TestExecService.cpp@ 62158

Last change on this file since 62158 was 62158, checked in by vboxsync, 9 years ago
ValidationKit/TestExecServ: Fix crc32 handling for stdin
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 119.9 KB

Line
1	/* $Id: TestExecService.cpp 62158 2016-07-11 12:33:42Z vboxsync $ */
2	/** @file
3	* TestExecServ - Basic Remote Execution Service.
4	*/
5
6	/*
7	* Copyright (C) 2010-2015 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27
28	/*********************************************************************************************************************************
29	* Header Files *
30	*********************************************************************************************************************************/
31	#define LOG_GROUP RTLOGGROUP_DEFAULT
32	#include <iprt/alloca.h>
33	#include <iprt/asm.h>
34	#include <iprt/assert.h>
35	#include <iprt/cdrom.h>
36	#include <iprt/critsect.h>
37	#include <iprt/crc.h>
38	#include <iprt/ctype.h>
39	#include <iprt/dir.h>
40	#include <iprt/env.h>
41	#include <iprt/err.h>
42	#include <iprt/file.h>
43	#include <iprt/getopt.h>
44	#include <iprt/handle.h>
45	#include <iprt/initterm.h>
46	#include <iprt/log.h>
47	#include <iprt/mem.h>
48	#include <iprt/message.h>
49	#include <iprt/param.h>
50	#include <iprt/path.h>
51	#include <iprt/pipe.h>
52	#include <iprt/poll.h>
53	#include <iprt/process.h>
54	#include <iprt/stream.h>
55	#include <iprt/string.h>
56	#include <iprt/system.h>
57	#include <iprt/thread.h>
58	#include <iprt/time.h>
59	#include <iprt/uuid.h>
60
61	#ifndef RT_OS_WINDOWS
62	# include <iprt/zip.h>
63	#endif
64
65	#include "TestExecServiceInternal.h"
66
67
68
69	/*********************************************************************************************************************************
70	* Structures and Typedefs *
71	*********************************************************************************************************************************/
72	/**
73	* Handle IDs used by txsDoExec for the poll set.
74	*/
75	typedef enum TXSEXECHNDID
76	{
77	TXSEXECHNDID_STDIN = 0,
78	TXSEXECHNDID_STDOUT,
79	TXSEXECHNDID_STDERR,
80	TXSEXECHNDID_TESTPIPE,
81	TXSEXECHNDID_STDIN_WRITABLE,
82	TXSEXECHNDID_TRANSPORT,
83	TXSEXECHNDID_THREAD
84	} TXSEXECHNDID;
85
86
87	/**
88	* For buffering process input supplied by the client.
89	*/
90	typedef struct TXSEXECSTDINBUF
91	{
92	/** The mount of buffered data. */
93	size_t cb;
94	/** The current data offset. */
95	size_t off;
96	/** The data buffer. */
97	char *pch;
98	/** The amount of allocated buffer space. */
99	size_t cbAllocated;
100	/** Send further input into the bit bucket (stdin is dead). */
101	bool fBitBucket;
102	/** The CRC-32 for standard input (received part). */
103	uint32_t uCrc32;
104	} TXSEXECSTDINBUF;
105	/** Pointer to a standard input buffer. */
106	typedef TXSEXECSTDINBUF *PTXSEXECSTDINBUF;
107
108	/**
109	* TXS child process info.
110	*/
111	typedef struct TXSEXEC
112	{
113	PCTXSPKTHDR pPktHdr;
114	RTMSINTERVAL cMsTimeout;
115	int rcReplySend;
116
117	RTPOLLSET hPollSet;
118	RTPIPE hStdInW;
119	RTPIPE hStdOutR;
120	RTPIPE hStdErrR;
121	RTPIPE hTestPipeR;
122	RTPIPE hWakeUpPipeR;
123	RTTHREAD hThreadWaiter;
124
125	/** @name For the setup phase
126	* @{ */
127	struct StdPipe
128	{
129	RTHANDLE hChild;
130	PRTHANDLE phChild;
131	} StdIn,
132	StdOut,
133	StdErr;
134	RTPIPE hTestPipeW;
135	RTENV hEnv;
136	/** @} */
137
138	/** For serializating some access. */
139	RTCRITSECT CritSect;
140	/** @name Members protected by the critical section.
141	* @{ */
142	RTPROCESS hProcess;
143	/** The process status. Only valid when fProcessAlive is cleared. */
144	RTPROCSTATUS ProcessStatus;
145	/** Set when the process is alive, clear when dead. */
146	bool volatile fProcessAlive;
147	/** The end of the pipe that hThreadWaiter writes to. */
148	RTPIPE hWakeUpPipeW;
149	/** @} */
150	} TXSEXEC;
151	/** Pointer to a the TXS child process info. */
152	typedef TXSEXEC *PTXSEXEC;
153
154
155	/*********************************************************************************************************************************
156	* Global Variables *
157	*********************************************************************************************************************************/
158	/**
159	* Transport layers.
160	*/
161	static const PCTXSTRANSPORT g_apTransports[] =
162	{
163	&g_TcpTransport,
164	//&g_SerialTransport,
165	//&g_FileSysTransport,
166	//&g_GuestPropTransport,
167	//&g_TestDevTransport,
168	};
169
170	/** The select transport layer. */
171	static PCTXSTRANSPORT g_pTransport;
172	/** The scratch path. */
173	static char g_szScratchPath[RTPATH_MAX];
174	/** The default scratch path. */
175	static char g_szDefScratchPath[RTPATH_MAX];
176	/** The CD/DVD-ROM path. */
177	static char g_szCdRomPath[RTPATH_MAX];
178	/** The default CD/DVD-ROM path. */
179	static char g_szDefCdRomPath[RTPATH_MAX];
180	/** The operating system short name. */
181	static char g_szOsShortName[16];
182	/** The CPU architecture short name. */
183	static char g_szArchShortName[16];
184	/** The combined "OS.arch" name. */
185	static char g_szOsDotArchShortName[32];
186	/** The combined "OS/arch" name. */
187	static char g_szOsSlashArchShortName[32];
188	/** The executable suffix. */
189	static char g_szExeSuff[8];
190	/** The shell script suffix. */
191	static char g_szScriptSuff[8];
192	/** UUID identifying this TXS instance. This can be used to see if TXS
193	* has been restarted or not. */
194	static RTUUID g_InstanceUuid;
195	/** Whether to display the output of the child process or not. */
196	static bool g_fDisplayOutput = true;
197	/** Whether to terminate or not.
198	* @todo implement signals and stuff. */
199	static bool volatile g_fTerminate = false;
200
201	/**
202	* Calculates the checksum value, zero any padding space and send the packet.
203	*
204	* @returns IPRT status code.
205	* @param pPkt The packet to send. Must point to a correctly
206	* aligned buffer.
207	*/
208	static int txsSendPkt(PTXSPKTHDR pPkt)
209	{
210	Assert(pPkt->cb >= sizeof(*pPkt));
211	pPkt->uCrc32 = RTCrc32(pPkt->achOpcode, pPkt->cb - RT_OFFSETOF(TXSPKTHDR, achOpcode));
212	if (pPkt->cb != RT_ALIGN_32(pPkt->cb, TXSPKT_ALIGNMENT))
213	memset((uint8_t *)pPkt + pPkt->cb, '\0', RT_ALIGN_32(pPkt->cb, TXSPKT_ALIGNMENT) - pPkt->cb);
214
215	Log(("txsSendPkt: cb=%#x opcode=%.8s\n", pPkt->cb, pPkt->achOpcode));
216	Log2(("%.*Rhxd\n", RT_MIN(pPkt->cb, 256), pPkt));
217	int rc = g_pTransport->pfnSendPkt(pPkt);
218	while (RT_UNLIKELY(rc == VERR_INTERRUPTED) && !g_fTerminate)
219	rc = g_pTransport->pfnSendPkt(pPkt);
220	if (RT_FAILURE(rc))
221	Log(("txsSendPkt: rc=%Rrc\n", rc));
222
223	return rc;
224	}
225
226	/**
227	* Sends a babble reply and disconnects the client (if applicable).
228	*
229	* @param pszOpcode The BABBLE opcode.
230	*/
231	static void txsReplyBabble(const char *pszOpcode)
232	{
233	TXSPKTHDR Reply;
234	Reply.cb = sizeof(Reply);
235	Reply.uCrc32 = 0;
236	memcpy(Reply.achOpcode, pszOpcode, sizeof(Reply.achOpcode));
237
238	g_pTransport->pfnBabble(&Reply, 20*1000);
239	}
240
241	/**
242	* Receive and validate a packet.
243	*
244	* Will send bable responses to malformed packets that results in a error status
245	* code.
246	*
247	* @returns IPRT status code.
248	* @param ppPktHdr Where to return the packet on success. Free
249	* with RTMemFree.
250	* @param fAutoRetryOnFailure Whether to retry on error.
251	*/
252	static int txsRecvPkt(PPTXSPKTHDR ppPktHdr, bool fAutoRetryOnFailure)
253	{
254	for (;;)
255	{
256	PTXSPKTHDR pPktHdr;
257	int rc = g_pTransport->pfnRecvPkt(&pPktHdr);
258	if (RT_SUCCESS(rc))
259	{
260	/* validate the packet. */
261	if ( pPktHdr->cb >= sizeof(TXSPKTHDR)
262	&& pPktHdr->cb < TXSPKT_MAX_SIZE)
263	{
264	Log2(("txsRecvPkt: pPktHdr=%p cb=%#x crc32=%#x opcode=%.8s\n"
265	"%.*Rhxd\n",
266	pPktHdr, pPktHdr->cb, pPktHdr->uCrc32, pPktHdr->achOpcode, RT_MIN(pPktHdr->cb, 256), pPktHdr));
267	uint32_t uCrc32Calc = pPktHdr->uCrc32 != 0
268	? RTCrc32(&pPktHdr->achOpcode[0], pPktHdr->cb - RT_OFFSETOF(TXSPKTHDR, achOpcode))
269	: 0;
270	if (pPktHdr->uCrc32 == uCrc32Calc)
271	{
272	AssertCompileMemberSize(TXSPKTHDR, achOpcode, 8);
273	if ( RT_C_IS_UPPER(pPktHdr->achOpcode[0])
274	&& RT_C_IS_UPPER(pPktHdr->achOpcode[1])
275	&& (RT_C_IS_UPPER(pPktHdr->achOpcode[2]) \|\| pPktHdr->achOpcode[2] == ' ')
276	&& (RT_C_IS_PRINT(pPktHdr->achOpcode[3]) \|\| pPktHdr->achOpcode[3] == ' ')
277	&& (RT_C_IS_PRINT(pPktHdr->achOpcode[4]) \|\| pPktHdr->achOpcode[4] == ' ')
278	&& (RT_C_IS_PRINT(pPktHdr->achOpcode[5]) \|\| pPktHdr->achOpcode[5] == ' ')
279	&& (RT_C_IS_PRINT(pPktHdr->achOpcode[6]) \|\| pPktHdr->achOpcode[6] == ' ')
280	&& (RT_C_IS_PRINT(pPktHdr->achOpcode[7]) \|\| pPktHdr->achOpcode[7] == ' ')
281	)
282	{
283	Log(("txsRecvPkt: cb=%#x opcode=%.8s\n", pPktHdr->cb, pPktHdr->achOpcode));
284	*ppPktHdr = pPktHdr;
285	return rc;
286	}
287
288	rc = VERR_IO_BAD_COMMAND;
289	}
290	else
291	{
292	Log(("txsRecvPkt: cb=%#x opcode=%.8s crc32=%#x actual=%#x\n",
293	pPktHdr->cb, pPktHdr->achOpcode, pPktHdr->uCrc32, uCrc32Calc));
294	rc = VERR_IO_CRC;
295	}
296	}
297	else
298	rc = VERR_IO_BAD_LENGTH;
299
300	/* Send babble reply and disconnect the client if the transport is
301	connection oriented. */
302	if (rc == VERR_IO_BAD_LENGTH)
303	txsReplyBabble("BABBLE L");
304	else if (rc == VERR_IO_CRC)
305	txsReplyBabble("BABBLE C");
306	else if (rc == VERR_IO_BAD_COMMAND)
307	txsReplyBabble("BABBLE O");
308	else
309	txsReplyBabble("BABBLE ");
310	RTMemFree(pPktHdr);
311	}
312
313	/* Try again or return failure? */
314	if ( g_fTerminate
315	\|\| rc != VERR_INTERRUPTED
316	\|\| !fAutoRetryOnFailure
317	)
318	{
319	Log(("txsRecvPkt: rc=%Rrc\n", rc));
320	return rc;
321	}
322	}
323	}
324
325	/**
326	* Make a simple reply, only status opcode.
327	*
328	* @returns IPRT status code of the send.
329	* @param pReply The reply packet.
330	* @param pszOpcode The status opcode. Exactly 8 chars long, padd
331	* with space.
332	* @param cbExtra Bytes in addition to the header.
333	*/
334	static int txsReplyInternal(PTXSPKTHDR pReply, const char *pszOpcode, size_t cbExtra)
335	{
336	/* copy the opcode, don't be too strict in case of a padding screw up. */
337	size_t cchOpcode = strlen(pszOpcode);
338	if (RT_LIKELY(cchOpcode == sizeof(pReply->achOpcode)))
339	memcpy(pReply->achOpcode, pszOpcode, sizeof(pReply->achOpcode));
340	else
341	{
342	Assert(cchOpcode == sizeof(pReply->achOpcode));
343	while (cchOpcode > 0 && pszOpcode[cchOpcode - 1] == ' ')
344	cchOpcode--;
345	AssertMsgReturn(cchOpcode < sizeof(pReply->achOpcode), ("%d/'%.8s'\n", cchOpcode, pszOpcode), VERR_INTERNAL_ERROR_4);
346	memcpy(pReply->achOpcode, pszOpcode, cchOpcode);
347	memset(&pReply->achOpcode[cchOpcode], ' ', sizeof(pReply->achOpcode) - cchOpcode);
348	}
349
350	pReply->cb = (uint32_t)sizeof(TXSPKTHDR) + (uint32_t)cbExtra;
351	pReply->uCrc32 = 0;
352
353	return txsSendPkt(pReply);
354	}
355
356	/**
357	* Make a simple reply, only status opcode.
358	*
359	* @returns IPRT status code of the send.
360	* @param pPktHdr The original packet (for future use).
361	* @param pszOpcode The status opcode. Exactly 8 chars long, padd
362	* with space.
363	*/
364	static int txsReplySimple(PCTXSPKTHDR pPktHdr, const char *pszOpcode)
365	{
366	TXSPKTHDR Pkt;
367	NOREF(pPktHdr);
368	return txsReplyInternal(&Pkt, pszOpcode, 0);
369	}
370
371	/**
372	* Acknowledges a packet with success.
373	*
374	* @returns IPRT status code of the send.
375	* @param pPktHdr The original packet (for future use).
376	*/
377	static int txsReplyAck(PCTXSPKTHDR pPktHdr)
378	{
379	return txsReplySimple(pPktHdr, "ACK ");
380	}
381
382	/**
383	* Replies with a failure.
384	*
385	* @returns IPRT status code of the send.
386	* @param pPktHdr The original packet (for future use).
387	* @param pszOpcode The status opcode. Exactly 8 chars long, padd
388	* with space.
389	* @param pszDetailsFmt Longer description of the problem (format
390	* string).
391	* @param va Format arguments.
392	*/
393	static int txsReplyFailureV(PCTXSPKTHDR pPktHdr, const char pszOpcode, const char pszDetailFmt, va_list va)
394	{
395	NOREF(pPktHdr);
396	union
397	{
398	TXSPKTHDR Hdr;
399	char ach[256];
400	} uPkt;
401
402	size_t cchDetail = RTStrPrintfV(&uPkt.ach[sizeof(TXSPKTHDR)],
403	sizeof(uPkt) - sizeof(TXSPKTHDR),
404	pszDetailFmt, va);
405	return txsReplyInternal(&uPkt.Hdr, pszOpcode, cchDetail + 1);
406	}
407
408	/**
409	* Replies with a failure.
410	*
411	* @returns IPRT status code of the send.
412	* @param pPktHdr The original packet (for future use).
413	* @param pszOpcode The status opcode. Exactly 8 chars long, padd
414	* with space.
415	* @param pszDetails Longer description of the problem (format
416	* string).
417	* @param ... Format arguments.
418	*/
419	static int txsReplyFailure(PCTXSPKTHDR pPktHdr, const char pszOpcode, const char pszDetailFmt, ...)
420	{
421	va_list va;
422	va_start(va, pszDetailFmt);
423	int rc = txsReplyFailureV(pPktHdr, pszOpcode, pszDetailFmt, va);
424	va_end(va);
425	return rc;
426	}
427
428	/**
429	* Replies according to the return code.
430	*
431	* @returns IPRT status code of the send.
432	* @param pPktHdr The packet to reply to.
433	* @param rcOperation The status code to report.
434	* @param pszOperationFmt The operation that failed. Typically giving the
435	* function call with important arguments.
436	* @param ... Arguments to the format string.
437	*/
438	static int txsReplyRC(PCTXSPKTHDR pPktHdr, int rcOperation, const char *pszOperationFmt, ...)
439	{
440	if (RT_SUCCESS(rcOperation))
441	return txsReplyAck(pPktHdr);
442
443	char szOperation[128];
444	va_list va;
445	va_start(va, pszOperationFmt);
446	RTStrPrintfV(szOperation, sizeof(szOperation), pszOperationFmt, va);
447	va_end(va);
448
449	return txsReplyFailure(pPktHdr, "FAILED ", "%s failed with rc=%Rrc (opcode '%.8s')",
450	szOperation, rcOperation, pPktHdr->achOpcode);
451	}
452
453	/**
454	* Signal a bad packet minum size.
455	*
456	* @returns IPRT status code of the send.
457	* @param pPktHdr The packet to reply to.
458	* @param cbMin The minimum size.
459	*/
460	static int txsReplyBadMinSize(PCTXSPKTHDR pPktHdr, size_t cbMin)
461	{
462	return txsReplyFailure(pPktHdr, "BAD SIZE", "Expected at least %zu bytes, got %u (opcode '%.8s')",
463	cbMin, pPktHdr->cb, pPktHdr->achOpcode);
464	}
465
466	/**
467	* Signal a bad packet exact size.
468	*
469	* @returns IPRT status code of the send.
470	* @param pPktHdr The packet to reply to.
471	* @param cb The wanted size.
472	*/
473	static int txsReplyBadSize(PCTXSPKTHDR pPktHdr, size_t cb)
474	{
475	return txsReplyFailure(pPktHdr, "BAD SIZE", "Expected at %zu bytes, got %u (opcode '%.8s')",
476	cb, pPktHdr->cb, pPktHdr->achOpcode);
477	}
478
479	/**
480	* Deals with a command that isn't implemented yet.
481	* @returns IPRT status code of the send.
482	* @param pPktHdr The packet which opcode isn't implemented.
483	*/
484	static int txsReplyNotImplemented(PCTXSPKTHDR pPktHdr)
485	{
486	return txsReplyFailure(pPktHdr, "NOT IMPL", "Opcode '%.8s' is not implemented", pPktHdr->achOpcode);
487	}
488
489	/**
490	* Deals with a unknown command.
491	* @returns IPRT status code of the send.
492	* @param pPktHdr The packet to reply to.
493	*/
494	static int txsReplyUnknown(PCTXSPKTHDR pPktHdr)
495	{
496	return txsReplyFailure(pPktHdr, "UNKNOWN ", "Opcode '%.8s' is not known", pPktHdr->achOpcode);
497	}
498
499	/**
500	* Replaces a variable with its value.
501	*
502	* @returns VINF_SUCCESS or VERR_NO_STR_MEMORY.
503	* @param ppszNew In/Out.
504	* @param pcchNew In/Out. (Messed up on failure.)
505	* @param offVar Variable offset.
506	* @param cchVar Variable length.
507	* @param pszValue The value.
508	* @param cchValue Value length.
509	*/
510	static int txsReplaceStringVariable(char *ppszNew, size_t pcchNew, size_t offVar, size_t cchVar,
511	const char *pszValue, size_t cchValue)
512	{
513	size_t const cchAfter = *pcchNew - offVar - cchVar;
514	if (cchVar < cchValue)
515	{
516	*pcchNew += cchValue - cchVar;
517	int rc = RTStrRealloc(ppszNew, *pcchNew + 1);
518	if (RT_FAILURE(rc))
519	return rc;
520	}
521
522	char pszNew = ppszNew;
523	memmove(&pszNew[offVar + cchValue], &pszNew[offVar + cchVar], cchAfter + 1);
524	memcpy(&pszNew[offVar], pszValue, cchValue);
525	return VINF_SUCCESS;
526	}
527
528	/**
529	* Replace the variables found in the source string, returning a new string that
530	* lives on the string heap.
531	*
532	* @returns Boolean success indicator. Will reply to the client with all the
533	* gory detail on failure.
534	* @param pPktHdr The packet the string relates to. For replying
535	* on error.
536	* @param pszSrc The source string.
537	* @param ppszNew Where to return the new string.
538	* @param prcSend Where to return the status code of the send on
539	* failure.
540	*/
541	static int txsReplaceStringVariables(PCTXSPKTHDR pPktHdr, const char pszSrc, char ppszNew, int prcSend)
542	{
543	/* Lazy approach that employs memmove. */
544	size_t cchNew = strlen(pszSrc);
545	char *pszNew = RTStrDup(pszSrc);
546	char *pszDollar = pszNew;
547	while ((pszDollar = strchr(pszDollar, '$')) != NULL)
548	{
549	if (pszDollar[1] == '{')
550	{
551	const char *pszEnd = strchr(&pszDollar[2], '}');
552	if (pszEnd)
553	{
554	#define IF_VARIABLE_DO(pszDollar, szVarExpr, pszValue) \
555	if ( cchVar == sizeof(szVarExpr) - 1 \
556	&& !memcmp(pszDollar, szVarExpr, sizeof(szVarExpr) - 1) ) \
557	{ \
558	size_t const cchValue = strlen(pszValue); \
559	rc = txsReplaceStringVariable(&pszNew, &cchNew, offDollar, \
560	sizeof(szVarExpr) - 1, pszValue, cchValue); \
561	offDollar += cchValue; \
562	}
563	int rc;
564	size_t const cchVar = pszEnd - pszDollar + 1; /* includes "${}" */
565	size_t offDollar = pszDollar - pszNew;
566	IF_VARIABLE_DO(pszDollar, "${CDROM}", g_szCdRomPath)
567	else IF_VARIABLE_DO(pszDollar, "${SCRATCH}", g_szScratchPath)
568	else IF_VARIABLE_DO(pszDollar, "${ARCH}", g_szArchShortName)
569	else IF_VARIABLE_DO(pszDollar, "${OS}", g_szOsShortName)
570	else IF_VARIABLE_DO(pszDollar, "${OS.ARCH}", g_szOsDotArchShortName)
571	else IF_VARIABLE_DO(pszDollar, "${OS/ARCH}", g_szOsSlashArchShortName)
572	else IF_VARIABLE_DO(pszDollar, "${EXESUFF}", g_szExeSuff)
573	else IF_VARIABLE_DO(pszDollar, "${SCRIPTSUFF}", g_szScriptSuff)
574	else
575	{
576	RTStrFree(pszNew);
577	prcSend = txsReplyFailure(pPktHdr, "UNKN VAR", "Unknown variable '%.s' encountered in '%s'",
578	cchVar, pszDollar, pszSrc);
579	*ppszNew = NULL;
580	return false;
581	}
582	pszDollar = &pszNew[offDollar];
583
584	if (RT_FAILURE(rc))
585	{
586	RTStrFree(pszNew);
587	*prcSend = txsReplyRC(pPktHdr, rc, "RTStrRealloc");
588	*ppszNew = NULL;
589	return false;
590	}
591	#undef IF_VARIABLE_DO
592	}
593	}
594	}
595
596	*ppszNew = pszNew;
597	*prcSend = VINF_SUCCESS;
598	return true;
599	}
600
601	/**
602	* Checks if the string is valid and returns the expanded version.
603	*
604	* @returns true if valid, false if invalid.
605	* @param pPktHdr The packet being unpacked.
606	* @param pszArgName The argument name.
607	* @param psz Pointer to the string within pPktHdr.
608	* @param ppszExp Where to return the expanded string. Must be
609	* freed by calling RTStrFree().
610	* @param ppszNext Where to return the pointer to the next field.
611	* If NULL, then we assume this string is at the
612	* end of the packet and will make sure it has the
613	* advertised length.
614	* @param prcSend Where to return the status code of the send on
615	* failure.
616	*/
617	static bool txsIsStringValid(PCTXSPKTHDR pPktHdr, const char pszArgName, const char psz,
618	char ppszExp, const char ppszNext, int *prcSend)
619	{
620	*ppszExp = NULL;
621	if (ppszNext)
622	*ppszNext = NULL;
623
624	size_t const off = psz - (const char *)pPktHdr;
625	if (pPktHdr->cb <= off)
626	{
627	*prcSend = txsReplyFailure(pPktHdr, "STR MISS", "Missing string argument '%s' in '%.8s'",
628	pszArgName, pPktHdr->achOpcode);
629	return false;
630	}
631
632	size_t const cchMax = pPktHdr->cb - off;
633	const char *pszEnd = RTStrEnd(psz, cchMax);
634	if (!pszEnd)
635	{
636	*prcSend = txsReplyFailure(pPktHdr, "STR TERM", "The string argument '%s' in '%.8s' is unterminated",
637	pszArgName, pPktHdr->achOpcode);
638	return false;
639	}
640
641	if (!ppszNext && (size_t)(pszEnd - psz) != cchMax - 1)
642	{
643	*prcSend = txsReplyFailure(pPktHdr, "STR SHRT", "The string argument '%s' in '%.8s' is shorter than advertised",
644	pszArgName, pPktHdr->achOpcode);
645	return false;
646	}
647
648	if (!txsReplaceStringVariables(pPktHdr, psz, ppszExp, prcSend))
649	return false;
650	if (ppszNext)
651	*ppszNext = pszEnd + 1;
652	return true;
653	}
654
655	/**
656	* Validates a packet with a single string after the header.
657	*
658	* @returns true if valid, false if invalid.
659	* @param pPktHdr The packet.
660	* @param pszArgName The argument name.
661	* @param ppszExp Where to return the string pointer. Variables
662	* will be replaced and it must therefore be freed
663	* by calling RTStrFree().
664	* @param prcSend Where to return the status code of the send on
665	* failure.
666	*/
667	static bool txsIsStringPktValid(PCTXSPKTHDR pPktHdr, const char pszArgName, char ppszExp, int prcSend)
668	{
669	if (pPktHdr->cb < sizeof(TXSPKTHDR) + 2)
670	{
671	*ppszExp = NULL;
672	*prcSend = txsReplyBadMinSize(pPktHdr, sizeof(TXSPKTHDR) + 2);
673	return false;
674	}
675
676	return txsIsStringValid(pPktHdr, pszArgName, (const char *)(pPktHdr + 1), ppszExp, NULL, prcSend);
677	}
678
679	/**
680	* Checks if the two opcodes match.
681	*
682	* @returns true on match, false on mismatch.
683	* @param pPktHdr The packet header.
684	* @param pszOpcode2 The opcode we're comparing with. Does not have
685	* to be the whole 8 chars long.
686	*/
687	DECLINLINE(bool) txsIsSameOpcode(PCTXSPKTHDR pPktHdr, const char *pszOpcode2)
688	{
689	if (pPktHdr->achOpcode[0] != pszOpcode2[0])
690	return false;
691	if (pPktHdr->achOpcode[1] != pszOpcode2[1])
692	return false;
693
694	unsigned i = 2;
695	while ( i < RT_SIZEOFMEMB(TXSPKTHDR, achOpcode)
696	&& pszOpcode2[i] != '\0')
697	{
698	if (pPktHdr->achOpcode[i] != pszOpcode2[i])
699	break;
700	i++;
701	}
702
703	if ( i < RT_SIZEOFMEMB(TXSPKTHDR, achOpcode)
704	&& pszOpcode2[i] == '\0')
705	{
706	while ( i < RT_SIZEOFMEMB(TXSPKTHDR, achOpcode)
707	&& pPktHdr->achOpcode[i] == ' ')
708	i++;
709	}
710
711	return i == RT_SIZEOFMEMB(TXSPKTHDR, achOpcode);
712	}
713
714	/**
715	* Used by txsDoGetFile to wait for a reply ACK from the client.
716	*
717	* @returns VINF_SUCCESS on ACK, VERR_GENERAL_FAILURE on NACK,
718	* VERR_NET_NOT_CONNECTED on unknown response (sending a bable reply),
719	* or whatever txsRecvPkt returns.
720	* @param pPktHdr The original packet (for future use).
721	*/
722	static int txsWaitForAck(PCTXSPKTHDR pPktHdr)
723	{
724	NOREF(pPktHdr);
725	/** @todo timeout? */
726	PTXSPKTHDR pReply;
727	int rc = txsRecvPkt(&pReply, false /fAutoRetryOnFailure/);
728	if (RT_SUCCESS(rc))
729	{
730	if (txsIsSameOpcode(pReply, "ACK"))
731	rc = VINF_SUCCESS;
732	else if (txsIsSameOpcode(pReply, "NACK"))
733	rc = VERR_GENERAL_FAILURE;
734	else
735	{
736	txsReplyBabble("BABBLE ");
737	rc = VERR_NET_NOT_CONNECTED;
738	}
739	RTMemFree(pReply);
740	}
741	return rc;
742	}
743
744	#ifndef RT_OS_WINDOWS
745	/**
746	* Unpacks a tar file.
747	*
748	* @returns IPRT status code from send.
749	* @param pPktHdr The unpack file packet.
750	*/
751	static int txsDoUnpackFile(PCTXSPKTHDR pPktHdr)
752	{
753	int rc;
754	char *pszFile = NULL;
755	char *pszDirectory = NULL;
756
757	/* Packet cursor. */
758	const char pchEnd = (const char )pPktHdr + pPktHdr->cb;
759	const char pch = (const char )(pPktHdr + 1);
760
761	if (txsIsStringValid(pPktHdr, "file", pch, &pszFile, &pch, &rc))
762	{
763	if (txsIsStringValid(pPktHdr, "directory", pch, &pszDirectory, &pch, &rc))
764	{
765	char *pszSuff = RTPathSuffix(pszFile);
766
767	const char *apszArgs[7];
768	unsigned cArgs = 0;
769
770	apszArgs[cArgs++] = "RTTar";
771	apszArgs[cArgs++] = "--extract";
772
773	apszArgs[cArgs++] = "--file";
774	apszArgs[cArgs++] = pszFile;
775
776	apszArgs[cArgs++] = "--directory";
777	apszArgs[cArgs++] = pszDirectory;
778
779	if ( pszSuff
780	&& ( !RTStrICmp(pszSuff, ".gz")
781	\|\| !RTStrICmp(pszSuff, ".tgz")))
782	apszArgs[cArgs++] = "--gunzip";
783
784	RTEXITCODE rcExit = RTZipTarCmd(cArgs, (char **)apszArgs);
785	if (rcExit != RTEXITCODE_SUCCESS)
786	rc = VERR_GENERAL_FAILURE; /** @todo proper return code. */
787	else
788	rc = VINF_SUCCESS;
789
790	rc = txsReplyRC(pPktHdr, rc, "RTZipTarCmd(\"%s\",\"%s\")",
791	pszFile, pszDirectory);
792
793	RTStrFree(pszDirectory);
794	}
795	RTStrFree(pszFile);
796	}
797
798	return rc;
799	}
800	#endif
801
802	/**
803	* Downloads a file to the client.
804	*
805	* The transfer sends a stream of DATA packets (0 or more) and ends it all with
806	* a ACK packet. If an error occurs, a FAILURE packet is sent and the transfer
807	* aborted.
808	*
809	* @returns IPRT status code from send.
810	* @param pPktHdr The get file packet.
811	*/
812	static int txsDoGetFile(PCTXSPKTHDR pPktHdr)
813	{
814	int rc;
815	char *pszPath;
816	if (!txsIsStringPktValid(pPktHdr, "file", &pszPath, &rc))
817	return rc;
818
819	RTFILE hFile;
820	rc = RTFileOpen(&hFile, pszPath, RTFILE_O_READ \| RTFILE_O_DENY_WRITE \| RTFILE_O_OPEN);
821	if (RT_SUCCESS(rc))
822	{
823	uint32_t uMyCrc32 = RTCrc32Start();
824	for (;;)
825	{
826	struct
827	{
828	TXSPKTHDR Hdr;
829	uint32_t uCrc32;
830	char ab[_64K];
831	char abPadding[TXSPKT_ALIGNMENT];
832	} Pkt;
833	size_t cbRead;
834	rc = RTFileRead(hFile, &Pkt.ab[0], _64K, &cbRead);
835	if (RT_FAILURE(rc) \|\| cbRead == 0)
836	{
837	if (rc == VERR_EOF \|\| (RT_SUCCESS(rc) && cbRead == 0))
838	{
839	Pkt.uCrc32 = RTCrc32Finish(uMyCrc32);
840	rc = txsReplyInternal(&Pkt.Hdr, "DATA EOF", sizeof(uint32_t));
841	if (RT_SUCCESS(rc))
842	rc = txsWaitForAck(&Pkt.Hdr);
843	}
844	else
845	rc = txsReplyRC(pPktHdr, rc, "RTFileRead");
846	break;
847	}
848
849	uMyCrc32 = RTCrc32Process(uMyCrc32, &Pkt.ab[0], cbRead);
850	Pkt.uCrc32 = RTCrc32Finish(uMyCrc32);
851	rc = txsReplyInternal(&Pkt.Hdr, "DATA ", cbRead + sizeof(uint32_t));
852	if (RT_FAILURE(rc))
853	break;
854	rc = txsWaitForAck(&Pkt.Hdr);
855	if (RT_FAILURE(rc))
856	break;
857	}
858
859	RTFileClose(hFile);
860	}
861	else
862	rc = txsReplyRC(pPktHdr, rc, "RTFileOpen(,\"%s\",)", pszPath);
863
864	RTStrFree(pszPath);
865	return rc;
866	}
867
868	/**
869	* Uploads a file from the client.
870	*
871	* The transfer sends a stream of DATA packets (0 or more) and ends it all with
872	* a DATA EOF packet. We ACK each of these, so that if a write error occurs we
873	* can abort the transfer straight away.
874	*
875	* @returns IPRT status code from send.
876	* @param pPktHdr The put file packet.
877	*/
878	static int txsDoPutFile(PCTXSPKTHDR pPktHdr)
879	{
880	int rc;
881	char *pszPath;
882	if (!txsIsStringPktValid(pPktHdr, "file", &pszPath, &rc))
883	return rc;
884
885	RTFILE hFile;
886	rc = RTFileOpen(&hFile, pszPath, RTFILE_O_WRITE \| RTFILE_O_DENY_WRITE \| RTFILE_O_CREATE_REPLACE);
887	if (RT_SUCCESS(rc))
888	{
889	bool fSuccess = false;
890	rc = txsReplyAck(pPktHdr);
891	if (RT_SUCCESS(rc))
892	{
893	/*
894	* Read client command packets and process them.
895	*/
896	uint32_t uMyCrc32 = RTCrc32Start();
897	for (;;)
898	{
899	PTXSPKTHDR pDataPktHdr;
900	rc = txsRecvPkt(&pDataPktHdr, false /fAutoRetryOnFailure/);
901	if (RT_FAILURE(rc))
902	break;
903
904	if (txsIsSameOpcode(pDataPktHdr, "DATA"))
905	{
906	size_t const cbMin = sizeof(TXSPKTHDR) + sizeof(uint32_t);
907	if (pDataPktHdr->cb >= cbMin)
908	{
909	size_t cbData = pDataPktHdr->cb - cbMin;
910	const void pvData = (const char )pDataPktHdr + cbMin;
911	uint32_t uCrc32 = (uint32_t const )(pDataPktHdr + 1);
912
913	uMyCrc32 = RTCrc32Process(uMyCrc32, pvData, cbData);
914	if (RTCrc32Finish(uMyCrc32) == uCrc32)
915	{
916	rc = RTFileWrite(hFile, pvData, cbData, NULL);
917	if (RT_SUCCESS(rc))
918	{
919	rc = txsReplyAck(pDataPktHdr);
920	RTMemFree(pDataPktHdr);
921	continue;
922	}
923
924	rc = txsReplyRC(pDataPktHdr, rc, "RTFileWrite");
925	}
926	else
927	rc = txsReplyFailure(pDataPktHdr, "BAD DCRC", "mycrc=%#x your=%#x", uMyCrc32, uCrc32);
928	}
929	else
930	rc = txsReplyBadMinSize(pPktHdr, cbMin);
931	}
932	else if (txsIsSameOpcode(pDataPktHdr, "DATA EOF"))
933	{
934	if (pDataPktHdr->cb == sizeof(TXSPKTHDR) + sizeof(uint32_t))
935	{
936	uint32_t uCrc32 = (uint32_t const )(pDataPktHdr + 1);
937	if (RTCrc32Finish(uMyCrc32) == uCrc32)
938	{
939	rc = txsReplyAck(pDataPktHdr);
940	fSuccess = RT_SUCCESS(rc);
941	}
942	else
943	rc = txsReplyFailure(pDataPktHdr, "BAD DCRC", "mycrc=%#x your=%#x", uMyCrc32, uCrc32);
944	}
945	else
946	rc = txsReplyAck(pDataPktHdr);
947	}
948	else if (txsIsSameOpcode(pDataPktHdr, "ABORT"))
949	rc = txsReplyAck(pDataPktHdr);
950	else
951	rc = txsReplyFailure(pDataPktHdr, "UNKNOWN ", "Opcode '%.8s' is not known or not recognized during PUT FILE", pDataPktHdr->achOpcode);
952	RTMemFree(pDataPktHdr);
953	break;
954	}
955	}
956
957	RTFileClose(hFile);
958
959	/*
960	* Delete the file on failure.
961	*/
962	if (!fSuccess)
963	RTFileDelete(pszPath);
964	}
965	else
966	rc = txsReplyRC(pPktHdr, rc, "RTFileOpen(,\"%s\",)", pszPath);
967
968	RTStrFree(pszPath);
969	return rc;
970	}
971
972	/**
973	* List the entries in the specified directory.
974	*
975	* @returns IPRT status code from send.
976	* @param pPktHdr The list packet.
977	*/
978	static int txsDoList(PCTXSPKTHDR pPktHdr)
979	{
980	int rc;
981	char *pszPath;
982	if (!txsIsStringPktValid(pPktHdr, "dir", &pszPath, &rc))
983	return rc;
984
985	rc = txsReplyNotImplemented(pPktHdr);
986
987	RTStrFree(pszPath);
988	return rc;
989	}
990
991
992	/**
993	* Get info about a file system object, following all but the symbolic links
994	* except in the final path component.
995	*
996	* @returns IPRT status code from send.
997	* @param pPktHdr The lstat packet.
998	*/
999	static int txsDoLStat(PCTXSPKTHDR pPktHdr)
1000	{
1001	int rc;
1002	char *pszPath;
1003	if (!txsIsStringPktValid(pPktHdr, "path", &pszPath, &rc))
1004	return rc;
1005
1006	RTFSOBJINFO Info;
1007	rc = RTPathQueryInfoEx(pszPath, &Info, RTFSOBJATTRADD_UNIX, RTPATH_F_ON_LINK);
1008	if (RT_SUCCESS(rc))
1009	/** @todo figure out how to format the return buffer here. */
1010	rc = txsReplyNotImplemented(pPktHdr);
1011	else
1012	rc = txsReplyRC(pPktHdr, rc, "RTPathQueryInfoEx(\"%s\",,UNIX,ON_LINK)", pszPath);
1013
1014	RTStrFree(pszPath);
1015	return rc;
1016	}
1017
1018	/**
1019	* Get info about a file system object, following all symbolic links.
1020	*
1021	* @returns IPRT status code from send.
1022	* @param pPktHdr The stat packet.
1023	*/
1024	static int txsDoStat(PCTXSPKTHDR pPktHdr)
1025	{
1026	int rc;
1027	char *pszPath;
1028	if (!txsIsStringPktValid(pPktHdr, "path", &pszPath, &rc))
1029	return rc;
1030
1031	RTFSOBJINFO Info;
1032	rc = RTPathQueryInfoEx(pszPath, &Info, RTFSOBJATTRADD_UNIX, RTPATH_F_FOLLOW_LINK);
1033	if (RT_SUCCESS(rc))
1034	/** @todo figure out how to format the return buffer here. */
1035	rc = txsReplyNotImplemented(pPktHdr);
1036	else
1037	rc = txsReplyRC(pPktHdr, rc, "RTPathQueryInfoEx(\"%s\",,UNIX,FOLLOW_LINK)", pszPath);
1038
1039	RTStrFree(pszPath);
1040	return rc;
1041	}
1042
1043	/**
1044	* Checks if the specified path is a symbolic link.
1045	*
1046	* @returns IPRT status code from send.
1047	* @param pPktHdr The issymlnk packet.
1048	*/
1049	static int txsDoIsSymlnk(PCTXSPKTHDR pPktHdr)
1050	{
1051	int rc;
1052	char *pszPath;
1053	if (!txsIsStringPktValid(pPktHdr, "symlink", &pszPath, &rc))
1054	return rc;
1055
1056	RTFSOBJINFO Info;
1057	rc = RTPathQueryInfoEx(pszPath, &Info, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
1058	if (RT_SUCCESS(rc) && RTFS_IS_SYMLINK(Info.Attr.fMode))
1059	rc = txsReplySimple(pPktHdr, "TRUE ");
1060	else
1061	rc = txsReplySimple(pPktHdr, "FALSE ");
1062
1063	RTStrFree(pszPath);
1064	return rc;
1065	}
1066
1067	/**
1068	* Checks if the specified path is a file or not.
1069	*
1070	* If the final path element is a symbolic link to a file, we'll return
1071	* FALSE.
1072	*
1073	* @returns IPRT status code from send.
1074	* @param pPktHdr The isfile packet.
1075	*/
1076	static int txsDoIsFile(PCTXSPKTHDR pPktHdr)
1077	{
1078	int rc;
1079	char *pszPath;
1080	if (!txsIsStringPktValid(pPktHdr, "dir", &pszPath, &rc))
1081	return rc;
1082
1083	RTFSOBJINFO Info;
1084	rc = RTPathQueryInfoEx(pszPath, &Info, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
1085	if (RT_SUCCESS(rc) && RTFS_IS_FILE(Info.Attr.fMode))
1086	rc = txsReplySimple(pPktHdr, "TRUE ");
1087	else
1088	rc = txsReplySimple(pPktHdr, "FALSE ");
1089
1090	RTStrFree(pszPath);
1091	return rc;
1092	}
1093
1094	/**
1095	* Checks if the specified path is a directory or not.
1096	*
1097	* If the final path element is a symbolic link to a directory, we'll return
1098	* FALSE.
1099	*
1100	* @returns IPRT status code from send.
1101	* @param pPktHdr The isdir packet.
1102	*/
1103	static int txsDoIsDir(PCTXSPKTHDR pPktHdr)
1104	{
1105	int rc;
1106	char *pszPath;
1107	if (!txsIsStringPktValid(pPktHdr, "dir", &pszPath, &rc))
1108	return rc;
1109
1110	RTFSOBJINFO Info;
1111	rc = RTPathQueryInfoEx(pszPath, &Info, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
1112	if (RT_SUCCESS(rc) && RTFS_IS_DIRECTORY(Info.Attr.fMode))
1113	rc = txsReplySimple(pPktHdr, "TRUE ");
1114	else
1115	rc = txsReplySimple(pPktHdr, "FALSE ");
1116
1117	RTStrFree(pszPath);
1118	return rc;
1119	}
1120
1121	/**
1122	* Changes the group of a file, directory of symbolic link.
1123	*
1124	* @returns IPRT status code from send.
1125	* @param pPktHdr The chmod packet.
1126	*/
1127	static int txsDoChGrp(PCTXSPKTHDR pPktHdr)
1128	{
1129	return txsReplyNotImplemented(pPktHdr);
1130	}
1131
1132	/**
1133	* Changes the owner of a file, directory of symbolic link.
1134	*
1135	* @returns IPRT status code from send.
1136	* @param pPktHdr The chmod packet.
1137	*/
1138	static int txsDoChOwn(PCTXSPKTHDR pPktHdr)
1139	{
1140	return txsReplyNotImplemented(pPktHdr);
1141	}
1142
1143	/**
1144	* Changes the mode of a file or directory.
1145	*
1146	* @returns IPRT status code from send.
1147	* @param pPktHdr The chmod packet.
1148	*/
1149	static int txsDoChMod(PCTXSPKTHDR pPktHdr)
1150	{
1151	return txsReplyNotImplemented(pPktHdr);
1152	}
1153
1154	/**
1155	* Removes a directory tree.
1156	*
1157	* @returns IPRT status code from send.
1158	* @param pPktHdr The rmtree packet.
1159	*/
1160	static int txsDoRmTree(PCTXSPKTHDR pPktHdr)
1161	{
1162	int rc;
1163	char *pszPath;
1164	if (!txsIsStringPktValid(pPktHdr, "dir", &pszPath, &rc))
1165	return rc;
1166
1167	rc = RTDirRemoveRecursive(pszPath, 0 /fFlags/);
1168
1169	rc = txsReplyRC(pPktHdr, rc, "RTDirRemoveRecusive(\"%s\",0)", pszPath);
1170	RTStrFree(pszPath);
1171	return rc;
1172	}
1173
1174	/**
1175	* Removes a symbolic link.
1176	*
1177	* @returns IPRT status code from send.
1178	* @param pPktHdr The rmsymlink packet.
1179	*/
1180	static int txsDoRmSymlnk(PCTXSPKTHDR pPktHdr)
1181	{
1182	int rc;
1183	char *pszPath;
1184	if (!txsIsStringPktValid(pPktHdr, "symlink", &pszPath, &rc))
1185	return rc;
1186
1187	rc = VERR_NOT_IMPLEMENTED; /// @todo RTSymlinkDelete(pszPath);
1188
1189	rc = txsReplyRC(pPktHdr, rc, "RTSymlinkDelete(\"%s\")", pszPath);
1190	RTStrFree(pszPath);
1191	return rc;
1192	}
1193
1194	/**
1195	* Removes a file.
1196	*
1197	* @returns IPRT status code from send.
1198	* @param pPktHdr The rmfile packet.
1199	*/
1200	static int txsDoRmFile(PCTXSPKTHDR pPktHdr)
1201	{
1202	int rc;
1203	char *pszPath;
1204	if (!txsIsStringPktValid(pPktHdr, "file", &pszPath, &rc))
1205	return rc;
1206
1207	rc = RTFileDelete(pszPath);
1208
1209	rc = txsReplyRC(pPktHdr, rc, "RTFileDelete(\"%s\")", pszPath);
1210	RTStrFree(pszPath);
1211	return rc;
1212	}
1213
1214	/**
1215	* Removes a directory.
1216	*
1217	* @returns IPRT status code from send.
1218	* @param pPktHdr The rmdir packet.
1219	*/
1220	static int txsDoRmDir(PCTXSPKTHDR pPktHdr)
1221	{
1222	int rc;
1223	char *pszPath;
1224	if (!txsIsStringPktValid(pPktHdr, "dir", &pszPath, &rc))
1225	return rc;
1226
1227	rc = RTDirRemove(pszPath);
1228
1229	rc = txsReplyRC(pPktHdr, rc, "RTDirRemove(\"%s\")", pszPath);
1230	RTStrFree(pszPath);
1231	return rc;
1232	}
1233
1234	/**
1235	* Creates a symbolic link.
1236	*
1237	* @returns IPRT status code from send.
1238	* @param pPktHdr The mksymlnk packet.
1239	*/
1240	static int txsDoMkSymlnk(PCTXSPKTHDR pPktHdr)
1241	{
1242	return txsReplyNotImplemented(pPktHdr);
1243	}
1244
1245	/**
1246	* Creates a directory and all its parents.
1247	*
1248	* @returns IPRT status code from send.
1249	* @param pPktHdr The mkdir -p packet.
1250	*/
1251	static int txsDoMkDrPath(PCTXSPKTHDR pPktHdr)
1252	{
1253	/* The same format as the MKDIR command. */
1254	if (pPktHdr->cb < sizeof(TXSPKTHDR) + sizeof(RTFMODE) + 2)
1255	return txsReplyBadMinSize(pPktHdr, sizeof(TXSPKTHDR) + sizeof(RTFMODE) + 2);
1256
1257	int rc;
1258	char *pszPath;
1259	if (!txsIsStringValid(pPktHdr, "dir", (const char *)(pPktHdr + 1) + sizeof(RTFMODE), &pszPath, NULL, &rc))
1260	return rc;
1261
1262	RTFMODE fMode = (RTFMODE const )(pPktHdr + 1);
1263	rc = RTDirCreateFullPath(pszPath, fMode);
1264
1265	rc = txsReplyRC(pPktHdr, rc, "RTDirCreateFullPath(\"%s\", %#x)", pszPath, fMode);
1266	RTStrFree(pszPath);
1267	return rc;
1268	}
1269
1270	/**
1271	* Creates a directory.
1272	*
1273	* @returns IPRT status code from send.
1274	* @param pPktHdr The mkdir packet.
1275	*/
1276	static int txsDoMkDir(PCTXSPKTHDR pPktHdr)
1277	{
1278	/* After the packet header follows a mode mask and the remainder of
1279	the packet is the zero terminated directory name. */
1280	size_t const cbMin = sizeof(TXSPKTHDR) + sizeof(RTFMODE) + 2;
1281	if (pPktHdr->cb < cbMin)
1282	return txsReplyBadMinSize(pPktHdr, cbMin);
1283
1284	int rc;
1285	char *pszPath;
1286	if (!txsIsStringValid(pPktHdr, "dir", (const char *)(pPktHdr + 1) + sizeof(RTFMODE), &pszPath, NULL, &rc))
1287	return rc;
1288
1289	RTFMODE fMode = (RTFMODE const )(pPktHdr + 1);
1290	rc = RTDirCreate(pszPath, fMode, 0);
1291
1292	rc = txsReplyRC(pPktHdr, rc, "RTDirCreate(\"%s\", %#x)", pszPath, fMode);
1293	RTStrFree(pszPath);
1294	return rc;
1295	}
1296
1297	/**
1298	* Cleans up the scratch area.
1299	*
1300	* @returns IPRT status code from send.
1301	* @param pPktHdr The shutdown packet.
1302	*/
1303	static int txsDoCleanup(PCTXSPKTHDR pPktHdr)
1304	{
1305	int rc = RTDirRemoveRecursive(g_szScratchPath, RTDIRRMREC_F_CONTENT_ONLY);
1306	return txsReplyRC(pPktHdr, rc, "RTDirRemoveRecursive(\"%s\", CONTENT_ONLY)", g_szScratchPath);
1307	}
1308
1309	/**
1310	* Ejects the specified DVD/CD drive.
1311	*
1312	* @returns IPRT status code from send.
1313	* @param pPktHdr The eject packet.
1314	*/
1315	static int txsDoCdEject(PCTXSPKTHDR pPktHdr)
1316	{
1317	/* After the packet header follows a uint32_t ordinal. */
1318	size_t const cbExpected = sizeof(TXSPKTHDR) + sizeof(uint32_t);
1319	if (pPktHdr->cb != cbExpected)
1320	return txsReplyBadSize(pPktHdr, cbExpected);
1321	uint32_t iOrdinal = (uint32_t const )(pPktHdr + 1);
1322
1323	RTCDROM hCdrom;
1324	int rc = RTCdromOpenByOrdinal(iOrdinal, RTCDROM_O_CONTROL, &hCdrom);
1325	if (RT_FAILURE(rc))
1326	return txsReplyRC(pPktHdr, rc, "RTCdromOpenByOrdinal(%u, RTCDROM_O_CONTROL, )", iOrdinal);
1327	rc = RTCdromEject(hCdrom, true /fForce/);
1328	RTCdromRelease(hCdrom);
1329
1330	return txsReplyRC(pPktHdr, rc, "RTCdromEject(ord=%u, fForce=true)", iOrdinal);
1331	}
1332
1333	/**
1334	* Common worker for txsDoShutdown and txsDoReboot.
1335	*
1336	* @returns IPRT status code from send.
1337	* @param pPktHdr The reboot packet.
1338	* @param fAction Which action to take.
1339	*/
1340	static int txsCommonShutdownReboot(PCTXSPKTHDR pPktHdr, uint32_t fAction)
1341	{
1342	/*
1343	* We ACK the reboot & shutdown before actually performing them, then we
1344	* terminate the transport layer.
1345	*
1346	* This is to make sure the client isn't stuck with a dead connection. The
1347	* transport layer termination also make sure we won't accept new
1348	* connections in case the client is too eager to reconnect to a rebooted
1349	* test victim. On the down side, we cannot easily report RTSystemShutdown
1350	* failures failures this way. But the client can kind of figure it out by
1351	* reconnecting and seeing that our UUID was unchanged.
1352	*/
1353	int rc;
1354	if (pPktHdr->cb != sizeof(TXSPKTHDR))
1355	return txsReplyBadSize(pPktHdr, sizeof(TXSPKTHDR));
1356	g_pTransport->pfnNotifyReboot();
1357	rc = txsReplyAck(pPktHdr);
1358	RTThreadSleep(2560); /* fudge factor */
1359	g_pTransport->pfnTerm();
1360
1361	/*
1362	* Do the job, if it fails we'll restart the transport layer.
1363	*/
1364	#if 0
1365	rc = VINF_SUCCESS;
1366	#else
1367	rc = RTSystemShutdown(0 /cMsDelay/,
1368	fAction \| RTSYSTEM_SHUTDOWN_PLANNED \| RTSYSTEM_SHUTDOWN_FORCE,
1369	"Test Execution Service");
1370	#endif
1371	if (RT_SUCCESS(rc))
1372	{
1373	RTMsgInfo(fAction == RTSYSTEM_SHUTDOWN_REBOOT ? "Rebooting...\n" : "Shutting down...\n");
1374	g_fTerminate = true;
1375	}
1376	else
1377	{
1378	RTMsgError("RTSystemShutdown w/ fAction=%#x failed: %Rrc", fAction, rc);
1379
1380	int rc2 = g_pTransport->pfnInit();
1381	if (RT_FAILURE(rc2))
1382	{
1383	g_fTerminate = true;
1384	rc = rc2;
1385	}
1386	}
1387	return rc;
1388	}
1389
1390	/**
1391	* Shuts down the machine, powering it off if possible.
1392	*
1393	* @returns IPRT status code from send.
1394	* @param pPktHdr The shutdown packet.
1395	*/
1396	static int txsDoShutdown(PCTXSPKTHDR pPktHdr)
1397	{
1398	return txsCommonShutdownReboot(pPktHdr, RTSYSTEM_SHUTDOWN_POWER_OFF_HALT);
1399	}
1400
1401	/**
1402	* Reboots the machine.
1403	*
1404	* @returns IPRT status code from send.
1405	* @param pPktHdr The reboot packet.
1406	*/
1407	static int txsDoReboot(PCTXSPKTHDR pPktHdr)
1408	{
1409	return txsCommonShutdownReboot(pPktHdr, RTSYSTEM_SHUTDOWN_REBOOT);
1410	}
1411
1412	/**
1413	* Verifies and acknowledges a "UUID" request.
1414	*
1415	* @returns IPRT status code.
1416	* @param pPktHdr The howdy packet.
1417	*/
1418	static int txsDoUuid(PCTXSPKTHDR pPktHdr)
1419	{
1420	if (pPktHdr->cb != sizeof(TXSPKTHDR))
1421	return txsReplyBadSize(pPktHdr, sizeof(TXSPKTHDR));
1422
1423	struct
1424	{
1425	TXSPKTHDR Hdr;
1426	char szUuid[RTUUID_STR_LENGTH];
1427	char abPadding[TXSPKT_ALIGNMENT];
1428	} Pkt;
1429
1430	int rc = RTUuidToStr(&g_InstanceUuid, Pkt.szUuid, sizeof(Pkt.szUuid));
1431	if (RT_FAILURE(rc))
1432	return txsReplyRC(pPktHdr, rc, "RTUuidToStr");
1433	return txsReplyInternal(&Pkt.Hdr, "ACK UUID", strlen(Pkt.szUuid) + 1);
1434	}
1435
1436	/**
1437	* Verifies and acknowledges a "BYE" request.
1438	*
1439	* @returns IPRT status code.
1440	* @param pPktHdr The howdy packet.
1441	*/
1442	static int txsDoBye(PCTXSPKTHDR pPktHdr)
1443	{
1444	int rc;
1445	if (pPktHdr->cb == sizeof(TXSPKTHDR))
1446	rc = txsReplyAck(pPktHdr);
1447	else
1448	rc = txsReplyBadSize(pPktHdr, sizeof(TXSPKTHDR));
1449	g_pTransport->pfnNotifyBye();
1450	return rc;
1451	}
1452
1453	/**
1454	* Verifies and acknowledges a "HOWDY" request.
1455	*
1456	* @returns IPRT status code.
1457	* @param pPktHdr The howdy packet.
1458	*/
1459	static int txsDoHowdy(PCTXSPKTHDR pPktHdr)
1460	{
1461	if (pPktHdr->cb != sizeof(TXSPKTHDR))
1462	return txsReplyBadSize(pPktHdr, sizeof(TXSPKTHDR));
1463	int rc = txsReplyAck(pPktHdr);
1464	if (RT_SUCCESS(rc))
1465	{
1466	g_pTransport->pfnNotifyHowdy();
1467	RTDirRemoveRecursive(g_szScratchPath, RTDIRRMREC_F_CONTENT_ONLY);
1468	}
1469	return rc;
1470	}
1471
1472	/**
1473	* Replies according to the return code.
1474	*
1475	* @returns rcOperation and pTxsExec->rcReplySend.
1476	* @param pTxsExec The TXSEXEC instance.
1477	* @param rcOperation The status code to report.
1478	* @param pszOperationFmt The operation that failed. Typically giving the
1479	* function call with important arguments.
1480	* @param ... Arguments to the format string.
1481	*/
1482	static int txsExecReplyRC(PTXSEXEC pTxsExec, int rcOperation, const char *pszOperationFmt, ...)
1483	{
1484	AssertStmt(RT_FAILURE_NP(rcOperation), rcOperation = VERR_IPE_UNEXPECTED_INFO_STATUS);
1485
1486	char szOperation[128];
1487	va_list va;
1488	va_start(va, pszOperationFmt);
1489	RTStrPrintfV(szOperation, sizeof(szOperation), pszOperationFmt, va);
1490	va_end(va);
1491
1492	pTxsExec->rcReplySend = txsReplyFailure(pTxsExec->pPktHdr, "FAILED ",
1493	"%s failed with rc=%Rrc (opcode '%.8s')",
1494	szOperation, rcOperation, pTxsExec->pPktHdr->achOpcode);
1495	return rcOperation;
1496	}
1497
1498
1499	/**
1500	* Sends the process exit status reply to the TXS client.
1501	*
1502	* @returns IPRT status code of the send.
1503	* @param pTxsExec The TXSEXEC instance.
1504	* @param fProcessAlive Whether the process is still alive (against our
1505	* will).
1506	* @param fProcessTimedOut Whether the process timed out.
1507	* @param MsProcessKilled When the process was killed, UINT64_MAX if not.
1508	*/
1509	static int txsExecSendExitStatus(PTXSEXEC pTxsExec, bool fProcessAlive, bool fProcessTimedOut, uint64_t MsProcessKilled)
1510	{
1511	int rc;
1512	if ( fProcessTimedOut && !fProcessAlive && MsProcessKilled != UINT64_MAX)
1513	{
1514	rc = txsReplySimple(pTxsExec->pPktHdr, "PROC TOK");
1515	if (g_fDisplayOutput)
1516	RTPrintf("txs: Process timed out and was killed\n");
1517	}
1518	else if (fProcessTimedOut && fProcessAlive && MsProcessKilled != UINT64_MAX)
1519	{
1520	rc = txsReplySimple(pTxsExec->pPktHdr, "PROC TOA");
1521	if (g_fDisplayOutput)
1522	RTPrintf("txs: Process timed out and was not killed successfully\n");
1523	}
1524	else if (g_fTerminate && (fProcessAlive \|\| MsProcessKilled != UINT64_MAX))
1525	rc = txsReplySimple(pTxsExec->pPktHdr, "PROC DWN");
1526	else if (fProcessAlive)
1527	{
1528	rc = txsReplyFailure(pTxsExec->pPktHdr, "PROC DOO", "Doofus! process is alive when it should not");
1529	AssertFailed();
1530	}
1531	else if (MsProcessKilled != UINT64_MAX)
1532	{
1533	rc = txsReplyFailure(pTxsExec->pPktHdr, "PROC DOO", "Doofus! process has been killed when it should not");
1534	AssertFailed();
1535	}
1536	else if ( pTxsExec->ProcessStatus.enmReason == RTPROCEXITREASON_NORMAL
1537	&& pTxsExec->ProcessStatus.iStatus == 0)
1538	{
1539	rc = txsReplySimple(pTxsExec->pPktHdr, "PROC OK ");
1540	if (g_fDisplayOutput)
1541	RTPrintf("txs: Process exited with status: 0\n");
1542	}
1543	else if (pTxsExec->ProcessStatus.enmReason == RTPROCEXITREASON_NORMAL)
1544	{
1545	rc = txsReplyFailure(pTxsExec->pPktHdr, "PROC NOK", "%d", pTxsExec->ProcessStatus.iStatus);
1546	if (g_fDisplayOutput)
1547	RTPrintf("txs: Process exited with status: %d\n", pTxsExec->ProcessStatus.iStatus);
1548	}
1549	else if (pTxsExec->ProcessStatus.enmReason == RTPROCEXITREASON_SIGNAL)
1550	{
1551	rc = txsReplyFailure(pTxsExec->pPktHdr, "PROC SIG", "%d", pTxsExec->ProcessStatus.iStatus);
1552	if (g_fDisplayOutput)
1553	RTPrintf("txs: Process exited with status: signal %d\n", pTxsExec->ProcessStatus.iStatus);
1554	}
1555	else if (pTxsExec->ProcessStatus.enmReason == RTPROCEXITREASON_ABEND)
1556	{
1557	rc = txsReplyFailure(pTxsExec->pPktHdr, "PROC ABD", "");
1558	if (g_fDisplayOutput)
1559	RTPrintf("txs: Process exited with status: abend\n");
1560	}
1561	else
1562	{
1563	rc = txsReplyFailure(pTxsExec->pPktHdr, "PROC DOO", "enmReason=%d iStatus=%d",
1564	pTxsExec->ProcessStatus.enmReason, pTxsExec->ProcessStatus.iStatus);
1565	AssertMsgFailed(("enmReason=%d iStatus=%d", pTxsExec->ProcessStatus.enmReason, pTxsExec->ProcessStatus.iStatus));
1566	}
1567	return rc;
1568	}
1569
1570	/**
1571	* Handle pending output data or error on standard out, standard error or the
1572	* test pipe.
1573	*
1574	* @returns IPRT status code from client send.
1575	* @param hPollSet The polling set.
1576	* @param fPollEvt The event mask returned by RTPollNoResume.
1577	* @param phPipeR The pipe handle.
1578	* @param pu32Crc The current CRC-32 of the stream. (In/Out)
1579	* @param enmHndId The handle ID.
1580	* @param pszOpcode The opcode for the data upload.
1581	*
1582	* @todo Put the last 4 parameters into a struct!
1583	*/
1584	static int txsDoExecHlpHandleOutputEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, PRTPIPE phPipeR,
1585	uint32_t puCrc32, TXSEXECHNDID enmHndId, const char pszOpcode)
1586	{
1587	Log(("txsDoExecHlpHandleOutputEvent: %s fPollEvt=%#x\n", pszOpcode, fPollEvt));
1588
1589	/*
1590	* Try drain the pipe before acting on any errors.
1591	*/
1592	int rc = VINF_SUCCESS;
1593	struct
1594	{
1595	TXSPKTHDR Hdr;
1596	uint32_t uCrc32;
1597	char abBuf[_64K];
1598	char abPadding[TXSPKT_ALIGNMENT];
1599	} Pkt;
1600	size_t cbRead;
1601	int rc2 = RTPipeRead(*phPipeR, Pkt.abBuf, sizeof(Pkt.abBuf), &cbRead);
1602	if (RT_SUCCESS(rc2) && cbRead)
1603	{
1604	Log(("Crc32=%#x ", *puCrc32));
1605	puCrc32 = RTCrc32Process(puCrc32, Pkt.abBuf, cbRead);
1606	Log(("cbRead=%#x Crc32=%#x \n", cbRead, *puCrc32));
1607	Pkt.uCrc32 = RTCrc32Finish(*puCrc32);
1608	if (g_fDisplayOutput)
1609	{
1610	if (enmHndId == TXSEXECHNDID_STDOUT)
1611	RTStrmPrintf(g_pStdErr, "%.*s", cbRead, Pkt.abBuf);
1612	else if (enmHndId == TXSEXECHNDID_STDERR)
1613	RTStrmPrintf(g_pStdErr, "%.*s", cbRead, Pkt.abBuf);
1614	}
1615
1616	rc = txsReplyInternal(&Pkt.Hdr, pszOpcode, cbRead + sizeof(uint32_t));
1617
1618	/* Make sure we go another poll round in case there was too much data
1619	for the buffer to hold. */
1620	fPollEvt &= RTPOLL_EVT_ERROR;
1621	}
1622	else if (RT_FAILURE(rc2))
1623	{
1624	fPollEvt \|= RTPOLL_EVT_ERROR;
1625	AssertMsg(rc2 == VERR_BROKEN_PIPE, ("%Rrc\n", rc));
1626	}
1627
1628	/*
1629	* If an error was raised signalled,
1630	*/
1631	if (fPollEvt & RTPOLL_EVT_ERROR)
1632	{
1633	rc2 = RTPollSetRemove(hPollSet, enmHndId);
1634	AssertRC(rc2);
1635
1636	rc2 = RTPipeClose(*phPipeR);
1637	AssertRC(rc2);
1638	*phPipeR = NIL_RTPIPE;
1639	}
1640	return rc;
1641	}
1642
1643	/**
1644	* Try write some more data to the standard input of the child.
1645	*
1646	* @returns IPRT status code.
1647	* @param pStdInBuf The standard input buffer.
1648	* @param hStdInW The standard input pipe.
1649	*/
1650	static int txsDoExecHlpWriteStdIn(PTXSEXECSTDINBUF pStdInBuf, RTPIPE hStdInW)
1651	{
1652	size_t cbToWrite = pStdInBuf->cb - pStdInBuf->off;
1653	size_t cbWritten;
1654	int rc = RTPipeWrite(hStdInW, &pStdInBuf->pch[pStdInBuf->off], cbToWrite, &cbWritten);
1655	if (RT_SUCCESS(rc))
1656	{
1657	Assert(cbWritten == cbToWrite);
1658	pStdInBuf->off += cbWritten;
1659	}
1660	return rc;
1661	}
1662
1663	/**
1664	* Handle an error event on standard input.
1665	*
1666	* @param hPollSet The polling set.
1667	* @param fPollEvt The event mask returned by RTPollNoResume.
1668	* @param phStdInW The standard input pipe handle.
1669	* @param pStdInBuf The standard input buffer.
1670	*/
1671	static void txsDoExecHlpHandleStdInErrorEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, PRTPIPE phStdInW,
1672	PTXSEXECSTDINBUF pStdInBuf)
1673	{
1674	NOREF(fPollEvt);
1675	int rc2;
1676	if (pStdInBuf->off < pStdInBuf->cb)
1677	{
1678	rc2 = RTPollSetRemove(hPollSet, TXSEXECHNDID_STDIN_WRITABLE);
1679	AssertRC(rc2);
1680	}
1681
1682	rc2 = RTPollSetRemove(hPollSet, TXSEXECHNDID_STDIN);
1683	AssertRC(rc2);
1684
1685	rc2 = RTPipeClose(*phStdInW);
1686	AssertRC(rc2);
1687	*phStdInW = NIL_RTPIPE;
1688
1689	RTMemFree(pStdInBuf->pch);
1690	pStdInBuf->pch = NULL;
1691	pStdInBuf->off = 0;
1692	pStdInBuf->cb = 0;
1693	pStdInBuf->cbAllocated = 0;
1694	pStdInBuf->fBitBucket = true;
1695	}
1696
1697	/**
1698	* Handle an event indicating we can write to the standard input pipe of the
1699	* child process.
1700	*
1701	* @param hPollSet The polling set.
1702	* @param fPollEvt The event mask returned by RTPollNoResume.
1703	* @param phStdInW The standard input pipe.
1704	* @param pStdInBuf The standard input buffer.
1705	*/
1706	static void txsDoExecHlpHandleStdInWritableEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, PRTPIPE phStdInW,
1707	PTXSEXECSTDINBUF pStdInBuf)
1708	{
1709	int rc;
1710	if (!(fPollEvt & RTPOLL_EVT_ERROR))
1711	{
1712	rc = txsDoExecHlpWriteStdIn(pStdInBuf, *phStdInW);
1713	if (RT_FAILURE(rc) && rc != VERR_BAD_PIPE)
1714	{
1715	/** @todo do we need to do something about this error condition? */
1716	AssertRC(rc);
1717	}
1718
1719	if (pStdInBuf->off < pStdInBuf->cb)
1720	{
1721	rc = RTPollSetRemove(hPollSet, TXSEXECHNDID_STDIN_WRITABLE);
1722	AssertRC(rc);
1723	}
1724	}
1725	else
1726	txsDoExecHlpHandleStdInErrorEvent(hPollSet, fPollEvt, phStdInW, pStdInBuf);
1727	}
1728
1729	/**
1730	* Handle a transport event or successful pfnPollIn() call.
1731	*
1732	* @returns IPRT status code from client send.
1733	* @retval VINF_EOF indicates ABORT command.
1734	*
1735	* @param hPollSet The polling set.
1736	* @param fPollEvt The event mask returned by RTPollNoResume.
1737	* @param idPollHnd The handle ID.
1738	* @param hStdInW The standard input pipe.
1739	* @param pStdInBuf The standard input buffer.
1740	*/
1741	static int txsDoExecHlpHandleTransportEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, uint32_t idPollHnd,
1742	PRTPIPE phStdInW, PTXSEXECSTDINBUF pStdInBuf)
1743	{
1744	/* ASSUMES the transport layer will detect or clear any error condition. */
1745	NOREF(fPollEvt); NOREF(idPollHnd);
1746	Log(("txsDoExecHlpHandleTransportEvent\n"));
1747	/** @todo Use a callback for this case? */
1748
1749	/*
1750	* Read client command packet and process it.
1751	*/
1752	/** @todo Sometimes this hangs on windows because there isn't any data pending.
1753	* We probably get woken up at the wrong time or in the wrong way, i.e. RTPoll()
1754	* is busted for sockets.
1755	*
1756	* Temporary workaround: Poll for input before trying to read it. */
1757	if (!g_pTransport->pfnPollIn())
1758	{
1759	Log(("Bad transport event\n"));
1760	RTThreadYield();
1761	return VINF_SUCCESS;
1762	}
1763	PTXSPKTHDR pPktHdr;
1764	int rc = txsRecvPkt(&pPktHdr, false /fAutoRetryOnFailure/);
1765	if (RT_FAILURE(rc))
1766	return rc;
1767	Log(("Bad transport event\n"));
1768
1769	/*
1770	* The most common thing here would be a STDIN request with data
1771	* for the child process.
1772	*/
1773	if (txsIsSameOpcode(pPktHdr, "STDIN"))
1774	{
1775	if ( !pStdInBuf->fBitBucket
1776	&& pPktHdr->cb >= sizeof(TXSPKTHDR) + sizeof(uint32_t))
1777	{
1778	uint32_t uCrc32 = (uint32_t )(pPktHdr + 1);
1779	const char pch = (const char )(pPktHdr + 1) + sizeof(uint32_t);
1780	size_t cb = pPktHdr->cb - sizeof(TXSPKTHDR) - sizeof(uint32_t);
1781
1782	/* Check the CRC */
1783	pStdInBuf->uCrc32 = RTCrc32Process(pStdInBuf->uCrc32, pch, cb);
1784	if (RTCrc32Finish(pStdInBuf->uCrc32) == uCrc32)
1785	{
1786
1787	/* Rewind the buffer if it's empty. */
1788	size_t cbInBuf = pStdInBuf->cb - pStdInBuf->off;
1789	bool const fAddToSet = cbInBuf == 0;
1790	if (fAddToSet)
1791	pStdInBuf->cb = pStdInBuf->off = 0;
1792
1793	/* Try and see if we can simply append the data. */
1794	if (cb + pStdInBuf->cb <= pStdInBuf->cbAllocated)
1795	{
1796	memcpy(&pStdInBuf->pch[pStdInBuf->cb], pch, cb);
1797	pStdInBuf->cb += cb;
1798	rc = txsReplyAck(pPktHdr);
1799	}
1800	else
1801	{
1802	/* Try write a bit or two before we move+realloc the buffer. */
1803	if (cbInBuf > 0)
1804	txsDoExecHlpWriteStdIn(pStdInBuf, *phStdInW);
1805
1806	/* Move any buffered data to the front. */
1807	cbInBuf = pStdInBuf->cb - pStdInBuf->off;
1808	if (cbInBuf == 0)
1809	pStdInBuf->cb = pStdInBuf->off = 0;
1810	else
1811	{
1812	memmove(pStdInBuf->pch, &pStdInBuf->pch[pStdInBuf->off], cbInBuf);
1813	pStdInBuf->cb = cbInBuf;
1814	pStdInBuf->off = 0;
1815	}
1816
1817	/* Do we need to grow the buffer? */
1818	if (cb + pStdInBuf->cb > pStdInBuf->cbAllocated)
1819	{
1820	size_t cbAlloc = pStdInBuf->cb + cb;
1821	cbAlloc = RT_ALIGN_Z(cbAlloc, _64K);
1822	void *pvNew = RTMemRealloc(pStdInBuf->pch, cbAlloc);
1823	if (pvNew)
1824	{
1825	pStdInBuf->pch = (char *)pvNew;
1826	pStdInBuf->cbAllocated = cbAlloc;
1827	}
1828	}
1829
1830	/* Finally, copy the data. */
1831	if (cb + pStdInBuf->cb <= pStdInBuf->cbAllocated)
1832	{
1833	memcpy(&pStdInBuf->pch[pStdInBuf->cb], pch, cb);
1834	pStdInBuf->cb += cb;
1835	rc = txsReplyAck(pPktHdr);
1836	}
1837	else
1838	rc = txsReplySimple(pPktHdr, "STDINMEM");
1839	}
1840
1841	/*
1842	* Flush the buffered data and add/remove the standard input
1843	* handle from the set.
1844	*/
1845	txsDoExecHlpWriteStdIn(pStdInBuf, *phStdInW);
1846	if (fAddToSet && pStdInBuf->off < pStdInBuf->cb)
1847	{
1848	int rc2 = RTPollSetAddPipe(hPollSet, *phStdInW, RTPOLL_EVT_WRITE, TXSEXECHNDID_STDIN_WRITABLE);
1849	AssertRC(rc2);
1850	}
1851	else if (!fAddToSet && pStdInBuf->off >= pStdInBuf->cb)
1852	{
1853	int rc2 = RTPollSetRemove(hPollSet, TXSEXECHNDID_STDIN_WRITABLE);
1854	AssertRC(rc2);
1855	}
1856	}
1857	else
1858	rc = txsReplyFailure(pPktHdr, "STDINCRC", "Invalid CRC checksum expected %#x got %#x",
1859	pStdInBuf->uCrc32, uCrc32);
1860	}
1861	else if (pPktHdr->cb < sizeof(TXSPKTHDR) + sizeof(uint32_t))
1862	rc = txsReplySimple(pPktHdr, "STDINBAD");
1863	else
1864	rc = txsReplySimple(pPktHdr, "STDINIGN");
1865	}
1866	/*
1867	* The only other two requests are connection oriented and we return a error
1868	* code so that we unwind the whole EXEC shebang and start afresh.
1869	*/
1870	else if (txsIsSameOpcode(pPktHdr, "BYE"))
1871	{
1872	rc = txsDoBye(pPktHdr);
1873	if (RT_SUCCESS(rc))
1874	rc = VERR_NET_NOT_CONNECTED;
1875	}
1876	else if (txsIsSameOpcode(pPktHdr, "HOWDY"))
1877	{
1878	rc = txsDoHowdy(pPktHdr);
1879	if (RT_SUCCESS(rc))
1880	rc = VERR_NET_NOT_CONNECTED;
1881	}
1882	else if (txsIsSameOpcode(pPktHdr, "ABORT"))
1883	{
1884	rc = txsReplyAck(pPktHdr);
1885	if (RT_SUCCESS(rc))
1886	rc = VINF_EOF; /* this is but ugly! */
1887	}
1888	else
1889	rc = txsReplyFailure(pPktHdr, "UNKNOWN ", "Opcode '%.8s' is not known or not recognized during EXEC", pPktHdr->achOpcode);
1890
1891	RTMemFree(pPktHdr);
1892	return rc;
1893	}
1894
1895	/**
1896	* Handles the output and input of the process, waits for it finish up.
1897	*
1898	* @returns IPRT status code from reply send.
1899	* @param pTxsExec The TXSEXEC instance.
1900	*/
1901	static int txsDoExecHlp2(PTXSEXEC pTxsExec)
1902	{
1903	int rc; /* client send. */
1904	int rc2;
1905	TXSEXECSTDINBUF StdInBuf = { 0, 0, NULL, 0, pTxsExec->hStdInW == NIL_RTPIPE, RTCrc32Start() };
1906	uint32_t uStdOutCrc32 = RTCrc32Start();
1907	uint32_t uStdErrCrc32 = uStdOutCrc32;
1908	uint32_t uTestPipeCrc32 = uStdOutCrc32;
1909	uint64_t const MsStart = RTTimeMilliTS();
1910	bool fProcessTimedOut = false;
1911	uint64_t MsProcessKilled = UINT64_MAX;
1912	RTMSINTERVAL const cMsPollBase = g_pTransport->pfnPollSetAdd \|\| pTxsExec->hStdInW == NIL_RTPIPE
1913	? 5000 : 100;
1914	RTMSINTERVAL cMsPollCur = 0;
1915
1916	/*
1917	* Before entering the loop, tell the client that we've started the guest
1918	* and that it's now OK to send input to the process. (This is not the
1919	* final ACK, so the packet header is NULL ... kind of bogus.)
1920	*/
1921	rc = txsReplyAck(NULL);
1922
1923	/*
1924	* Process input, output, the test pipe and client requests.
1925	*/
1926	while ( RT_SUCCESS(rc)
1927	&& RT_UNLIKELY(!g_fTerminate))
1928	{
1929	/*
1930	* Wait/Process all pending events.
1931	*/
1932	uint32_t idPollHnd;
1933	uint32_t fPollEvt;
1934	Log3(("Calling RTPollNoResume(,%u,)...\n", cMsPollCur));
1935	rc2 = RTPollNoResume(pTxsExec->hPollSet, cMsPollCur, &fPollEvt, &idPollHnd);
1936	Log3(("RTPollNoResume -> fPollEvt=%#x idPollHnd=%u\n", fPollEvt, idPollHnd));
1937	if (g_fTerminate)
1938	continue;
1939	cMsPollCur = 0; /* no rest until we've checked everything. */
1940
1941	if (RT_SUCCESS(rc2))
1942	{
1943	switch (idPollHnd)
1944	{
1945	case TXSEXECHNDID_STDOUT:
1946	rc = txsDoExecHlpHandleOutputEvent(pTxsExec->hPollSet, fPollEvt, &pTxsExec->hStdOutR, &uStdOutCrc32,
1947	TXSEXECHNDID_STDOUT, "STDOUT ");
1948	break;
1949
1950	case TXSEXECHNDID_STDERR:
1951	rc = txsDoExecHlpHandleOutputEvent(pTxsExec->hPollSet, fPollEvt, &pTxsExec->hStdErrR, &uStdErrCrc32,
1952	TXSEXECHNDID_STDERR, "STDERR ");
1953	break;
1954
1955	case TXSEXECHNDID_TESTPIPE:
1956	rc = txsDoExecHlpHandleOutputEvent(pTxsExec->hPollSet, fPollEvt, &pTxsExec->hTestPipeR, &uTestPipeCrc32,
1957	TXSEXECHNDID_TESTPIPE, "TESTPIPE");
1958	break;
1959
1960	case TXSEXECHNDID_STDIN:
1961	txsDoExecHlpHandleStdInErrorEvent(pTxsExec->hPollSet, fPollEvt, &pTxsExec->hStdInW, &StdInBuf);
1962	break;
1963
1964	case TXSEXECHNDID_STDIN_WRITABLE:
1965	txsDoExecHlpHandleStdInWritableEvent(pTxsExec->hPollSet, fPollEvt, &pTxsExec->hStdInW, &StdInBuf);
1966	break;
1967
1968	case TXSEXECHNDID_THREAD:
1969	rc2 = RTPollSetRemove(pTxsExec->hPollSet, TXSEXECHNDID_THREAD); AssertRC(rc2);
1970	break;
1971
1972	default:
1973	rc = txsDoExecHlpHandleTransportEvent(pTxsExec->hPollSet, fPollEvt, idPollHnd, &pTxsExec->hStdInW,
1974	&StdInBuf);
1975	break;
1976	}
1977	if (RT_FAILURE(rc) \|\| rc == VINF_EOF)
1978	break; /* abort command, or client dead or something */
1979	continue;
1980	}
1981
1982	/*
1983	* Check for incoming data.
1984	*/
1985	if (g_pTransport->pfnPollIn())
1986	{
1987	rc = txsDoExecHlpHandleTransportEvent(pTxsExec->hPollSet, 0, UINT32_MAX, &pTxsExec->hStdInW, &StdInBuf);
1988	if (RT_FAILURE(rc) \|\| rc == VINF_EOF)
1989	break; /* abort command, or client dead or something */
1990	continue;
1991	}
1992
1993	/*
1994	* If the process has terminated, we're should head out.
1995	*/
1996	if (!ASMAtomicReadBool(&pTxsExec->fProcessAlive))
1997	break;
1998
1999	/*
2000	* Check for timed out, killing the process.
2001	*/
2002	uint32_t cMilliesLeft = RT_INDEFINITE_WAIT;
2003	if (pTxsExec->cMsTimeout != RT_INDEFINITE_WAIT)
2004	{
2005	uint64_t u64Now = RTTimeMilliTS();
2006	uint64_t cMsElapsed = u64Now - MsStart;
2007	if (cMsElapsed >= pTxsExec->cMsTimeout)
2008	{
2009	fProcessTimedOut = true;
2010	if ( MsProcessKilled == UINT64_MAX
2011	\|\| u64Now - MsProcessKilled > 1000)
2012	{
2013	if (u64Now - MsProcessKilled > 20601000)
2014	break; /* give up after 20 mins */
2015	RTCritSectEnter(&pTxsExec->CritSect);
2016	if (pTxsExec->fProcessAlive)
2017	RTProcTerminate(pTxsExec->hProcess);
2018	RTCritSectLeave(&pTxsExec->CritSect);
2019	MsProcessKilled = u64Now;
2020	continue;
2021	}
2022	cMilliesLeft = 10000;
2023	}
2024	else
2025	cMilliesLeft = pTxsExec->cMsTimeout - (uint32_t)cMsElapsed;
2026	}
2027
2028	/* Reset the polling interval since we've done all pending work. */
2029	cMsPollCur = cMilliesLeft >= cMsPollBase ? cMsPollBase : cMilliesLeft;
2030	}
2031
2032	/*
2033	* At this point we should hopefully only have to wait 0 ms on the thread
2034	* to release the handle... But if for instance the process refuses to die,
2035	* we'll have to try kill it again. Bothersome.
2036	*/
2037	for (size_t i = 0; i < 22; i++)
2038	{
2039	rc2 = RTThreadWait(pTxsExec->hThreadWaiter, 500, NULL);
2040	if (RT_SUCCESS(rc))
2041	{
2042	pTxsExec->hThreadWaiter = NIL_RTTHREAD;
2043	Assert(!pTxsExec->fProcessAlive);
2044	break;
2045	}
2046	if (i == 0 \|\| i == 10 \|\| i == 15 \|\| i == 18 \|\| i > 20)
2047	{
2048	RTCritSectEnter(&pTxsExec->CritSect);
2049	if (pTxsExec->fProcessAlive)
2050	RTProcTerminate(pTxsExec->hProcess);
2051	RTCritSectLeave(&pTxsExec->CritSect);
2052	}
2053	}
2054
2055	/*
2056	* If we don't have a client problem (RT_FAILURE(rc) we'll reply to the
2057	* clients exec packet now.
2058	*/
2059	if (RT_SUCCESS(rc))
2060	rc = txsExecSendExitStatus(pTxsExec, pTxsExec->fProcessAlive, fProcessTimedOut, MsProcessKilled);
2061
2062	RTMemFree(StdInBuf.pch);
2063	return rc;
2064	}
2065
2066	/**
2067	* Creates a poll set for the pipes and let the transport layer add stuff to it
2068	* as well.
2069	*
2070	* @returns IPRT status code, reply to client made on error.
2071	* @param pTxsExec The TXSEXEC instance.
2072	*/
2073	static int txsExecSetupPollSet(PTXSEXEC pTxsExec)
2074	{
2075	int rc = RTPollSetCreate(&pTxsExec->hPollSet);
2076	if (RT_FAILURE(rc))
2077	return txsExecReplyRC(pTxsExec, rc, "RTPollSetCreate");
2078
2079	rc = RTPollSetAddPipe(pTxsExec->hPollSet, pTxsExec->hStdInW, RTPOLL_EVT_ERROR, TXSEXECHNDID_STDIN);
2080	if (RT_FAILURE(rc))
2081	return txsExecReplyRC(pTxsExec, rc, "RTPollSetAddPipe/stdin");
2082
2083	rc = RTPollSetAddPipe(pTxsExec->hPollSet, pTxsExec->hStdOutR, RTPOLL_EVT_READ \| RTPOLL_EVT_ERROR,
2084	TXSEXECHNDID_STDOUT);
2085	if (RT_FAILURE(rc))
2086	return txsExecReplyRC(pTxsExec, rc, "RTPollSetAddPipe/stdout");
2087
2088	rc = RTPollSetAddPipe(pTxsExec->hPollSet, pTxsExec->hStdErrR, RTPOLL_EVT_READ \| RTPOLL_EVT_ERROR,
2089	TXSEXECHNDID_STDERR);
2090	if (RT_FAILURE(rc))
2091	return txsExecReplyRC(pTxsExec, rc, "RTPollSetAddPipe/stderr");
2092
2093	rc = RTPollSetAddPipe(pTxsExec->hPollSet, pTxsExec->hTestPipeR, RTPOLL_EVT_READ \| RTPOLL_EVT_ERROR,
2094	TXSEXECHNDID_TESTPIPE);
2095	if (RT_FAILURE(rc))
2096	return txsExecReplyRC(pTxsExec, rc, "RTPollSetAddPipe/test");
2097
2098	rc = RTPollSetAddPipe(pTxsExec->hPollSet, pTxsExec->hWakeUpPipeR, RTPOLL_EVT_READ \| RTPOLL_EVT_ERROR,
2099	TXSEXECHNDID_THREAD);
2100	if (RT_FAILURE(rc))
2101	return txsExecReplyRC(pTxsExec, rc, "RTPollSetAddPipe/wakeup");
2102
2103	if (g_pTransport->pfnPollSetAdd)
2104	{
2105	rc = g_pTransport->pfnPollSetAdd(pTxsExec->hPollSet, TXSEXECHNDID_TRANSPORT);
2106	if (RT_FAILURE(rc))
2107	return txsExecReplyRC(pTxsExec, rc, "%s->pfnPollSetAdd/stdin", g_pTransport->szName);
2108	}
2109
2110	return VINF_SUCCESS;
2111	}
2112
2113	/**
2114	* Thread that calls RTProcWait and signals the main thread when it returns.
2115	*
2116	* The thread is created before the process is started and is waiting for a user
2117	* signal from the main thread before it calls RTProcWait.
2118	*
2119	* @returns VINF_SUCCESS (ignored).
2120	* @param hThreadSelf The thread handle.
2121	* @param pvUser The TXEEXEC structure.
2122	*/
2123	static DECLCALLBACK(int) txsExecWaitThreadProc(RTTHREAD hThreadSelf, void *pvUser)
2124	{
2125	PTXSEXEC pTxsExec = (PTXSEXEC)pvUser;
2126
2127	/* Wait for the go ahead... */
2128	int rc = RTThreadUserWait(hThreadSelf, RT_INDEFINITE_WAIT); AssertRC(rc);
2129
2130	RTCritSectEnter(&pTxsExec->CritSect);
2131	for (;;)
2132	{
2133	RTCritSectLeave(&pTxsExec->CritSect);
2134	rc = RTProcWaitNoResume(pTxsExec->hProcess, RTPROCWAIT_FLAGS_BLOCK, &pTxsExec->ProcessStatus);
2135	RTCritSectEnter(&pTxsExec->CritSect);
2136
2137	/* If the pipe is NIL, the destructor wants us to get lost ASAP. */
2138	if (pTxsExec->hWakeUpPipeW == NIL_RTPIPE)
2139	break;
2140
2141	if (RT_FAILURE(rc))
2142	{
2143	rc = RTProcWait(pTxsExec->hProcess, RTPROCWAIT_FLAGS_NOBLOCK, &pTxsExec->ProcessStatus);
2144	if (rc == VERR_PROCESS_RUNNING)
2145	continue;
2146
2147	if (RT_FAILURE(rc))
2148	{
2149	AssertRC(rc);
2150	pTxsExec->ProcessStatus.iStatus = rc;
2151	pTxsExec->ProcessStatus.enmReason = RTPROCEXITREASON_ABEND;
2152	}
2153	}
2154
2155	/* The process finished, signal the main thread over the pipe. */
2156	ASMAtomicWriteBool(&pTxsExec->fProcessAlive, false);
2157	size_t cbIgnored;
2158	RTPipeWrite(pTxsExec->hWakeUpPipeW, "done", 4, &cbIgnored);
2159	RTPipeClose(pTxsExec->hWakeUpPipeW);
2160	pTxsExec->hWakeUpPipeW = NIL_RTPIPE;
2161	break;
2162	}
2163	RTCritSectLeave(&pTxsExec->CritSect);
2164
2165	return VINF_SUCCESS;
2166	}
2167
2168	/**
2169	* Sets up the thread that waits for the process to complete.
2170	*
2171	* @returns IPRT status code, reply to client made on error.
2172	* @param pTxsExec The TXSEXEC instance.
2173	*/
2174	static int txsExecSetupThread(PTXSEXEC pTxsExec)
2175	{
2176	int rc = RTPipeCreate(&pTxsExec->hWakeUpPipeR, &pTxsExec->hWakeUpPipeW, 0 /fFlags/);
2177	if (RT_FAILURE(rc))
2178	{
2179	pTxsExec->hWakeUpPipeR = pTxsExec->hWakeUpPipeW = NIL_RTPIPE;
2180	return txsExecReplyRC(pTxsExec, rc, "RTPipeCreate/wait");
2181	}
2182
2183	rc = RTThreadCreate(&pTxsExec->hThreadWaiter, txsExecWaitThreadProc,
2184	pTxsExec, 0 /cbStack /, RTTHREADTYPE_DEFAULT,
2185	RTTHREADFLAGS_WAITABLE, "TxsProcW");
2186	if (RT_FAILURE(rc))
2187	{
2188	pTxsExec->hThreadWaiter = NIL_RTTHREAD;
2189	return txsExecReplyRC(pTxsExec, rc, "RTThreadCreate");
2190	}
2191
2192	return VINF_SUCCESS;
2193	}
2194
2195	/**
2196	* Sets up the test pipe.
2197	*
2198	* @returns IPRT status code, reply to client made on error.
2199	* @param pTxsExec The TXSEXEC instance.
2200	* @param pszTestPipe How to set up the test pipe.
2201	*/
2202	static int txsExecSetupTestPipe(PTXSEXEC pTxsExec, const char *pszTestPipe)
2203	{
2204	if (strcmp(pszTestPipe, "\|"))
2205	return VINF_SUCCESS;
2206
2207	int rc = RTPipeCreate(&pTxsExec->hTestPipeR, &pTxsExec->hTestPipeW, RTPIPE_C_INHERIT_WRITE);
2208	if (RT_FAILURE(rc))
2209	{
2210	pTxsExec->hTestPipeR = pTxsExec->hTestPipeW = NIL_RTPIPE;
2211	return txsExecReplyRC(pTxsExec, rc, "RTPipeCreate/test/%s", pszTestPipe);
2212	}
2213
2214	char szVal[64];
2215	RTStrPrintf(szVal, sizeof(szVal), "%#llx", (uint64_t)RTPipeToNative(pTxsExec->hTestPipeW));
2216	rc = RTEnvSetEx(pTxsExec->hEnv, "IPRT_TEST_PIPE", szVal);
2217	if (RT_FAILURE(rc))
2218	return txsExecReplyRC(pTxsExec, rc, "RTEnvSetEx/test/%s", pszTestPipe);
2219
2220	return VINF_SUCCESS;
2221	}
2222
2223	/**
2224	* Sets up the redirection / pipe / nothing for one of the standard handles.
2225	*
2226	* @returns IPRT status code, reply to client made on error.
2227	* @param pTxsExec The TXSEXEC instance.
2228	* @param pszHowTo How to set up this standard handle.
2229	* @param fd Which standard handle it is (0 == stdin, 1 ==
2230	* stdout, 2 == stderr).
2231	* @param ph The generic handle that @a pph may be set
2232	* pointing to. Always set.
2233	* @param pph Pointer to the RTProcCreateExec argument.
2234	* Always set.
2235	* @param phPipe Where to return the end of the pipe that we
2236	* should service. Always set.
2237	*/
2238	static int txsExecSetupRedir(PTXSEXEC pTxsExec, const char pszHowTo, const char pszStdWhat, int fd, PRTHANDLE ph, PRTHANDLE *pph, PRTPIPE phPipe)
2239	{
2240	ph->enmType = RTHANDLETYPE_PIPE;
2241	ph->u.hPipe = NIL_RTPIPE;
2242	*pph = NULL;
2243	*phPipe = NIL_RTPIPE;
2244
2245	int rc;
2246	if (!strcmp(pszHowTo, "\|"))
2247	{
2248	/*
2249	* Setup a pipe for forwarding to/from the client.
2250	*/
2251	if (fd == 0)
2252	rc = RTPipeCreate(&ph->u.hPipe, phPipe, RTPIPE_C_INHERIT_READ);
2253	else
2254	rc = RTPipeCreate(phPipe, &ph->u.hPipe, RTPIPE_C_INHERIT_WRITE);
2255	if (RT_FAILURE(rc))
2256	return txsExecReplyRC(pTxsExec, rc, "RTPipeCreate/%s/%s", pszStdWhat, pszHowTo);
2257	ph->enmType = RTHANDLETYPE_PIPE;
2258	*pph = ph;
2259	}
2260	else if (!strcmp(pszHowTo, "/dev/null"))
2261	{
2262	/*
2263	* Redirect to/from /dev/null.
2264	*/
2265	RTFILE hFile;
2266	rc = RTFileOpenBitBucket(&hFile, fd == 0 ? RTFILE_O_READ : RTFILE_O_WRITE);
2267	if (RT_FAILURE(rc))
2268	return txsExecReplyRC(pTxsExec, rc, "RTFileOpenBitBucket/%s/%s", pszStdWhat, pszHowTo);
2269
2270	ph->enmType = RTHANDLETYPE_FILE;
2271	ph->u.hFile = hFile;
2272	*pph = ph;
2273	}
2274	else if (*pszHowTo)
2275	{
2276	/*
2277	* Redirect to/from file.
2278	*/
2279	uint32_t fFlags;
2280	if (fd == 0)
2281	fFlags = RTFILE_O_READ \| RTFILE_O_DENY_WRITE \| RTFILE_O_OPEN;
2282	else
2283	{
2284	if (pszHowTo[0] != '>' \|\| pszHowTo[1] != '>')
2285	fFlags = RTFILE_O_WRITE \| RTFILE_O_DENY_WRITE \| RTFILE_O_CREATE_REPLACE;
2286	else
2287	{
2288	/* append */
2289	pszHowTo += 2;
2290	fFlags = RTFILE_O_WRITE \| RTFILE_O_DENY_NONE \| RTFILE_O_OPEN_CREATE \| RTFILE_O_APPEND;
2291	}
2292	}
2293
2294	RTFILE hFile;
2295	rc = RTFileOpen(&hFile, pszHowTo, fFlags);
2296	if (RT_FAILURE(rc))
2297	return txsExecReplyRC(pTxsExec, rc, "RTFileOpen/%s/%s", pszStdWhat, pszHowTo);
2298
2299	ph->enmType = RTHANDLETYPE_FILE;
2300	ph->u.hFile = hFile;
2301	*pph = ph;
2302	}
2303	else
2304	/* same as parent (us) */
2305	rc = VINF_SUCCESS;
2306	return rc;
2307	}
2308
2309	/**
2310	* Create the environment.
2311	*
2312	* @returns IPRT status code, reply to client made on error.
2313	* @param pTxsExec The TXSEXEC instance.
2314	* @param cEnvVars The number of environment variables.
2315	* @param papszEnv The environment variables (var=value).
2316	*/
2317	static int txsExecSetupEnv(PTXSEXEC pTxsExec, uint32_t cEnvVars, const char * const *papszEnv)
2318	{
2319	/*
2320	* Create the environment.
2321	*/
2322	int rc = RTEnvClone(&pTxsExec->hEnv, RTENV_DEFAULT);
2323	if (RT_FAILURE(rc))
2324	return txsExecReplyRC(pTxsExec, rc, "RTEnvClone");
2325
2326	for (size_t i = 0; i < cEnvVars; i++)
2327	{
2328	rc = RTEnvPutEx(pTxsExec->hEnv, papszEnv[i]);
2329	if (RT_FAILURE(rc))
2330	return txsExecReplyRC(pTxsExec, rc, "RTEnvPutEx(,'%s')", papszEnv[i]);
2331	}
2332	return VINF_SUCCESS;
2333	}
2334
2335	/**
2336	* Deletes the TXSEXEC structure and frees the memory backing it.
2337	*
2338	* @param pTxsExec The structure to destroy.
2339	*/
2340	static void txsExecDestroy(PTXSEXEC pTxsExec)
2341	{
2342	int rc2;
2343
2344	rc2 = RTEnvDestroy(pTxsExec->hEnv); AssertRC(rc2);
2345	pTxsExec->hEnv = NIL_RTENV;
2346	rc2 = RTPipeClose(pTxsExec->hTestPipeW); AssertRC(rc2);
2347	pTxsExec->hTestPipeW = NIL_RTPIPE;
2348	rc2 = RTHandleClose(pTxsExec->StdErr.phChild); AssertRC(rc2);
2349	pTxsExec->StdErr.phChild = NULL;
2350	rc2 = RTHandleClose(pTxsExec->StdOut.phChild); AssertRC(rc2);
2351	pTxsExec->StdOut.phChild = NULL;
2352	rc2 = RTHandleClose(pTxsExec->StdIn.phChild); AssertRC(rc2);
2353	pTxsExec->StdIn.phChild = NULL;
2354
2355	rc2 = RTPipeClose(pTxsExec->hTestPipeR); AssertRC(rc2);
2356	pTxsExec->hTestPipeR = NIL_RTPIPE;
2357	rc2 = RTPipeClose(pTxsExec->hStdErrR); AssertRC(rc2);
2358	pTxsExec->hStdErrR = NIL_RTPIPE;
2359	rc2 = RTPipeClose(pTxsExec->hStdOutR); AssertRC(rc2);
2360	pTxsExec->hStdOutR = NIL_RTPIPE;
2361	rc2 = RTPipeClose(pTxsExec->hStdInW); AssertRC(rc2);
2362	pTxsExec->hStdInW = NIL_RTPIPE;
2363
2364	RTPollSetDestroy(pTxsExec->hPollSet);
2365	pTxsExec->hPollSet = NIL_RTPOLLSET;
2366
2367	/*
2368	* If the process is still running we're in a bit of a fix... Try kill it,
2369	* although that's potentially racing process termination and reusage of
2370	* the pid.
2371	*/
2372	RTCritSectEnter(&pTxsExec->CritSect);
2373
2374	RTPipeClose(pTxsExec->hWakeUpPipeW);
2375	pTxsExec->hWakeUpPipeW = NIL_RTPIPE;
2376	RTPipeClose(pTxsExec->hWakeUpPipeR);
2377	pTxsExec->hWakeUpPipeR = NIL_RTPIPE;
2378
2379	if ( pTxsExec->hProcess != NIL_RTPROCESS
2380	&& pTxsExec->fProcessAlive)
2381	RTProcTerminate(pTxsExec->hProcess);
2382
2383	RTCritSectLeave(&pTxsExec->CritSect);
2384
2385	int rcThread = VINF_SUCCESS;
2386	if (pTxsExec->hThreadWaiter != NIL_RTTHREAD)
2387	rcThread = RTThreadWait(pTxsExec->hThreadWaiter, 5000, NULL);
2388	if (RT_SUCCESS(rcThread))
2389	{
2390	pTxsExec->hThreadWaiter = NIL_RTTHREAD;
2391	RTCritSectDelete(&pTxsExec->CritSect);
2392	RTMemFree(pTxsExec);
2393	}
2394	/* else: leak it or RTThreadWait may cause heap corruption later. */
2395	}
2396
2397	/**
2398	* Initializes the TXSEXEC structure.
2399	*
2400	* @returns VINF_SUCCESS and non-NULL *ppTxsExec on success, reply send status
2401	* and *ppTxsExec set to NULL on failure.
2402	* @param pPktHdr The exec packet.
2403	* @param cMsTimeout The time parameter.
2404	* @param ppTxsExec Where to return the structure.
2405	*/
2406	static int txsExecCreate(PCTXSPKTHDR pPktHdr, RTMSINTERVAL cMsTimeout, PTXSEXEC *ppTxsExec)
2407	{
2408	*ppTxsExec = NULL;
2409
2410	/*
2411	* Allocate the basic resources.
2412	*/
2413	PTXSEXEC pTxsExec = (PTXSEXEC)RTMemAlloc(sizeof(*pTxsExec));
2414	if (!pTxsExec)
2415	return txsReplyRC(pPktHdr, VERR_NO_MEMORY, "RTMemAlloc(%zu)", sizeof(*pTxsExec));
2416	int rc = RTCritSectInit(&pTxsExec->CritSect);
2417	if (RT_FAILURE(rc))
2418	{
2419	RTMemFree(pTxsExec);
2420	return txsReplyRC(pPktHdr, rc, "RTCritSectInit");
2421	}
2422
2423	/*
2424	* Initialize the member to NIL values.
2425	*/
2426	pTxsExec->pPktHdr = pPktHdr;
2427	pTxsExec->cMsTimeout = cMsTimeout;
2428	pTxsExec->rcReplySend = VINF_SUCCESS;
2429
2430	pTxsExec->hPollSet = NIL_RTPOLLSET;
2431	pTxsExec->hStdInW = NIL_RTPIPE;
2432	pTxsExec->hStdOutR = NIL_RTPIPE;
2433	pTxsExec->hStdErrR = NIL_RTPIPE;
2434	pTxsExec->hTestPipeR = NIL_RTPIPE;
2435	pTxsExec->hWakeUpPipeR = NIL_RTPIPE;
2436	pTxsExec->hThreadWaiter = NIL_RTTHREAD;
2437
2438	pTxsExec->StdIn.phChild = NULL;
2439	pTxsExec->StdOut.phChild = NULL;
2440	pTxsExec->StdErr.phChild = NULL;
2441	pTxsExec->hTestPipeW = NIL_RTPIPE;
2442	pTxsExec->hEnv = NIL_RTENV;
2443
2444	pTxsExec->hProcess = NIL_RTPROCESS;
2445	pTxsExec->ProcessStatus.iStatus = 254;
2446	pTxsExec->ProcessStatus.enmReason = RTPROCEXITREASON_ABEND;
2447	pTxsExec->fProcessAlive = false;
2448	pTxsExec->hWakeUpPipeW = NIL_RTPIPE;
2449
2450	*ppTxsExec = pTxsExec;
2451	return VINF_SUCCESS;
2452	}
2453
2454	/**
2455	* txsDoExec helper that takes over when txsDoExec has expanded the packet.
2456	*
2457	* @returns IPRT status code from send.
2458	* @param pPktHdr The exec packet.
2459	* @param fFlags Flags, reserved for future use.
2460	* @param pszExecName The executable name.
2461	* @param cArgs The argument count.
2462	* @param papszArgs The arguments.
2463	* @param cEnvVars The environment variable count.
2464	* @param papszEnv The environment variables.
2465	* @param pszStdIn How to deal with standard in.
2466	* @param pszStdOut How to deal with standard out.
2467	* @param pszStdErr How to deal with standard err.
2468	* @param pszTestPipe How to deal with the test pipe.
2469	* @param pszUsername The user to run the program as.
2470	* @param cMillies The process time limit in milliseconds.
2471	*/
2472	static int txsDoExecHlp(PCTXSPKTHDR pPktHdr, uint32_t fFlags, const char *pszExecName,
2473	uint32_t cArgs, const char * const *papszArgs,
2474	uint32_t cEnvVars, const char * const *papszEnv,
2475	const char pszStdIn, const char pszStdOut, const char pszStdErr, const char pszTestPipe,
2476	const char *pszUsername, RTMSINTERVAL cMillies)
2477	{
2478	int rc2;
2479
2480	/*
2481	* Input validation, filter out things we don't yet support..
2482	*/
2483	Assert(!fFlags);
2484	if (!*pszExecName)
2485	return txsReplyFailure(pPktHdr, "STR ZERO", "Executable name is empty");
2486	if (!*pszStdIn)
2487	return txsReplyFailure(pPktHdr, "STR ZERO", "The stdin howto is empty");
2488	if (!*pszStdOut)
2489	return txsReplyFailure(pPktHdr, "STR ZERO", "The stdout howto is empty");
2490	if (!*pszStdErr)
2491	return txsReplyFailure(pPktHdr, "STR ZERO", "The stderr howto is empty");
2492	if (!*pszTestPipe)
2493	return txsReplyFailure(pPktHdr, "STR ZERO", "The testpipe howto is empty");
2494	if (strcmp(pszTestPipe, "\|") && strcmp(pszTestPipe, "/dev/null"))
2495	return txsReplyFailure(pPktHdr, "BAD TSTP", "Only \"\|\" and \"/dev/null\" are allowed as testpipe howtos ('%s')",
2496	pszTestPipe);
2497	if (*pszUsername)
2498	return txsReplyFailure(pPktHdr, "NOT IMPL", "Executing as a specific user is not implemented ('%s')", pszUsername);
2499
2500	/*
2501	* Prepare for process launch.
2502	*/
2503	PTXSEXEC pTxsExec;
2504	int rc = txsExecCreate(pPktHdr, cMillies, &pTxsExec);
2505	if (pTxsExec == NULL)
2506	return rc;
2507	rc = txsExecSetupEnv(pTxsExec, cEnvVars, papszEnv);
2508	if (RT_SUCCESS(rc))
2509	rc = txsExecSetupRedir(pTxsExec, pszStdIn, "StdIn", 0, &pTxsExec->StdIn.hChild, &pTxsExec->StdIn.phChild, &pTxsExec->hStdInW);
2510	if (RT_SUCCESS(rc))
2511	rc = txsExecSetupRedir(pTxsExec, pszStdOut, "StdOut", 1, &pTxsExec->StdOut.hChild, &pTxsExec->StdOut.phChild, &pTxsExec->hStdOutR);
2512	if (RT_SUCCESS(rc))
2513	rc = txsExecSetupRedir(pTxsExec, pszStdErr, "StdErr", 2, &pTxsExec->StdErr.hChild, &pTxsExec->StdErr.phChild, &pTxsExec->hStdErrR);
2514	if (RT_SUCCESS(rc))
2515	rc = txsExecSetupTestPipe(pTxsExec, pszTestPipe);
2516	if (RT_SUCCESS(rc))
2517	rc = txsExecSetupThread(pTxsExec);
2518	if (RT_SUCCESS(rc))
2519	rc = txsExecSetupPollSet(pTxsExec);
2520	if (RT_SUCCESS(rc))
2521	{
2522	/*
2523	* Create the process.
2524	*/
2525	if (g_fDisplayOutput)
2526	{
2527	RTPrintf("txs: Executing \"%s\": ", pszExecName);
2528	for (uint32_t i = 0; i < cArgs; i++)
2529	RTPrintf(" \"%s\"", papszArgs[i]);
2530	RTPrintf("\n");
2531	}
2532	rc = RTProcCreateEx(pszExecName, papszArgs, pTxsExec->hEnv, 0 /fFlags/,
2533	pTxsExec->StdIn.phChild, pTxsExec->StdOut.phChild, pTxsExec->StdErr.phChild,
2534	*pszUsername ? pszUsername : NULL, NULL,
2535	&pTxsExec->hProcess);
2536	if (RT_SUCCESS(rc))
2537	{
2538	ASMAtomicWriteBool(&pTxsExec->fProcessAlive, true);
2539	rc2 = RTThreadUserSignal(pTxsExec->hThreadWaiter); AssertRC(rc2);
2540
2541	/*
2542	* Close the child ends of any pipes and redirected files.
2543	*/
2544	rc2 = RTHandleClose(pTxsExec->StdIn.phChild); AssertRC(rc2);
2545	pTxsExec->StdIn.phChild = NULL;
2546	rc2 = RTHandleClose(pTxsExec->StdOut.phChild); AssertRC(rc2);
2547	pTxsExec->StdOut.phChild = NULL;
2548	rc2 = RTHandleClose(pTxsExec->StdErr.phChild); AssertRC(rc2);
2549	pTxsExec->StdErr.phChild = NULL;
2550	rc2 = RTPipeClose(pTxsExec->hTestPipeW); AssertRC(rc2);
2551	pTxsExec->hTestPipeW = NIL_RTPIPE;
2552
2553	/*
2554	* Let another worker function funnel output and input to the
2555	* client as well as the process exit code.
2556	*/
2557	rc = txsDoExecHlp2(pTxsExec);
2558	}
2559	else
2560	rc = txsReplyFailure(pPktHdr, "FAILED ", "Executing process \"%s\" failed with %Rrc",
2561	pszExecName, rc);
2562	}
2563	else
2564	rc = pTxsExec->rcReplySend;
2565	txsExecDestroy(pTxsExec);
2566	return rc;
2567	}
2568
2569	/**
2570	* Execute a program.
2571	*
2572	* @returns IPRT status code from send.
2573	* @param pPktHdr The exec packet.
2574	*/
2575	static int txsDoExec(PCTXSPKTHDR pPktHdr)
2576	{
2577	/*
2578	* This packet has a lot of parameters, most of which are zero terminated
2579	* strings. The strings used in items 7 thru 10 are either file names,
2580	* "/dev/null" or a pipe char (\|).
2581	*
2582	* Packet content:
2583	* 1. Flags reserved for future use (32-bit unsigned).
2584	* 2. The executable name (string).
2585	* 3. The argument count given as a 32-bit unsigned integer.
2586	* 4. The arguments strings.
2587	* 5. The number of environment strings (32-bit unsigned).
2588	* 6. The environment strings (var=val) to apply the environment.
2589	* 7. What to do about standard in (string).
2590	* 8. What to do about standard out (string).
2591	* 9. What to do about standard err (string).
2592	* 10. What to do about the test pipe (string).
2593	* 11. The name of the user to run the program as (string). Empty string
2594	* means running it as the current user.
2595	* 12. Process time limit in milliseconds (32-bit unsigned). Max == no limit.
2596	*/
2597	size_t const cbMin = sizeof(TXSPKTHDR)
2598	+ sizeof(uint32_t) /* flags */ + 2
2599	+ sizeof(uint32_t) /* argc / + 2 / argv */
2600	+ sizeof(uint32_t) + 0 /* environ */
2601	+ 4 * 1
2602	+ sizeof(uint32_t) /* timeout */;
2603	if (pPktHdr->cb < cbMin)
2604	return txsReplyBadMinSize(pPktHdr, cbMin);
2605
2606	/* unpack the packet */
2607	char const pchEnd = (char const )pPktHdr + pPktHdr->cb;
2608	char const pch = (char const )(pPktHdr + 1); /* cursor */
2609
2610	/* 1. flags */
2611	uint32_t const fFlags = (uint32_t const )pch;
2612	pch += sizeof(uint32_t);
2613	if (fFlags != 0)
2614	return txsReplyFailure(pPktHdr, "BAD FLAG", "Invalid EXEC flags %#x, expected 0", fFlags);
2615
2616	/* 2. exec name */
2617	int rc;
2618	char *pszExecName = NULL;
2619	if (!txsIsStringValid(pPktHdr, "execname", pch, &pszExecName, &pch, &rc))
2620	return rc;
2621
2622	/* 3. argc */
2623	uint32_t const cArgs = (size_t)(pchEnd - pch) > sizeof(uint32_t) ? (uint32_t const )pch : 0xff;
2624	pch += sizeof(uint32_t);
2625	if (cArgs * 1 >= (size_t)(pchEnd - pch))
2626	rc = txsReplyFailure(pPktHdr, "BAD ARGC", "Bad or missing argument count (%#x)", cArgs);
2627	else if (cArgs > 128)
2628	rc = txsReplyFailure(pPktHdr, "BAD ARGC", "Too many arguments (%#x)", cArgs);
2629	else
2630	{
2631	char papszArgs = (char )RTMemTmpAllocZ(sizeof(char ) (cArgs + 1));
2632	if (papszArgs)
2633	{
2634	/* 4. argv */
2635	bool fOk = true;
2636	for (size_t i = 0; i < cArgs && fOk; i++)
2637	{
2638	fOk = txsIsStringValid(pPktHdr, "argvN", pch, &papszArgs[i], &pch, &rc);
2639	if (!fOk)
2640	break;
2641	}
2642	if (fOk)
2643	{
2644	/* 5. cEnvVars */
2645	uint32_t const cEnvVars = (size_t)(pchEnd - pch) > sizeof(uint32_t) ? (uint32_t const )pch : 0xfff;
2646	pch += sizeof(uint32_t);
2647	if (cEnvVars * 1 >= (size_t)(pchEnd - pch))
2648	rc = txsReplyFailure(pPktHdr, "BAD ENVC", "Bad or missing environment variable count (%#x)", cEnvVars);
2649	else if (cEnvVars > 256)
2650	rc = txsReplyFailure(pPktHdr, "BAD ENVC", "Too many environment variables (%#x)", cEnvVars);
2651	else
2652	{
2653	char papszEnv = (char )RTMemTmpAllocZ(sizeof(char ) (cEnvVars + 1));
2654	if (papszEnv)
2655	{
2656	/* 6. environ */
2657	for (size_t i = 0; i < cEnvVars && fOk; i++)
2658	{
2659	fOk = txsIsStringValid(pPktHdr, "envN", pch, &papszEnv[i], &pch, &rc);
2660	if (!fOk) /* Bail out on error. */
2661	break;
2662	}
2663	if (fOk)
2664	{
2665	/* 7. stdout */
2666	char *pszStdIn;
2667	if (txsIsStringValid(pPktHdr, "stdin", pch, &pszStdIn, &pch, &rc))
2668	{
2669	/* 8. stdout */
2670	char *pszStdOut;
2671	if (txsIsStringValid(pPktHdr, "stdout", pch, &pszStdOut, &pch, &rc))
2672	{
2673	/* 9. stderr */
2674	char *pszStdErr;
2675	if (txsIsStringValid(pPktHdr, "stderr", pch, &pszStdErr, &pch, &rc))
2676	{
2677	/* 10. testpipe */
2678	char *pszTestPipe;
2679	if (txsIsStringValid(pPktHdr, "testpipe", pch, &pszTestPipe, &pch, &rc))
2680	{
2681	/* 11. username */
2682	char *pszUsername;
2683	if (txsIsStringValid(pPktHdr, "username", pch, &pszUsername, &pch, &rc))
2684	{
2685	/** @todo No password value? */
2686
2687	/* 12. time limit */
2688	uint32_t const cMillies = (size_t)(pchEnd - pch) >= sizeof(uint32_t)
2689	? (uint32_t const )pch
2690	: 0;
2691	if ((size_t)(pchEnd - pch) > sizeof(uint32_t))
2692	rc = txsReplyFailure(pPktHdr, "BAD END ", "Timeout argument not at end of packet (%#x)", (size_t)(pchEnd - pch));
2693	else if ((size_t)(pchEnd - pch) < sizeof(uint32_t))
2694	rc = txsReplyFailure(pPktHdr, "BAD NOTO", "No timeout argument");
2695	else if (cMillies < 1000)
2696	rc = txsReplyFailure(pPktHdr, "BAD TO ", "Timeout is less than a second (%#x)", cMillies);
2697	else
2698	{
2699	pch += sizeof(uint32_t);
2700
2701	/*
2702	* Time to employ a helper here before we go way beyond
2703	* the right margin...
2704	*/
2705	rc = txsDoExecHlp(pPktHdr, fFlags, pszExecName,
2706	cArgs, papszArgs,
2707	cEnvVars, papszEnv,
2708	pszStdIn, pszStdOut, pszStdErr, pszTestPipe,
2709	pszUsername,
2710	cMillies == UINT32_MAX ? RT_INDEFINITE_WAIT : cMillies);
2711	}
2712	RTStrFree(pszUsername);
2713	}
2714	RTStrFree(pszTestPipe);
2715	}
2716	RTStrFree(pszStdErr);
2717	}
2718	RTStrFree(pszStdOut);
2719	}
2720	RTStrFree(pszStdIn);
2721	}
2722	}
2723	for (size_t i = 0; i < cEnvVars; i++)
2724	RTStrFree(papszEnv[i]);
2725	RTMemTmpFree(papszEnv);
2726	}
2727	else
2728	rc = txsReplyFailure(pPktHdr, "NO MEM ", "Failed to allocate %zu bytes environ", sizeof(char ) (cEnvVars + 1));
2729	}
2730	}
2731	for (size_t i = 0; i < cArgs; i++)
2732	RTStrFree(papszArgs[i]);
2733	RTMemTmpFree(papszArgs);
2734	}
2735	else
2736	rc = txsReplyFailure(pPktHdr, "NO MEM ", "Failed to allocate %zu bytes for argv", sizeof(char ) (cArgs + 1));
2737	}
2738	RTStrFree(pszExecName);
2739
2740	return rc;
2741	}
2742
2743	/**
2744	* The main loop.
2745	*
2746	* @returns exit code.
2747	*/
2748	static RTEXITCODE txsMainLoop(void)
2749	{
2750	RTEXITCODE enmExitCode = RTEXITCODE_SUCCESS;
2751	while (!g_fTerminate)
2752	{
2753	/*
2754	* Read client command packet and process it.
2755	*/
2756	PTXSPKTHDR pPktHdr;
2757	int rc = txsRecvPkt(&pPktHdr, true /fAutoRetryOnFailure/);
2758	if (RT_FAILURE(rc))
2759	continue;
2760
2761	/*
2762	* Do a string switch on the opcode bit.
2763	*/
2764	/* Connection: */
2765	if ( txsIsSameOpcode(pPktHdr, "HOWDY "))
2766	rc = txsDoHowdy(pPktHdr);
2767	else if (txsIsSameOpcode(pPktHdr, "BYE "))
2768	rc = txsDoBye(pPktHdr);
2769	else if (txsIsSameOpcode(pPktHdr, "UUID "))
2770	rc = txsDoUuid(pPktHdr);
2771	/* Process: */
2772	else if (txsIsSameOpcode(pPktHdr, "EXEC "))
2773	rc = txsDoExec(pPktHdr);
2774	/* Admin: */
2775	else if (txsIsSameOpcode(pPktHdr, "REBOOT "))
2776	rc = txsDoReboot(pPktHdr);
2777	else if (txsIsSameOpcode(pPktHdr, "SHUTDOWN"))
2778	rc = txsDoShutdown(pPktHdr);
2779	/* CD/DVD control: */
2780	else if (txsIsSameOpcode(pPktHdr, "CD EJECT"))
2781	rc = txsDoCdEject(pPktHdr);
2782	/* File system: */
2783	else if (txsIsSameOpcode(pPktHdr, "CLEANUP "))
2784	rc = txsDoCleanup(pPktHdr);
2785	else if (txsIsSameOpcode(pPktHdr, "MKDIR "))
2786	rc = txsDoMkDir(pPktHdr);
2787	else if (txsIsSameOpcode(pPktHdr, "MKDRPATH"))
2788	rc = txsDoMkDrPath(pPktHdr);
2789	else if (txsIsSameOpcode(pPktHdr, "MKSYMLNK"))
2790	rc = txsDoMkSymlnk(pPktHdr);
2791	else if (txsIsSameOpcode(pPktHdr, "RMDIR "))
2792	rc = txsDoRmDir(pPktHdr);
2793	else if (txsIsSameOpcode(pPktHdr, "RMFILE "))
2794	rc = txsDoRmFile(pPktHdr);
2795	else if (txsIsSameOpcode(pPktHdr, "RMSYMLNK"))
2796	rc = txsDoRmSymlnk(pPktHdr);
2797	else if (txsIsSameOpcode(pPktHdr, "RMTREE "))
2798	rc = txsDoRmTree(pPktHdr);
2799	else if (txsIsSameOpcode(pPktHdr, "CHMOD "))
2800	rc = txsDoChMod(pPktHdr);
2801	else if (txsIsSameOpcode(pPktHdr, "CHOWN "))
2802	rc = txsDoChOwn(pPktHdr);
2803	else if (txsIsSameOpcode(pPktHdr, "CHGRP "))
2804	rc = txsDoChGrp(pPktHdr);
2805	else if (txsIsSameOpcode(pPktHdr, "ISDIR "))
2806	rc = txsDoIsDir(pPktHdr);
2807	else if (txsIsSameOpcode(pPktHdr, "ISFILE "))
2808	rc = txsDoIsFile(pPktHdr);
2809	else if (txsIsSameOpcode(pPktHdr, "ISSYMLNK"))
2810	rc = txsDoIsSymlnk(pPktHdr);
2811	else if (txsIsSameOpcode(pPktHdr, "STAT "))
2812	rc = txsDoStat(pPktHdr);
2813	else if (txsIsSameOpcode(pPktHdr, "LSTAT "))
2814	rc = txsDoLStat(pPktHdr);
2815	else if (txsIsSameOpcode(pPktHdr, "LIST "))
2816	rc = txsDoList(pPktHdr);
2817	else if (txsIsSameOpcode(pPktHdr, "PUT FILE"))
2818	rc = txsDoPutFile(pPktHdr);
2819	else if (txsIsSameOpcode(pPktHdr, "GET FILE"))
2820	rc = txsDoGetFile(pPktHdr);
2821	#ifndef RT_OS_WINDOWS
2822	else if (txsIsSameOpcode(pPktHdr, "UNPKFILE"))
2823	rc = txsDoUnpackFile(pPktHdr);
2824	#endif
2825	/* Misc: */
2826	else
2827	rc = txsReplyUnknown(pPktHdr);
2828
2829	RTMemFree(pPktHdr);
2830	}
2831
2832	return enmExitCode;
2833	}
2834
2835
2836	/**
2837	* Finalizes the scratch directory, making sure it exists.
2838	*
2839	* @returns exit code.
2840	*/
2841	static RTEXITCODE txsFinalizeScratch(void)
2842	{
2843	RTPathStripTrailingSlash(g_szScratchPath);
2844	char *pszFilename = RTPathFilename(g_szScratchPath);
2845	if (!pszFilename)
2846	return RTMsgErrorExit(RTEXITCODE_FAILURE, "cannot use root for scratch (%s)\n", g_szScratchPath);
2847
2848	int rc;
2849	if (strchr(pszFilename, 'X'))
2850	{
2851	char ch = *pszFilename;
2852	rc = RTDirCreateFullPath(g_szScratchPath, 0700);
2853	*pszFilename = ch;
2854	if (RT_SUCCESS(rc))
2855	rc = RTDirCreateTemp(g_szScratchPath, 0700);
2856	}
2857	else
2858	{
2859	if (RTDirExists(g_szScratchPath))
2860	rc = VINF_SUCCESS;
2861	else
2862	rc = RTDirCreateFullPath(g_szScratchPath, 0700);
2863	}
2864	if (RT_FAILURE(rc))
2865	return RTMsgErrorExit(RTEXITCODE_FAILURE, "failed to create scratch directory: %Rrc (%s)\n", rc, g_szScratchPath);
2866	return RTEXITCODE_SUCCESS;
2867	}
2868
2869	/**
2870	* Attempts to complete an upgrade by updating the original and relaunching
2871	* ourselves from there again.
2872	*
2873	* On failure, we'll continue running as the temporary copy.
2874	*
2875	* @returns Exit code. Exit if this is non-zero or @a *pfExit is set.
2876	* @param argc The number of arguments.
2877	* @param argv The argument vector.
2878	* @param pfExit For indicating exit when the exit code is zero.
2879	*/
2880	static RTEXITCODE txsAutoUpdateStage2(int argc, char *argv, bool pfExit, const char *pszUpgrading)
2881	{
2882	/*
2883	* Copy the current executable onto the original.
2884	* Note that we're racing the original program on some platforms, thus the
2885	* 60 sec sleep mess.
2886	*/
2887	char szUpgradePath[RTPATH_MAX];
2888	if (!RTProcGetExecutablePath(szUpgradePath, sizeof(szUpgradePath)))
2889	{
2890	RTMsgError("RTProcGetExecutablePath failed (step 2)\n");
2891	return RTEXITCODE_SUCCESS;
2892	}
2893	void *pvUpgrade;
2894	size_t cbUpgrade;
2895	int rc = RTFileReadAll(szUpgradePath, &pvUpgrade, &cbUpgrade);
2896	if (RT_FAILURE(rc))
2897	{
2898	RTMsgError("RTFileReadAllEx(\"%s\"): %Rrc (step 2)\n", szUpgradePath, rc);
2899	return RTEXITCODE_SUCCESS;
2900	}
2901
2902	uint64_t StartMilliTS = RTTimeMilliTS();
2903	RTFILE hFile;
2904	rc = RTFileOpen(&hFile, pszUpgrading,
2905	RTFILE_O_WRITE \| RTFILE_O_DENY_WRITE \| RTFILE_O_OPEN_CREATE \| RTFILE_O_TRUNCATE
2906	\| (0755 << RTFILE_O_CREATE_MODE_SHIFT));
2907	while ( RT_FAILURE(rc)
2908	&& RTTimeMilliTS() - StartMilliTS < 60000)
2909	{
2910	RTThreadSleep(1000);
2911	rc = RTFileOpen(&hFile, pszUpgrading,
2912	RTFILE_O_WRITE \| RTFILE_O_DENY_WRITE \| RTFILE_O_OPEN_CREATE \| RTFILE_O_TRUNCATE
2913	\| (0755 << RTFILE_O_CREATE_MODE_SHIFT));
2914	}
2915	if (RT_SUCCESS(rc))
2916	{
2917	rc = RTFileWrite(hFile, pvUpgrade, cbUpgrade, NULL);
2918	RTFileClose(hFile);
2919	if (RT_SUCCESS(rc))
2920	{
2921	/*
2922	* Relaunch the service with the original name, foricbly barring
2923	* further upgrade cycles in case of bugs (and simplifying the code).
2924	*/
2925	const char papszArgs = (const char )RTMemAlloc((argc + 1 + 1) * sizeof(char **));
2926	if (papszArgs)
2927	{
2928	papszArgs[0] = pszUpgrading;
2929	for (int i = 1; i < argc; i++)
2930	papszArgs[i] = argv[i];
2931	papszArgs[argc] = "--no-auto-upgrade";
2932	papszArgs[argc + 1] = NULL;
2933
2934	RTMsgInfo("Launching upgraded image: \"%s\"\n", pszUpgrading);
2935	RTPROCESS hProc;
2936	rc = RTProcCreate(pszUpgrading, papszArgs, RTENV_DEFAULT, 0 /fFlags/, &hProc);
2937	if (RT_SUCCESS(rc))
2938	*pfExit = true;
2939	else
2940	RTMsgError("RTProcCreate(\"%s\"): %Rrc (upgrade stage 2)\n", pszUpgrading, rc);
2941	RTMemFree(papszArgs);
2942	}
2943	else
2944	RTMsgError("RTMemAlloc failed during upgrade attempt (stage 2)\n");
2945	}
2946	else
2947	RTMsgError("RTFileWrite(%s,,%zu): %Rrc (step 2) - BAD\n", pszUpgrading, cbUpgrade, rc);
2948	}
2949	else
2950	RTMsgError("RTFileOpen(,%s,): %Rrc\n", pszUpgrading, rc);
2951	RTFileReadAllFree(pvUpgrade, cbUpgrade);
2952	return RTEXITCODE_SUCCESS;
2953	}
2954
2955	/**
2956	* Checks for an upgrade and respawns if there is.
2957	*
2958	* @returns Exit code. Exit if this is non-zero or @a *pfExit is set.
2959	* @param argc The number of arguments.
2960	* @param argv The argument vector.
2961	* @param pfExit For indicating exit when the exit code is zero.
2962	*/
2963	static RTEXITCODE txsAutoUpdateStage1(int argc, char *argv, bool pfExit)
2964	{
2965	/*
2966	* Figure names of the current service image and the potential upgrade.
2967	*/
2968	char szOrgPath[RTPATH_MAX];
2969	if (!RTProcGetExecutablePath(szOrgPath, sizeof(szOrgPath)))
2970	{
2971	RTMsgError("RTProcGetExecutablePath failed\n");
2972	return RTEXITCODE_SUCCESS;
2973	}
2974
2975	char szUpgradePath[RTPATH_MAX];
2976	int rc = RTPathJoin(szUpgradePath, sizeof(szUpgradePath), g_szCdRomPath, g_szOsSlashArchShortName);
2977	if (RT_SUCCESS(rc))
2978	rc = RTPathAppend(szUpgradePath, sizeof(szUpgradePath), RTPathFilename(szOrgPath));
2979	if (RT_FAILURE(rc))
2980	{
2981	RTMsgError("Failed to construct path to potential service upgrade: %Rrc\n", rc);
2982	return RTEXITCODE_SUCCESS;
2983	}
2984
2985	/*
2986	* Query information about the two images and read the entire potential source file.
2987	*/
2988	RTFSOBJINFO UpgradeInfo;
2989	rc = RTPathQueryInfo(szUpgradePath, &UpgradeInfo, RTFSOBJATTRADD_NOTHING);
2990	if ( rc == VERR_FILE_NOT_FOUND
2991	\|\| rc == VERR_PATH_NOT_FOUND
2992	\|\| rc == VERR_MEDIA_NOT_PRESENT
2993	\|\| rc == VERR_MEDIA_NOT_RECOGNIZED)
2994	return RTEXITCODE_SUCCESS;
2995	if (RT_FAILURE(rc))
2996	{
2997	RTMsgError("RTPathQueryInfo(\"%s\"): %Rrc (upgrade)\n", szUpgradePath, rc);
2998	return RTEXITCODE_SUCCESS;
2999	}
3000
3001	RTFSOBJINFO OrgInfo;
3002	rc = RTPathQueryInfo(szOrgPath, &OrgInfo, RTFSOBJATTRADD_NOTHING);
3003	if (RT_FAILURE(rc))
3004	{
3005	RTMsgError("RTPathQueryInfo(\"%s\"): %Rrc (old)\n", szOrgPath, rc);
3006	return RTEXITCODE_SUCCESS;
3007	}
3008
3009	void *pvUpgrade;
3010	size_t cbUpgrade;
3011	rc = RTFileReadAllEx(szUpgradePath, 0, UpgradeInfo.cbObject, RTFILE_RDALL_O_DENY_NONE, &pvUpgrade, &cbUpgrade);
3012	if (RT_FAILURE(rc))
3013	{
3014	RTMsgError("RTPathQueryInfo(\"%s\"): %Rrc (old)\n", szOrgPath, rc);
3015	return RTEXITCODE_SUCCESS;
3016	}
3017
3018	/*
3019	* Compare and see if we've got a different service image or not.
3020	*/
3021	if (OrgInfo.cbObject == UpgradeInfo.cbObject)
3022	{
3023	/* must compare bytes. */
3024	void *pvOrg;
3025	size_t cbOrg;
3026	rc = RTFileReadAllEx(szOrgPath, 0, OrgInfo.cbObject, RTFILE_RDALL_O_DENY_NONE, &pvOrg, &cbOrg);
3027	if (RT_FAILURE(rc))
3028	{
3029	RTMsgError("RTFileReadAllEx(\"%s\"): %Rrc\n", szOrgPath, rc);
3030	RTFileReadAllFree(pvUpgrade, cbUpgrade);
3031	return RTEXITCODE_SUCCESS;
3032	}
3033	bool fSame = !memcmp(pvUpgrade, pvOrg, OrgInfo.cbObject);
3034	RTFileReadAllFree(pvOrg, cbOrg);
3035	if (fSame)
3036	{
3037	RTFileReadAllFree(pvUpgrade, cbUpgrade);
3038	return RTEXITCODE_SUCCESS;
3039	}
3040	}
3041
3042	/*
3043	* Should upgrade. Start by creating an executable copy of the update
3044	* image in the scratch area.
3045	*/
3046	RTEXITCODE rcExit = txsFinalizeScratch();
3047	if (rcExit == RTEXITCODE_SUCCESS)
3048	{
3049	char szTmpPath[RTPATH_MAX];
3050	rc = RTPathJoin(szTmpPath, sizeof(szTmpPath), g_szScratchPath, RTPathFilename(szOrgPath));
3051	if (RT_SUCCESS(rc))
3052	{
3053	RTFileDelete(szTmpPath); /* shouldn't hurt. */
3054
3055	RTFILE hFile;
3056	rc = RTFileOpen(&hFile, szTmpPath,
3057	RTFILE_O_WRITE \| RTFILE_O_DENY_WRITE \| RTFILE_O_CREATE_REPLACE
3058	\| (0755 << RTFILE_O_CREATE_MODE_SHIFT));
3059	if (RT_SUCCESS(rc))
3060	{
3061	rc = RTFileWrite(hFile, pvUpgrade, UpgradeInfo.cbObject, NULL);
3062	RTFileClose(hFile);
3063	if (RT_SUCCESS(rc))
3064	{
3065	/*
3066	* Try execute the new image and quit if it works.
3067	*/
3068	const char papszArgs = (const char )RTMemAlloc((argc + 2 + 1) * sizeof(char **));
3069	if (papszArgs)
3070	{
3071	papszArgs[0] = szTmpPath;
3072	for (int i = 1; i < argc; i++)
3073	papszArgs[i] = argv[i];
3074	papszArgs[argc] = "--upgrading";
3075	papszArgs[argc + 1] = szOrgPath;
3076	papszArgs[argc + 2] = NULL;
3077
3078	RTMsgInfo("Launching intermediate automatic upgrade stage: \"%s\"\n", szTmpPath);
3079	RTPROCESS hProc;
3080	rc = RTProcCreate(szTmpPath, papszArgs, RTENV_DEFAULT, 0 /fFlags/, &hProc);
3081	if (RT_SUCCESS(rc))
3082	*pfExit = true;
3083	else
3084	RTMsgError("RTProcCreate(\"%s\"): %Rrc (upgrade stage 1)\n", szTmpPath, rc);
3085	RTMemFree(papszArgs);
3086	}
3087	else
3088	RTMsgError("RTMemAlloc failed during upgrade attempt (stage)\n");
3089	}
3090	else
3091	RTMsgError("RTFileWrite(%s,,%zu): %Rrc\n", szTmpPath, UpgradeInfo.cbObject, rc);
3092	}
3093	else
3094	RTMsgError("RTFileOpen(,%s,): %Rrc\n", szTmpPath, rc);
3095	}
3096	else
3097	RTMsgError("Failed to construct path to temporary upgrade image: %Rrc\n", rc);
3098	}
3099
3100	RTFileReadAllFree(pvUpgrade, cbUpgrade);
3101	return rcExit;
3102	}
3103
3104	/**
3105	* Determines the default configuration.
3106	*/
3107	static void txsSetDefaults(void)
3108	{
3109	/*
3110	* OS and ARCH.
3111	*/
3112	AssertCompile(sizeof(KBUILD_TARGET) <= sizeof(g_szOsShortName));
3113	strcpy(g_szOsShortName, KBUILD_TARGET);
3114
3115	AssertCompile(sizeof(KBUILD_TARGET_ARCH) <= sizeof(g_szArchShortName));
3116	strcpy(g_szArchShortName, KBUILD_TARGET_ARCH);
3117
3118	AssertCompile(sizeof(KBUILD_TARGET) + sizeof(KBUILD_TARGET_ARCH) <= sizeof(g_szOsDotArchShortName));
3119	strcpy(g_szOsDotArchShortName, KBUILD_TARGET);
3120	g_szOsDotArchShortName[sizeof(KBUILD_TARGET) - 1] = '.';
3121	strcpy(&g_szOsDotArchShortName[sizeof(KBUILD_TARGET)], KBUILD_TARGET_ARCH);
3122
3123	AssertCompile(sizeof(KBUILD_TARGET) + sizeof(KBUILD_TARGET_ARCH) <= sizeof(g_szOsSlashArchShortName));
3124	strcpy(g_szOsSlashArchShortName, KBUILD_TARGET);
3125	g_szOsSlashArchShortName[sizeof(KBUILD_TARGET) - 1] = '/';
3126	strcpy(&g_szOsSlashArchShortName[sizeof(KBUILD_TARGET)], KBUILD_TARGET_ARCH);
3127
3128	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
3129	strcpy(g_szExeSuff, ".exe");
3130	strcpy(g_szScriptSuff, ".cmd");
3131	#else
3132	strcpy(g_szExeSuff, "");
3133	strcpy(g_szScriptSuff, ".sh");
3134	#endif
3135
3136	/*
3137	* The CD/DVD-ROM location.
3138	*/
3139	/** @todo do a better job here :-) */
3140	#ifdef RT_OS_WINDOWS
3141	strcpy(g_szDefCdRomPath, "D:/");
3142	#elif defined(RT_OS_OS2)
3143	strcpy(g_szDefCdRomPath, "D:/");
3144	#else
3145	if (RTDirExists("/media"))
3146	strcpy(g_szDefCdRomPath, "/media/cdrom");
3147	else
3148	strcpy(g_szDefCdRomPath, "/mnt/cdrom");
3149	#endif
3150	strcpy(g_szCdRomPath, g_szDefCdRomPath);
3151
3152	/*
3153	* Temporary directory.
3154	*/
3155	int rc = RTPathTemp(g_szDefScratchPath, sizeof(g_szDefScratchPath));
3156	if (RT_SUCCESS(rc))
3157	#if defined(RT_OS_OS2) \|\| defined(RT_OS_WINDOWS) \|\| defined(RT_OS_DOS)
3158	rc = RTPathAppend(g_szDefScratchPath, sizeof(g_szDefScratchPath), "txs-XXXX.tmp");
3159	#else
3160	rc = RTPathAppend(g_szDefScratchPath, sizeof(g_szDefScratchPath), "txs-XXXXXXXXX.tmp");
3161	#endif
3162	if (RT_FAILURE(rc))
3163	{
3164	RTMsgError("RTPathTemp/Append failed when constructing scratch path: %Rrc\n", rc);
3165	strcpy(g_szDefScratchPath, "/tmp/txs-XXXX.tmp");
3166	}
3167	strcpy(g_szScratchPath, g_szDefScratchPath);
3168
3169	/*
3170	* The default transporter is the first one.
3171	*/
3172	g_pTransport = g_apTransports[0];
3173	}
3174
3175	/**
3176	* Prints the usage.
3177	*
3178	* @param pStrm Where to print it.
3179	* @param pszArgv0 The program name (argv[0]).
3180	*/
3181	static void txsUsage(PRTSTREAM pStrm, const char *argv0)
3182	{
3183	RTStrmPrintf(pStrm,
3184	"Usage: %Rbn [options]\n"
3185	"\n"
3186	"Options:\n"
3187	" --cdrom <path>\n"
3188	" Where the CD/DVD-ROM will be mounted.\n"
3189	" Default: %s\n"
3190	" --scratch <path>\n"
3191	" Where to put scratch files.\n"
3192	" Default: %s \n"
3193	,
3194	argv0,
3195	g_szDefCdRomPath,
3196	g_szDefScratchPath);
3197	RTStrmPrintf(pStrm,
3198	" --transport <name>\n"
3199	" Use the specified transport layer, one of the following:\n");
3200	for (size_t i = 0; i < RT_ELEMENTS(g_apTransports); i++)
3201	RTStrmPrintf(pStrm, " %s - %s\n", g_apTransports[i]->szName, g_apTransports[i]->pszDesc);
3202	RTStrmPrintf(pStrm, " Default: %s\n", g_pTransport->szName);
3203	RTStrmPrintf(pStrm,
3204	" --auto-upgrade, --no-auto-upgrade\n"
3205	" To enable or disable the automatic upgrade mechanism where any different\n"
3206	" version found on the CD-ROM on startup will replace the initial copy.\n"
3207	" Default: --auto-upgrade\n"
3208	" --upgrading <org-path>\n"
3209	" Internal use only.\n");
3210	RTStrmPrintf(pStrm,
3211	" --display-output, --no-display-output\n"
3212	" Display the output and the result of all child processes.\n");
3213	RTStrmPrintf(pStrm,
3214	" --foreground\n"
3215	" Don't daemonize, run in the foreground.\n");
3216	RTStrmPrintf(pStrm,
3217	" --help, -h, -?\n"
3218	" Display this message and exit.\n"
3219	" --version, -V\n"
3220	" Display the version and exit.\n");
3221
3222	for (size_t i = 0; i < RT_ELEMENTS(g_apTransports); i++)
3223	if (g_apTransports[i]->cOpts)
3224	{
3225	RTStrmPrintf(pStrm,
3226	"\n"
3227	"Options for %s:\n", g_apTransports[i]->szName);
3228	g_apTransports[i]->pfnUsage(g_pStdOut);
3229	}
3230	}
3231
3232	/**
3233	* Parses the arguments.
3234	*
3235	* @returns Exit code. Exit if this is non-zero or @a *pfExit is set.
3236	* @param argc The number of arguments.
3237	* @param argv The argument vector.
3238	* @param pfExit For indicating exit when the exit code is zero.
3239	*/
3240	static RTEXITCODE txsParseArgv(int argc, char *argv, bool pfExit)
3241	{
3242	*pfExit = false;
3243
3244	/*
3245	* Storage for locally handled options.
3246	*/
3247	bool fAutoUpgrade = true;
3248	bool fDaemonize = true;
3249	bool fDaemonized = false;
3250	bool fTransportFixed = false;
3251	const char *pszUpgrading = NULL;
3252
3253	/*
3254	* Combine the base and transport layer option arrays.
3255	*/
3256	static const RTGETOPTDEF s_aBaseOptions[] =
3257	{
3258	{ "--transport", 't', RTGETOPT_REQ_STRING },
3259	{ "--cdrom", 'c', RTGETOPT_REQ_STRING },
3260	{ "--scratch", 's', RTGETOPT_REQ_STRING },
3261	{ "--auto-upgrade", 'a', RTGETOPT_REQ_NOTHING },
3262	{ "--no-auto-upgrade", 'A', RTGETOPT_REQ_NOTHING },
3263	{ "--upgrading", 'U', RTGETOPT_REQ_STRING },
3264	{ "--display-output", 'd', RTGETOPT_REQ_NOTHING },
3265	{ "--no-display-output",'D', RTGETOPT_REQ_NOTHING },
3266	{ "--foreground", 'f', RTGETOPT_REQ_NOTHING },
3267	{ "--daemonized", 'Z', RTGETOPT_REQ_NOTHING },
3268	};
3269
3270	size_t cOptions = RT_ELEMENTS(s_aBaseOptions);
3271	for (size_t i = 0; i < RT_ELEMENTS(g_apTransports); i++)
3272	cOptions += g_apTransports[i]->cOpts;
3273
3274	PRTGETOPTDEF paOptions = (PRTGETOPTDEF)alloca(cOptions * sizeof(RTGETOPTDEF));
3275	if (!paOptions)
3276	return RTMsgErrorExit(RTEXITCODE_FAILURE, "alloca failed\n");
3277
3278	memcpy(paOptions, s_aBaseOptions, sizeof(s_aBaseOptions));
3279	cOptions = RT_ELEMENTS(s_aBaseOptions);
3280	for (size_t i = 0; i < RT_ELEMENTS(g_apTransports); i++)
3281	{
3282	memcpy(&paOptions[cOptions], g_apTransports[i]->paOpts, g_apTransports[i]->cOpts * sizeof(RTGETOPTDEF));
3283	cOptions += g_apTransports[i]->cOpts;
3284	}
3285
3286	/*
3287	* Parse the arguments.
3288	*/
3289	RTGETOPTSTATE GetState;
3290	int rc = RTGetOptInit(&GetState, argc, argv, paOptions, cOptions, 1, 0 /* fFlags */);
3291	AssertRC(rc);
3292
3293	int ch;
3294	RTGETOPTUNION Val;
3295	while ((ch = RTGetOpt(&GetState, &Val)))
3296	{
3297	switch (ch)
3298	{
3299	case 'a':
3300	fAutoUpgrade = true;
3301	break;
3302
3303	case 'A':
3304	fAutoUpgrade = false;
3305	break;
3306
3307	case 'c':
3308	rc = RTStrCopy(g_szCdRomPath, sizeof(g_szCdRomPath), Val.psz);
3309	if (RT_FAILURE(rc))
3310	return RTMsgErrorExit(RTEXITCODE_FAILURE, "CD/DVD-ROM is path too long (%Rrc)\n", rc);
3311	break;
3312
3313	case 'd':
3314	g_fDisplayOutput = true;
3315	break;
3316
3317	case 'D':
3318	g_fDisplayOutput = false;
3319	break;
3320
3321	case 'f':
3322	fDaemonize = false;
3323	break;
3324
3325	case 'h':
3326	txsUsage(g_pStdOut, argv[0]);
3327	*pfExit = true;
3328	return RTEXITCODE_SUCCESS;
3329
3330	case 's':
3331	rc = RTStrCopy(g_szScratchPath, sizeof(g_szScratchPath), Val.psz);
3332	if (RT_FAILURE(rc))
3333	return RTMsgErrorExit(RTEXITCODE_FAILURE, "scratch path is too long (%Rrc)\n", rc);
3334	break;
3335
3336	case 't':
3337	{
3338	PCTXSTRANSPORT pTransport = NULL;
3339	for (size_t i = 0; RT_ELEMENTS(g_apTransports); i++)
3340	if (!strcmp(g_apTransports[i]->szName, Val.psz))
3341	{
3342	pTransport = g_apTransports[i];
3343	break;
3344	}
3345	if (!pTransport)
3346	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown transport layer name '%s'\n", Val.psz);
3347	g_pTransport = pTransport;
3348	break;
3349	}
3350
3351	case 'U':
3352	pszUpgrading = Val.psz;
3353	break;
3354
3355	case 'V':
3356	RTPrintf("$Revision: 62158 $\n");
3357	*pfExit = true;
3358	return RTEXITCODE_SUCCESS;
3359
3360	case 'Z':
3361	fDaemonized = true;
3362	fDaemonize = false;
3363	break;
3364
3365	default:
3366	{
3367	rc = VERR_TRY_AGAIN;
3368	for (size_t i = 0; i < RT_ELEMENTS(g_apTransports); i++)
3369	if (g_apTransports[i]->cOpts)
3370	{
3371	rc = g_apTransports[i]->pfnOption(ch, &Val);
3372	if (RT_SUCCESS(rc))
3373	break;
3374	if (rc != VERR_TRY_AGAIN)
3375	{
3376	*pfExit = true;
3377	return RTEXITCODE_SYNTAX;
3378	}
3379	}
3380	if (rc == VERR_TRY_AGAIN)
3381	{
3382	*pfExit = true;
3383	return RTGetOptPrintError(ch, &Val);
3384	}
3385	break;
3386	}
3387	}
3388	}
3389
3390	/*
3391	* Handle automatic upgrading of the service.
3392	*/
3393	if (fAutoUpgrade && !*pfExit)
3394	{
3395	RTEXITCODE rcExit;
3396	if (pszUpgrading)
3397	rcExit = txsAutoUpdateStage2(argc, argv, pfExit, pszUpgrading);
3398	else
3399	rcExit = txsAutoUpdateStage1(argc, argv, pfExit);
3400	if ( *pfExit
3401	\|\| rcExit != RTEXITCODE_SUCCESS)
3402	return rcExit;
3403	}
3404
3405	/*
3406	* Daemonize ourselves if asked to.
3407	*/
3408	if (fDaemonize && !*pfExit)
3409	{
3410	rc = RTProcDaemonize(argv, "--daemonized");
3411	if (RT_FAILURE(rc))
3412	return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTProcDaemonize: %Rrc\n", rc);
3413	*pfExit = true;
3414	}
3415
3416	return RTEXITCODE_SUCCESS;
3417	}
3418
3419
3420	int main(int argc, char **argv)
3421	{
3422	/*
3423	* Initialize the runtime.
3424	*/
3425	int rc = RTR3InitExe(argc, &argv, 0);
3426	if (RT_FAILURE(rc))
3427	return RTMsgInitFailure(rc);
3428
3429	/*
3430	* Determine defaults and parse the arguments.
3431	*/
3432	txsSetDefaults();
3433	bool fExit;
3434	RTEXITCODE rcExit = txsParseArgv(argc, argv, &fExit);
3435	if (rcExit != RTEXITCODE_SUCCESS \|\| fExit)
3436	return rcExit;
3437
3438	/*
3439	* Generate a UUID for this TXS instance.
3440	*/
3441	rc = RTUuidCreate(&g_InstanceUuid);
3442	if (RT_FAILURE(rc))
3443	return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTUuidCreate failed: %Rrc", rc);
3444
3445	/*
3446	* Finalize the scratch directory and initialize the transport layer.
3447	*/
3448	rcExit = txsFinalizeScratch();
3449	if (rcExit != RTEXITCODE_SUCCESS)
3450	return rcExit;
3451
3452	rc = g_pTransport->pfnInit();
3453	if (RT_FAILURE(rc))
3454	return RTEXITCODE_FAILURE;
3455
3456	/*
3457	* Ok, start working
3458	*/
3459	rcExit = txsMainLoop();
3460
3461	/*
3462	* Cleanup.
3463	*/
3464	g_pTransport->pfnTerm();
3465
3466	return rcExit;
3467	}
3468

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

source: vbox/trunk/src/VBox/ValidationKit/utils/TestExecServ/TestExecService.cpp@ 62158

Download in other formats: