VBoxServiceControlProcess.cpp@ 98613

Last change on this file since 98613 was 98103, checked in by vboxsync, 23 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 86.0 KB

Line
1	/* $Id: VBoxServiceControlProcess.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* VBoxServiceControlThread - Guest process handling.
4	*/
5
6	/*
7	* Copyright (C) 2012-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#include <iprt/asm.h>
33	#include <iprt/assert.h>
34	#include <iprt/env.h>
35	#include <iprt/file.h>
36	#include <iprt/getopt.h>
37	#include <iprt/handle.h>
38	#include <iprt/mem.h>
39	#include <iprt/path.h>
40	#include <iprt/pipe.h>
41	#include <iprt/poll.h>
42	#include <iprt/process.h>
43	#include <iprt/semaphore.h>
44	#include <iprt/string.h>
45	#include <iprt/string.h>
46	#include <iprt/system.h>
47	#include <iprt/thread.h>
48
49	#include <VBox/VBoxGuestLib.h>
50	#include <VBox/HostServices/GuestControlSvc.h>
51
52	#include "VBoxServiceInternal.h"
53	#include "VBoxServiceControl.h"
54	#include "VBoxServiceToolBox.h"
55
56	using namespace guestControl;
57
58
59	/*********************************************************************************************************************************
60	* Internal Functions *
61	*********************************************************************************************************************************/
62	static int vgsvcGstCtrlProcessAssignPID(PVBOXSERVICECTRLPROCESS pThread, uint32_t uPID);
63	static int vgsvcGstCtrlProcessLock(PVBOXSERVICECTRLPROCESS pProcess);
64	static int vgsvcGstCtrlProcessSetupPipe(const char pszHowTo, int fd, PRTHANDLE ph, PRTHANDLE pph,
65	PRTPIPE phPipe);
66	static int vgsvcGstCtrlProcessUnlock(PVBOXSERVICECTRLPROCESS pProcess);
67	/* Request handlers. */
68	static DECLCALLBACK(int) vgsvcGstCtrlProcessOnInput(PVBOXSERVICECTRLPROCESS pThis, const PVBGLR3GUESTCTRLCMDCTX pHostCtx,
69	bool fPendingClose, void *pvBuf, uint32_t cbBuf);
70	static DECLCALLBACK(int) vgsvcGstCtrlProcessOnOutput(PVBOXSERVICECTRLPROCESS pThis, const PVBGLR3GUESTCTRLCMDCTX pHostCtx,
71	uint32_t uHandle, uint32_t cbToRead, uint32_t uFlags);
72
73
74
75	/**
76	* Initialies the passed in thread data structure with the parameters given.
77	*
78	* @return IPRT status code.
79	* @param pProcess Process to initialize.
80	* @param pSession Guest session the process is bound to.
81	* @param pStartupInfo Startup information.
82	* @param u32ContextID The context ID bound to this request / command.
83	*/
84	static int vgsvcGstCtrlProcessInit(PVBOXSERVICECTRLPROCESS pProcess,
85	const PVBOXSERVICECTRLSESSION pSession,
86	const PVBGLR3GUESTCTRLPROCSTARTUPINFO pStartupInfo,
87	uint32_t u32ContextID)
88	{
89	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
90	AssertPtrReturn(pSession, VERR_INVALID_POINTER);
91	AssertPtrReturn(pStartupInfo, VERR_INVALID_POINTER);
92
93	/* General stuff. */
94	pProcess->hProcess = NIL_RTPROCESS;
95	pProcess->pSession = pSession;
96	pProcess->Node.pPrev = NULL;
97	pProcess->Node.pNext = NULL;
98
99	pProcess->fShutdown = false;
100	pProcess->fStarted = false;
101	pProcess->fStopped = false;
102
103	pProcess->uPID = 0; /* Don't have a PID yet. */
104	pProcess->cRefs = 0;
105	/*
106	* Use the initial context ID we got for starting
107	* the process to report back its status with the
108	* same context ID.
109	*/
110	pProcess->uContextID = u32ContextID;
111	/*
112	* Note: pProcess->ClientID will be assigned when thread is started;
113	* every guest process has its own client ID to detect crashes on
114	* a per-guest-process level.
115	*/
116
117	int rc = RTCritSectInit(&pProcess->CritSect);
118	if (RT_FAILURE(rc))
119	return rc;
120
121	pProcess->hPollSet = NIL_RTPOLLSET;
122	pProcess->hPipeStdInW = NIL_RTPIPE;
123	pProcess->hPipeStdOutR = NIL_RTPIPE;
124	pProcess->hPipeStdErrR = NIL_RTPIPE;
125	pProcess->hNotificationPipeW = NIL_RTPIPE;
126	pProcess->hNotificationPipeR = NIL_RTPIPE;
127
128	rc = RTReqQueueCreate(&pProcess->hReqQueue);
129	AssertReleaseRC(rc);
130
131	/* Duplicate startup info. */
132	pProcess->pStartupInfo = VbglR3GuestCtrlProcStartupInfoDup(pStartupInfo);
133	AssertPtrReturn(pProcess->pStartupInfo, VERR_NO_MEMORY);
134
135	/* Adjust timeout value. */
136	if ( pProcess->pStartupInfo->uTimeLimitMS == UINT32_MAX
137	\|\| pProcess->pStartupInfo->uTimeLimitMS == 0)
138	pProcess->pStartupInfo->uTimeLimitMS = RT_INDEFINITE_WAIT;
139
140	if (RT_FAILURE(rc)) /* Clean up on failure. */
141	VGSvcGstCtrlProcessFree(pProcess);
142	return rc;
143	}
144
145
146	/**
147	* Frees a guest process. On success, pProcess will be
148	* free'd and thus won't be available anymore.
149	*
150	* @return IPRT status code.
151	* @param pProcess Guest process to free.
152	* The pointer will not be valid anymore after return.
153	*/
154	int VGSvcGstCtrlProcessFree(PVBOXSERVICECTRLPROCESS pProcess)
155	{
156	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
157
158	int rc = RTCritSectEnter(&pProcess->CritSect);
159	if (RT_SUCCESS(rc))
160	{
161	VGSvcVerbose(3, "[PID %RU32]: Freeing (cRefs=%RU32)...\n", pProcess->uPID, pProcess->cRefs);
162
163	AssertReturn(pProcess->cRefs == 0, VERR_WRONG_ORDER);
164	AssertReturn(pProcess->fStopped, VERR_WRONG_ORDER);
165	AssertReturn(pProcess->fShutdown, VERR_WRONG_ORDER);
166
167	VbglR3GuestCtrlProcStartupInfoFree(pProcess->pStartupInfo);
168	pProcess->pStartupInfo = NULL;
169
170	/*
171	* Destroy other thread data.
172	*/
173	rc = RTPollSetDestroy(pProcess->hPollSet);
174	AssertRC(rc);
175
176	rc = RTReqQueueDestroy(pProcess->hReqQueue);
177	AssertRC(rc);
178
179	rc = RTPipeClose(pProcess->hNotificationPipeR);
180	AssertRC(rc);
181	rc = RTPipeClose(pProcess->hNotificationPipeW);
182	AssertRC(rc);
183
184	rc = RTPipeClose(pProcess->hPipeStdInW);
185	AssertRC(rc);
186	rc = RTPipeClose(pProcess->hPipeStdErrR);
187	AssertRC(rc);
188	rc = RTPipeClose(pProcess->hPipeStdOutR);
189	AssertRC(rc);
190
191	rc = RTCritSectLeave(&pProcess->CritSect);
192	AssertRC(rc);
193
194	RTCritSectDelete(&pProcess->CritSect);
195
196	/*
197	* Destroy thread structure as final step.
198	*/
199	RTMemFree(pProcess);
200	pProcess = NULL;
201	}
202
203	return rc;
204	}
205
206
207	/**
208	* Signals a guest process thread that we want it to shut down in
209	* a gentle way.
210	*
211	* @return IPRT status code.
212	* @param pProcess Process to stop.
213	*/
214	int VGSvcGstCtrlProcessStop(PVBOXSERVICECTRLPROCESS pProcess)
215	{
216	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
217
218	VGSvcVerbose(3, "[PID %RU32]: Stopping ...\n", pProcess->uPID);
219
220	/* Do not set pThread->fShutdown or other stuff here!
221	* The guest thread loop will clean up itself. */
222
223	return VGSvcGstCtrlProcessHandleTerm(pProcess);
224	}
225
226
227	/**
228	* Releases a previously acquired guest process (decreases the refcount).
229	*
230	* @param pProcess Process to release.
231	*/
232	void VGSvcGstCtrlProcessRelease(PVBOXSERVICECTRLPROCESS pProcess)
233	{
234	AssertPtrReturnVoid(pProcess);
235
236	int rc2 = RTCritSectEnter(&pProcess->CritSect);
237	if (RT_SUCCESS(rc2))
238	{
239	AssertReturnVoid(pProcess->cRefs);
240	pProcess->cRefs--;
241
242	VGSvcVerbose(3, "[PID %RU32]: cRefs=%RU32, fShutdown=%RTbool, fStopped=%RTbool\n",
243	pProcess->uPID, pProcess->cRefs, pProcess->fShutdown, pProcess->fStopped);
244
245	rc2 = RTCritSectLeave(&pProcess->CritSect);
246	AssertRC(rc2);
247	}
248	}
249
250
251	/**
252	* Wait for a guest process thread to shut down.
253	*
254	* @return IPRT status code.
255	* @param pProcess Process to wait shutting down for.
256	* @param msTimeout Timeout in ms to wait for shutdown.
257	* @param prc Where to store the thread's return code.
258	* Optional.
259	*/
260	int VGSvcGstCtrlProcessWait(const PVBOXSERVICECTRLPROCESS pProcess, RTMSINTERVAL msTimeout, int *prc)
261	{
262	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
263	AssertPtrNullReturn(prc, VERR_INVALID_POINTER);
264
265	int rc = vgsvcGstCtrlProcessLock(pProcess);
266	if (RT_SUCCESS(rc))
267	{
268	if (RTThreadGetState(pProcess->Thread) != RTTHREADSTATE_INVALID) /* Is there a thread we can wait for? */
269	{
270	VGSvcVerbose(2, "[PID %RU32]: Waiting for shutdown (%RU32ms) ...\n", pProcess->uPID, msTimeout);
271
272	AssertMsgReturn(pProcess->fStarted,
273	("Tried to wait on guest process=%p (PID %RU32) which has not been started yet\n",
274	pProcess, pProcess->uPID), VERR_INVALID_PARAMETER);
275
276	/* Unlock process before waiting. */
277	rc = vgsvcGstCtrlProcessUnlock(pProcess);
278	AssertRC(rc);
279
280	/* Do the actual waiting. */
281	int rcThread;
282	Assert(pProcess->Thread != NIL_RTTHREAD);
283	rc = RTThreadWait(pProcess->Thread, msTimeout, &rcThread);
284
285	int rc2 = vgsvcGstCtrlProcessLock(pProcess);
286	AssertRC(rc2);
287
288	if (RT_SUCCESS(rc))
289	{
290	pProcess->Thread = NIL_RTTHREAD;
291	VGSvcVerbose(3, "[PID %RU32]: Thread shutdown complete, thread rc=%Rrc\n", pProcess->uPID, rcThread);
292	if (prc)
293	*prc = rcThread;
294	}
295	}
296
297	int rc2 = vgsvcGstCtrlProcessUnlock(pProcess);
298	AssertRC(rc2);
299	}
300
301	if (RT_FAILURE(rc))
302	VGSvcError("[PID %RU32]: Waiting for shutting down thread returned error rc=%Rrc\n", pProcess->uPID, rc);
303
304	VGSvcVerbose(3, "[PID %RU32]: Waiting resulted in rc=%Rrc\n", pProcess->uPID, rc);
305	return rc;
306	}
307
308
309	/**
310	* Closes the stdin pipe of a guest process.
311	*
312	* @return IPRT status code.
313	* @param pProcess The process which input pipe we close.
314	* @param phStdInW The standard input pipe handle.
315	*/
316	static int vgsvcGstCtrlProcessPollsetCloseInput(PVBOXSERVICECTRLPROCESS pProcess, PRTPIPE phStdInW)
317	{
318	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
319	AssertPtrReturn(phStdInW, VERR_INVALID_POINTER);
320
321	int rc = RTPollSetRemove(pProcess->hPollSet, VBOXSERVICECTRLPIPEID_STDIN);
322	if (rc != VERR_POLL_HANDLE_ID_NOT_FOUND)
323	AssertRC(rc);
324
325	if (*phStdInW != NIL_RTPIPE)
326	{
327	rc = RTPipeClose(*phStdInW);
328	AssertRC(rc);
329	*phStdInW = NIL_RTPIPE;
330	}
331
332	return rc;
333	}
334
335
336	#ifdef DEBUG
337	/**
338	* Names a poll handle ID.
339	*
340	* @returns Pointer to read-only string.
341	* @param idPollHnd What to name.
342	*/
343	static const char *vgsvcGstCtrlProcessPollHandleToString(uint32_t idPollHnd)
344	{
345	switch (idPollHnd)
346	{
347	case VBOXSERVICECTRLPIPEID_UNKNOWN:
348	return "unknown";
349	case VBOXSERVICECTRLPIPEID_STDIN:
350	return "stdin";
351	case VBOXSERVICECTRLPIPEID_STDIN_WRITABLE:
352	return "stdin_writable";
353	case VBOXSERVICECTRLPIPEID_STDOUT:
354	return "stdout";
355	case VBOXSERVICECTRLPIPEID_STDERR:
356	return "stderr";
357	case VBOXSERVICECTRLPIPEID_IPC_NOTIFY:
358	return "ipc_notify";
359	default:
360	return "unknown";
361	}
362	}
363	#endif /* DEBUG */
364
365
366	/**
367	* Handle an error event on standard input.
368	*
369	* @return IPRT status code.
370	* @param pProcess Process to handle pollset for.
371	* @param fPollEvt The event mask returned by RTPollNoResume.
372	* @param phStdInW The standard input pipe handle.
373	*/
374	static int vgsvcGstCtrlProcessPollsetOnInput(PVBOXSERVICECTRLPROCESS pProcess, uint32_t fPollEvt, PRTPIPE phStdInW)
375	{
376	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
377
378	NOREF(fPollEvt);
379
380	return vgsvcGstCtrlProcessPollsetCloseInput(pProcess, phStdInW);
381	}
382
383
384	/**
385	* Handle pending output data or error on standard out or standard error.
386	*
387	* @returns IPRT status code from client send.
388	* @param pProcess Process to handle pollset for.
389	* @param fPollEvt The event mask returned by RTPollNoResume.
390	* @param phPipeR The pipe handle.
391	* @param idPollHnd The pipe ID to handle.
392	*/
393	static int vgsvcGstCtrlProcessHandleOutputError(PVBOXSERVICECTRLPROCESS pProcess,
394	uint32_t fPollEvt, PRTPIPE phPipeR, uint32_t idPollHnd)
395	{
396	RT_NOREF1(fPollEvt);
397	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
398
399	if (!phPipeR)
400	return VINF_SUCCESS;
401
402	#ifdef DEBUG
403	VGSvcVerbose(4, "[PID %RU32]: Output error: idPollHnd=%s, fPollEvt=0x%x\n",
404	pProcess->uPID, vgsvcGstCtrlProcessPollHandleToString(idPollHnd), fPollEvt);
405	#endif
406
407	/* Remove pipe from poll set. */
408	int rc2 = RTPollSetRemove(pProcess->hPollSet, idPollHnd);
409	AssertMsg(RT_SUCCESS(rc2) \|\| rc2 == VERR_POLL_HANDLE_ID_NOT_FOUND, ("%Rrc\n", rc2));
410
411	bool fClosePipe = true; /* By default close the pipe. */
412
413	/* Check if there's remaining data to read from the pipe. */
414	if (*phPipeR != NIL_RTPIPE)
415	{
416	size_t cbReadable;
417	rc2 = RTPipeQueryReadable(*phPipeR, &cbReadable);
418	if ( RT_SUCCESS(rc2)
419	&& cbReadable)
420	{
421	#ifdef DEBUG
422	VGSvcVerbose(3, "[PID %RU32]: idPollHnd=%s has %zu bytes left, vetoing close\n",
423	pProcess->uPID, vgsvcGstCtrlProcessPollHandleToString(idPollHnd), cbReadable);
424	#endif
425	/* Veto closing the pipe yet because there's still stuff to read
426	* from the pipe. This can happen on UNIX-y systems where on
427	* error/hangup there still can be data to be read out. */
428	fClosePipe = false;
429	}
430	}
431	#ifdef DEBUG
432	else
433	VGSvcVerbose(3, "[PID %RU32]: idPollHnd=%s will be closed\n",
434	pProcess->uPID, vgsvcGstCtrlProcessPollHandleToString(idPollHnd));
435	#endif
436
437	if ( *phPipeR != NIL_RTPIPE
438	&& fClosePipe)
439	{
440	rc2 = RTPipeClose(*phPipeR);
441	AssertRC(rc2);
442	*phPipeR = NIL_RTPIPE;
443	}
444
445	return VINF_SUCCESS;
446	}
447
448
449	/**
450	* Handle pending output data or error on standard out or standard error.
451	*
452	* @returns IPRT status code from client send.
453	* @param pProcess Process to handle pollset for.
454	* @param fPollEvt The event mask returned by RTPollNoResume.
455	* @param phPipeR The pipe handle.
456	* @param idPollHnd The pipe ID to handle.
457	*
458	*/
459	static int vgsvcGstCtrlProcessPollsetOnOutput(PVBOXSERVICECTRLPROCESS pProcess,
460	uint32_t fPollEvt, PRTPIPE phPipeR, uint32_t idPollHnd)
461	{
462	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
463
464	#ifdef DEBUG
465	VGSvcVerbose(4, "[PID %RU32]: Output event phPipeR=%p, idPollHnd=%s, fPollEvt=0x%x\n",
466	pProcess->uPID, phPipeR, vgsvcGstCtrlProcessPollHandleToString(idPollHnd), fPollEvt);
467	#endif
468
469	if (!phPipeR)
470	return VINF_SUCCESS;
471
472	int rc = VINF_SUCCESS;
473
474	#ifdef DEBUG
475	if (*phPipeR != NIL_RTPIPE)
476	{
477	size_t cbReadable;
478	rc = RTPipeQueryReadable(*phPipeR, &cbReadable);
479	if ( RT_SUCCESS(rc)
480	&& cbReadable)
481	{
482	VGSvcVerbose(4, "[PID %RU32]: Output event cbReadable=%zu\n", pProcess->uPID, cbReadable);
483	}
484	}
485	#endif
486
487	#if 0
488	/* Push output to the host. */
489	if (fPollEvt & RTPOLL_EVT_READ)
490	{
491	size_t cbRead = 0;
492	uint8_t byData[_64K];
493	rc = RTPipeRead(*phPipeR, byData, sizeof(byData), &cbRead);
494	VGSvcVerbose(4, "VGSvcGstCtrlProcessHandleOutputEvent cbRead=%u, rc=%Rrc\n", cbRead, rc);
495
496	/* Make sure we go another poll round in case there was too much data
497	for the buffer to hold. */
498	fPollEvt &= RTPOLL_EVT_ERROR;
499	}
500	#endif
501
502	if (fPollEvt & RTPOLL_EVT_ERROR)
503	rc = vgsvcGstCtrlProcessHandleOutputError(pProcess, fPollEvt, phPipeR, idPollHnd);
504	return rc;
505	}
506
507
508	/**
509	* Execution loop which runs in a dedicated per-started-process thread and
510	* handles all pipe input/output and signalling stuff.
511	*
512	* @return IPRT status code.
513	* @param pProcess The guest process to handle.
514	*/
515	static int vgsvcGstCtrlProcessProcLoop(PVBOXSERVICECTRLPROCESS pProcess)
516	{
517	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
518
519	int rc;
520	int rc2;
521	uint64_t const uMsStart = RTTimeMilliTS();
522	RTPROCSTATUS ProcessStatus = { 254, RTPROCEXITREASON_ABEND };
523	bool fProcessAlive = true;
524	bool fProcessTimedOut = false;
525	uint64_t MsProcessKilled = UINT64_MAX;
526	RTMSINTERVAL const cMsPollBase = pProcess->hPipeStdInW != NIL_RTPIPE
527	? 100 /* Need to poll for input. */
528	: 1000; /* Need only poll for process exit and aborts. */
529	RTMSINTERVAL cMsPollCur = 0;
530
531	/*
532	* Assign PID to thread data.
533	* Also check if there already was a thread with the same PID and shut it down -- otherwise
534	* the first (stale) entry will be found and we get really weird results!
535	*/
536	rc = vgsvcGstCtrlProcessAssignPID(pProcess, pProcess->hProcess /* Opaque PID handle */);
537	if (RT_FAILURE(rc))
538	{
539	VGSvcError("Unable to assign PID=%u, to new thread, rc=%Rrc\n", pProcess->hProcess, rc);
540	return rc;
541	}
542
543	/*
544	* Before entering the loop, tell the host that we've started the guest
545	* and that it's now OK to send input to the process.
546	*/
547	VGSvcVerbose(2, "[PID %RU32]: Process '%s' started, CID=%u, User=%s, cMsTimeout=%RU32\n",
548	pProcess->uPID, pProcess->pStartupInfo->pszCmd, pProcess->uContextID,
549	pProcess->pStartupInfo->pszUser, pProcess->pStartupInfo->uTimeLimitMS);
550	VBGLR3GUESTCTRLCMDCTX ctxStart = { g_idControlSvcClient, pProcess->uContextID, 0 /* uProtocol /, 0 / uNumParms */ };
551	rc = VbglR3GuestCtrlProcCbStatus(&ctxStart,
552	pProcess->uPID, PROC_STS_STARTED, 0 /* u32Flags */,
553	NULL /* pvData /, 0 / cbData */);
554	if (rc == VERR_INTERRUPTED)
555	rc = VINF_SUCCESS; /* SIGCHLD send by quick childs! */
556	if (RT_FAILURE(rc))
557	VGSvcError("[PID %RU32]: Error reporting starting status to host, rc=%Rrc\n", pProcess->uPID, rc);
558
559	/*
560	* Process input, output, the test pipe and client requests.
561	*/
562	while ( RT_SUCCESS(rc)
563	&& RT_UNLIKELY(!pProcess->fShutdown))
564	{
565	/*
566	* Wait/Process all pending events.
567	*/
568	uint32_t idPollHnd;
569	uint32_t fPollEvt;
570	rc2 = RTPollNoResume(pProcess->hPollSet, cMsPollCur, &fPollEvt, &idPollHnd);
571	if (pProcess->fShutdown)
572	continue;
573
574	cMsPollCur = 0; /* No rest until we've checked everything. */
575
576	if (RT_SUCCESS(rc2))
577	{
578	switch (idPollHnd)
579	{
580	case VBOXSERVICECTRLPIPEID_STDIN:
581	rc = vgsvcGstCtrlProcessPollsetOnInput(pProcess, fPollEvt, &pProcess->hPipeStdInW);
582	break;
583
584	case VBOXSERVICECTRLPIPEID_STDOUT:
585	rc = vgsvcGstCtrlProcessPollsetOnOutput(pProcess, fPollEvt, &pProcess->hPipeStdOutR, idPollHnd);
586	break;
587
588	case VBOXSERVICECTRLPIPEID_STDERR:
589	rc = vgsvcGstCtrlProcessPollsetOnOutput(pProcess, fPollEvt, &pProcess->hPipeStdErrR, idPollHnd);
590	break;
591
592	case VBOXSERVICECTRLPIPEID_IPC_NOTIFY:
593	#ifdef DEBUG_andy
594	VGSvcVerbose(4, "[PID %RU32]: IPC notify\n", pProcess->uPID);
595	#endif
596	rc2 = vgsvcGstCtrlProcessLock(pProcess);
597	if (RT_SUCCESS(rc2))
598	{
599	/* Drain the notification pipe. */
600	uint8_t abBuf[8];
601	size_t cbIgnore;
602	rc2 = RTPipeRead(pProcess->hNotificationPipeR, abBuf, sizeof(abBuf), &cbIgnore);
603	if (RT_FAILURE(rc2))
604	VGSvcError("Draining IPC notification pipe failed with rc=%Rrc\n", rc2);
605
606	/* Process all pending requests. */
607	VGSvcVerbose(4, "[PID %RU32]: Processing pending requests ...\n", pProcess->uPID);
608	Assert(pProcess->hReqQueue != NIL_RTREQQUEUE);
609	rc2 = RTReqQueueProcess(pProcess->hReqQueue,
610	0 /* Only process all pending requests, don't wait for new ones */);
611	if ( RT_FAILURE(rc2)
612	&& rc2 != VERR_TIMEOUT)
613	VGSvcError("Processing requests failed with with rc=%Rrc\n", rc2);
614
615	int rc3 = vgsvcGstCtrlProcessUnlock(pProcess);
616	AssertRC(rc3);
617	#ifdef DEBUG
618	VGSvcVerbose(4, "[PID %RU32]: Processing pending requests done, rc=%Rrc\n", pProcess->uPID, rc2);
619	#endif
620	}
621
622	break;
623
624	default:
625	AssertMsgFailed(("Unknown idPollHnd=%RU32\n", idPollHnd));
626	break;
627	}
628
629	if (RT_FAILURE(rc) \|\| rc == VINF_EOF)
630	break; /* Abort command, or client dead or something. */
631	}
632	#if 0
633	VGSvcVerbose(4, "[PID %RU32]: Polling done, pollRc=%Rrc, pollCnt=%RU32, idPollHnd=%s, rc=%Rrc, fProcessAlive=%RTbool, fShutdown=%RTbool\n",
634	pProcess->uPID, rc2, RTPollSetGetCount(hPollSet), vgsvcGstCtrlProcessPollHandleToString(idPollHnd), rc, fProcessAlive, pProcess->fShutdown);
635	VGSvcVerbose(4, "[PID %RU32]: stdOut=%s, stdErrR=%s\n",
636	pProcess->uPID,
637	*phStdOutR == NIL_RTPIPE ? "closed" : "open",
638	*phStdErrR == NIL_RTPIPE ? "closed" : "open");
639	#endif
640	if (RT_UNLIKELY(pProcess->fShutdown))
641	break; /* We were asked to shutdown. */
642
643	/*
644	* Check for process death.
645	*/
646	if (fProcessAlive)
647	{
648	rc2 = RTProcWaitNoResume(pProcess->hProcess, RTPROCWAIT_FLAGS_NOBLOCK, &ProcessStatus);
649	if (RT_SUCCESS_NP(rc2))
650	{
651	fProcessAlive = false;
652	/* Note: Don't bail out here yet. First check in the next block below
653	* if all needed pipe outputs have been consumed. */
654	}
655	else
656	{
657	if (RT_UNLIKELY(rc2 == VERR_INTERRUPTED))
658	continue;
659	if (RT_UNLIKELY(rc2 == VERR_PROCESS_NOT_FOUND))
660	{
661	fProcessAlive = false;
662	ProcessStatus.enmReason = RTPROCEXITREASON_ABEND;
663	ProcessStatus.iStatus = 255;
664	AssertFailed();
665	}
666	else
667	AssertMsg(rc2 == VERR_PROCESS_RUNNING, ("%Rrc\n", rc2));
668	}
669	}
670
671	/*
672	* If the process has terminated and all output has been consumed,
673	* we should be heading out.
674	*/
675	if (!fProcessAlive)
676	{
677	if ( fProcessTimedOut
678	\|\| ( pProcess->hPipeStdOutR == NIL_RTPIPE
679	&& pProcess->hPipeStdErrR == NIL_RTPIPE)
680	)
681	{
682	VGSvcVerbose(3, "[PID %RU32]: RTProcWaitNoResume=%Rrc\n", pProcess->uPID, rc2);
683	break;
684	}
685	}
686
687	/*
688	* Check for timed out, killing the process.
689	*/
690	uint32_t cMilliesLeft = RT_INDEFINITE_WAIT;
691	if ( pProcess->pStartupInfo->uTimeLimitMS != RT_INDEFINITE_WAIT
692	&& pProcess->pStartupInfo->uTimeLimitMS != 0)
693	{
694	uint64_t u64Now = RTTimeMilliTS();
695	uint64_t cMsElapsed = u64Now - uMsStart;
696	if (cMsElapsed >= pProcess->pStartupInfo->uTimeLimitMS)
697	{
698	fProcessTimedOut = true;
699	if ( MsProcessKilled == UINT64_MAX
700	\|\| u64Now - MsProcessKilled > 1000)
701	{
702	if (u64Now - MsProcessKilled > 20601000)
703	break; /* Give up after 20 mins. */
704
705	VGSvcVerbose(3, "[PID %RU32]: Timed out (%RU64ms elapsed > %RU32ms timeout), killing ...\n",
706	pProcess->uPID, cMsElapsed, pProcess->pStartupInfo->uTimeLimitMS);
707
708	rc2 = RTProcTerminate(pProcess->hProcess);
709	VGSvcVerbose(3, "[PID %RU32]: Killing process resulted in rc=%Rrc\n",
710	pProcess->uPID, rc2);
711	MsProcessKilled = u64Now;
712	continue;
713	}
714	cMilliesLeft = 10000;
715	}
716	else
717	cMilliesLeft = pProcess->pStartupInfo->uTimeLimitMS - (uint32_t)cMsElapsed;
718	}
719
720	/* Reset the polling interval since we've done all pending work. */
721	cMsPollCur = fProcessAlive
722	? cMsPollBase
723	: RT_MS_1MIN;
724	if (cMilliesLeft < cMsPollCur)
725	cMsPollCur = cMilliesLeft;
726	}
727
728	VGSvcVerbose(3, "[PID %RU32]: Loop ended: rc=%Rrc, fShutdown=%RTbool, fProcessAlive=%RTbool, fProcessTimedOut=%RTbool, MsProcessKilled=%RU64 (%RX64)\n",
729	pProcess->uPID, rc, pProcess->fShutdown, fProcessAlive, fProcessTimedOut, MsProcessKilled, MsProcessKilled);
730	VGSvcVerbose(3, "[PID %RU32]: phStdOutR=%s, phStdErrR=%s\n",
731	pProcess->uPID,
732	pProcess->hPipeStdOutR == NIL_RTPIPE ? "closed" : "open",
733	pProcess->hPipeStdErrR == NIL_RTPIPE ? "closed" : "open");
734
735	/* Signal that this thread is in progress of shutting down. */
736	ASMAtomicWriteBool(&pProcess->fShutdown, true);
737
738	/*
739	* Try killing the process if it's still alive at this point.
740	*/
741	if (fProcessAlive)
742	{
743	if (MsProcessKilled == UINT64_MAX)
744	{
745	VGSvcVerbose(2, "[PID %RU32]: Is still alive and not killed yet\n", pProcess->uPID);
746
747	MsProcessKilled = RTTimeMilliTS();
748	rc2 = RTProcTerminate(pProcess->hProcess);
749	if (rc2 == VERR_NOT_FOUND)
750	{
751	fProcessAlive = false;
752	}
753	else if (RT_FAILURE(rc2))
754	VGSvcError("[PID %RU32]: Killing process failed with rc=%Rrc\n", pProcess->uPID, rc2);
755	RTThreadSleep(500);
756	}
757
758	for (int i = 0; i < 10 && fProcessAlive; i++)
759	{
760	VGSvcVerbose(4, "[PID %RU32]: Kill attempt %d/10: Waiting to exit ...\n", pProcess->uPID, i + 1);
761	rc2 = RTProcWait(pProcess->hProcess, RTPROCWAIT_FLAGS_NOBLOCK, &ProcessStatus);
762	if (RT_SUCCESS(rc2))
763	{
764	VGSvcVerbose(4, "[PID %RU32]: Kill attempt %d/10: Exited\n", pProcess->uPID, i + 1);
765	fProcessAlive = false;
766	break;
767	}
768	if (i >= 5)
769	{
770	VGSvcVerbose(4, "[PID %RU32]: Kill attempt %d/10: Trying to terminate ...\n", pProcess->uPID, i + 1);
771	rc2 = RTProcTerminate(pProcess->hProcess);
772	if ( RT_FAILURE(rc)
773	&& rc2 != VERR_NOT_FOUND)
774	VGSvcError("PID %RU32]: Killing process failed with rc=%Rrc\n",
775	pProcess->uPID, rc2);
776	}
777	RTThreadSleep(i >= 5 ? 2000 : 500);
778	}
779
780	if (fProcessAlive)
781	VGSvcError("[PID %RU32]: Could not be killed\n", pProcess->uPID);
782	}
783
784	/*
785	* Shutdown procedure:
786	* - Set the pProcess->fShutdown indicator to let others know we're
787	* not accepting any new requests anymore.
788	* - After setting the indicator, try to process all outstanding
789	* requests to make sure they're getting delivered.
790	*
791	* Note: After removing the process from the session's list it's not
792	* even possible for the session anymore to control what's
793	* happening to this thread, so be careful and don't mess it up.
794	*/
795
796	rc2 = vgsvcGstCtrlProcessLock(pProcess);
797	if (RT_SUCCESS(rc2))
798	{
799	VGSvcVerbose(3, "[PID %RU32]: Processing outstanding requests ...\n", pProcess->uPID);
800
801	/* Process all pending requests (but don't wait for new ones). */
802	Assert(pProcess->hReqQueue != NIL_RTREQQUEUE);
803	rc2 = RTReqQueueProcess(pProcess->hReqQueue, 0 /* No timeout */);
804	if ( RT_FAILURE(rc2)
805	&& rc2 != VERR_TIMEOUT)
806	VGSvcError("[PID %RU32]: Processing outstanding requests failed with with rc=%Rrc\n", pProcess->uPID, rc2);
807
808	VGSvcVerbose(3, "[PID %RU32]: Processing outstanding requests done, rc=%Rrc\n", pProcess->uPID, rc2);
809
810	rc2 = vgsvcGstCtrlProcessUnlock(pProcess);
811	AssertRC(rc2);
812	}
813
814	/*
815	* If we don't have a client problem (RT_FAILURE(rc)) we'll reply to the
816	* clients exec packet now.
817	*/
818	if (RT_SUCCESS(rc))
819	{
820	uint32_t uStatus = PROC_STS_UNDEFINED;
821	uint32_t fFlags = 0;
822
823	if ( fProcessTimedOut && !fProcessAlive && MsProcessKilled != UINT64_MAX)
824	{
825	VGSvcVerbose(3, "[PID %RU32]: Timed out and got killed\n", pProcess->uPID);
826	uStatus = PROC_STS_TOK;
827	}
828	else if (fProcessTimedOut && fProcessAlive && MsProcessKilled != UINT64_MAX)
829	{
830	VGSvcVerbose(3, "[PID %RU32]: Timed out and did not get killed\n", pProcess->uPID);
831	uStatus = PROC_STS_TOA;
832	}
833	else if (pProcess->fShutdown && (fProcessAlive \|\| MsProcessKilled != UINT64_MAX))
834	{
835	VGSvcVerbose(3, "[PID %RU32]: Got terminated because system/service is about to shutdown\n", pProcess->uPID);
836	uStatus = PROC_STS_DWN; /* Service is stopping, process was killed. */
837	fFlags = pProcess->pStartupInfo->fFlags; /* Return handed-in execution flags back to the host. */
838	}
839	else if (fProcessAlive)
840	VGSvcError("[PID %RU32]: Is alive when it should not!\n", pProcess->uPID);
841	else if (MsProcessKilled != UINT64_MAX)
842	VGSvcError("[PID %RU32]: Has been killed when it should not!\n", pProcess->uPID);
843	else if (ProcessStatus.enmReason == RTPROCEXITREASON_NORMAL)
844	{
845	VGSvcVerbose(3, "[PID %RU32]: Ended with RTPROCEXITREASON_NORMAL (Exit code: %d)\n",
846	pProcess->uPID, ProcessStatus.iStatus);
847	uStatus = PROC_STS_TEN;
848	fFlags = ProcessStatus.iStatus;
849	}
850	else if (ProcessStatus.enmReason == RTPROCEXITREASON_SIGNAL)
851	{
852	VGSvcVerbose(3, "[PID %RU32]: Ended with RTPROCEXITREASON_SIGNAL (Signal: %u)\n",
853	pProcess->uPID, ProcessStatus.iStatus);
854	uStatus = PROC_STS_TES;
855	fFlags = ProcessStatus.iStatus;
856	}
857	else if (ProcessStatus.enmReason == RTPROCEXITREASON_ABEND)
858	{
859	/* ProcessStatus.iStatus will be undefined. */
860	VGSvcVerbose(3, "[PID %RU32]: Ended with RTPROCEXITREASON_ABEND\n", pProcess->uPID);
861	uStatus = PROC_STS_TEA;
862	fFlags = ProcessStatus.iStatus;
863	}
864	else
865	VGSvcVerbose(1, "[PID %RU32]: Handling process status %u not implemented\n", pProcess->uPID, ProcessStatus.enmReason);
866	VBGLR3GUESTCTRLCMDCTX ctxEnd = { g_idControlSvcClient, pProcess->uContextID, 0 /* uProtocol /, 0 / uNumParms */ };
867	VGSvcVerbose(2, "[PID %RU32]: Ended, ClientID=%u, CID=%u, Status=%u, Flags=0x%x\n",
868	pProcess->uPID, ctxEnd.uClientID, pProcess->uContextID, uStatus, fFlags);
869
870	rc2 = VbglR3GuestCtrlProcCbStatus(&ctxEnd, pProcess->uPID, uStatus, fFlags, NULL /* pvData /, 0 / cbData */);
871	if ( RT_FAILURE(rc2)
872	&& rc2 == VERR_NOT_FOUND)
873	VGSvcError("[PID %RU32]: Error reporting final status to host; rc=%Rrc\n", pProcess->uPID, rc2);
874	}
875
876	VGSvcVerbose(3, "[PID %RU32]: Process loop returned with rc=%Rrc\n", pProcess->uPID, rc);
877	return rc;
878	}
879
880
881	#if 0 /* unused */
882	/**
883	* Initializes a pipe's handle and pipe object.
884	*
885	* @return IPRT status code.
886	* @param ph The pipe's handle to initialize.
887	* @param phPipe The pipe's object to initialize.
888	*/
889	static int vgsvcGstCtrlProcessInitPipe(PRTHANDLE ph, PRTPIPE phPipe)
890	{
891	AssertPtrReturn(ph, VERR_INVALID_PARAMETER);
892	AssertPtrReturn(phPipe, VERR_INVALID_PARAMETER);
893
894	ph->enmType = RTHANDLETYPE_PIPE;
895	ph->u.hPipe = NIL_RTPIPE;
896	*phPipe = NIL_RTPIPE;
897
898	return VINF_SUCCESS;
899	}
900	#endif
901
902
903	/**
904	* Sets up the redirection / pipe / nothing for one of the standard handles.
905	*
906	* @returns IPRT status code. No client replies made.
907	* @param pszHowTo How to set up this standard handle.
908	* @param fd Which standard handle it is (0 == stdin, 1 ==
909	* stdout, 2 == stderr).
910	* @param ph The generic handle that @a pph may be set
911	* pointing to. Always set.
912	* @param pph Pointer to the RTProcCreateExec argument.
913	* Always set.
914	* @param phPipe Where to return the end of the pipe that we
915	* should service.
916	*/
917	static int vgsvcGstCtrlProcessSetupPipe(const char pszHowTo, int fd, PRTHANDLE ph, PRTHANDLE pph, PRTPIPE phPipe)
918	{
919	AssertPtrReturn(ph, VERR_INVALID_POINTER);
920	AssertPtrReturn(pph, VERR_INVALID_POINTER);
921	AssertPtrReturn(phPipe, VERR_INVALID_POINTER);
922
923	int rc;
924
925	ph->enmType = RTHANDLETYPE_PIPE;
926	ph->u.hPipe = NIL_RTPIPE;
927	*pph = NULL;
928	*phPipe = NIL_RTPIPE;
929
930	if (!strcmp(pszHowTo, "\|"))
931	{
932	/*
933	* Setup a pipe for forwarding to/from the client.
934	* The ph union struct will be filled with a pipe read/write handle
935	* to represent the "other" end to phPipe.
936	*/
937	if (fd == 0) /* stdin? */
938	{
939	/* Connect a wrtie pipe specified by phPipe to stdin. */
940	rc = RTPipeCreate(&ph->u.hPipe, phPipe, RTPIPE_C_INHERIT_READ);
941	}
942	else /* stdout or stderr. */
943	{
944	/* Connect a read pipe specified by phPipe to stdout or stderr. */
945	rc = RTPipeCreate(phPipe, &ph->u.hPipe, RTPIPE_C_INHERIT_WRITE);
946	}
947
948	if (RT_FAILURE(rc))
949	return rc;
950
951	ph->enmType = RTHANDLETYPE_PIPE;
952	*pph = ph;
953	}
954	else if (!strcmp(pszHowTo, "/dev/null"))
955	{
956	/*
957	* Redirect to/from /dev/null.
958	*/
959	RTFILE hFile;
960	rc = RTFileOpenBitBucket(&hFile, fd == 0 ? RTFILE_O_READ : RTFILE_O_WRITE);
961	if (RT_FAILURE(rc))
962	return rc;
963
964	ph->enmType = RTHANDLETYPE_FILE;
965	ph->u.hFile = hFile;
966	*pph = ph;
967	}
968	else /* Add other piping stuff here. */
969	rc = VINF_SUCCESS; /* Same as parent (us). */
970
971	return rc;
972	}
973
974
975	/**
976	* Expands a file name / path to its real content.
977	*
978	* ~~This only works on Windows for now (e.g. translating "%TEMP%\foo.exe" to
979	* "C:\Windows\Temp" when starting with system / administrative rights).~~ See
980	* todo in code.
981	*
982	* @return IPRT status code.
983	* @param pszPath Path to resolve.
984	* @param pszExpanded Pointer to string to store the resolved path in.
985	* @param cbExpanded Size (in bytes) of string to store the resolved path.
986	*/
987	static int vgsvcGstCtrlProcessMakeFullPath(const char pszPath, char pszExpanded, size_t cbExpanded)
988	{
989	/** @todo r=bird: This feature shall be made optional, i.e. require a
990	* flag to be passed down. Further, it shall work on the environment
991	* block of the new process (i.e. include env changes passed down from
992	* the caller). I would also suggest using the unix variable expansion
993	* syntax, not the DOS one.
994	*
995	* Since this currently not available on non-windows guests, I suggest
996	* we disable it until such a time as it is implemented correctly. */
997	#if 0 /def RT_OS_WINDOWS - see above. Don't know why this wasn't disabled before 7.0, didn't see the @todo yet? /
998	int rc = VINF_SUCCESS;
999	if (!ExpandEnvironmentStrings(pszPath, pszExpanded, (DWORD)cbExpanded))
1000	rc = RTErrConvertFromWin32(GetLastError());
1001	#else
1002	/* There is no expansion anywhere yet, see above @todo. */
1003	int rc = RTStrCopy(pszExpanded, cbExpanded, pszPath);
1004	#endif
1005	#ifdef DEBUG
1006	VGSvcVerbose(3, "vgsvcGstCtrlProcessMakeFullPath: %s -> %s\n", pszPath, pszExpanded);
1007	#endif
1008	return rc;
1009	}
1010
1011
1012	/**
1013	* Resolves the full path of a specified executable name.
1014	*
1015	* This function also resolves internal VBoxService tools to its appropriate
1016	* executable path + name if VBOXSERVICE_NAME is specified as pszFilename.
1017	*
1018	* @return IPRT status code.
1019	* @param pszFilename File name to resolve.
1020	* @param pszResolved Pointer to a string where the resolved file name will be stored.
1021	* @param cbResolved Size (in bytes) of resolved file name string.
1022	*/
1023	static int vgsvcGstCtrlProcessResolveExecutable(const char pszFilename, char pszResolved, size_t cbResolved)
1024	{
1025	AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
1026	AssertPtrReturn(pszResolved, VERR_INVALID_POINTER);
1027	AssertReturn(cbResolved, VERR_INVALID_PARAMETER);
1028
1029	const char * const pszOrgFilename = pszFilename;
1030	if ( RTStrICmp(pszFilename, g_pszProgName) == 0
1031	\|\| RTStrICmp(pszFilename, VBOXSERVICE_NAME) == 0)
1032	pszFilename = RTProcExecutablePath();
1033
1034	int rc = vgsvcGstCtrlProcessMakeFullPath(pszFilename, pszResolved, cbResolved);
1035	if (RT_SUCCESS(rc))
1036	VGSvcVerbose(3, "Looked up executable: %s -> %s\n", pszOrgFilename, pszResolved);
1037	return rc;
1038	}
1039
1040
1041	/**
1042	* Constructs the argv command line by resolving environment variables
1043	* and relative paths.
1044	*
1045	* @return IPRT status code.
1046	* @param pszArgv0 First argument (argv0), either original or modified version.
1047	* @param papszArgs Original argv command line from the host, starting at argv[1].
1048	* @param fFlags The process creation flags pass to us from the host.
1049	* @param fExecutingSelf Set if we're executing the VBoxService executable
1050	* and should inject the --utf8-argv trick.
1051	* @param ppapszArgv Pointer to a pointer with the new argv command line.
1052	* Needs to be freed with RTGetOptArgvFree.
1053	*/
1054	static int vgsvcGstCtrlProcessAllocateArgv(const char pszArgv0, const char const *papszArgs, uint32_t fFlags,
1055	bool fExecutingSelf, char ***ppapszArgv)
1056	{
1057	VGSvcVerbose(3, "VGSvcGstCtrlProcessPrepareArgv: pszArgv0=%p, papszArgs=%p, fFlags=%#x, fExecutingSelf=%d, ppapszArgv=%p\n",
1058	pszArgv0, papszArgs, fFlags, fExecutingSelf, ppapszArgv);
1059
1060	AssertPtrReturn(pszArgv0, VERR_INVALID_POINTER);
1061	AssertPtrReturn(ppapszArgv, VERR_INVALID_POINTER);
1062	AssertReturn(!(fFlags & GUEST_PROC_CREATE_FLAG_EXPAND_ARGUMENTS), VERR_INVALID_FLAGS); /** @todo implement me */
1063
1064	#ifndef VBOXSERVICE_ARG1_UTF8_ARGV
1065	fExecutingSelf = false;
1066	#endif
1067
1068	/* Count arguments: */
1069	int rc = VINF_SUCCESS;
1070	uint32_t cArgs;
1071	for (cArgs = 0; papszArgs[cArgs]; cArgs++)
1072	{
1073	if (cArgs >= UINT32_MAX - 2)
1074	return VERR_BUFFER_OVERFLOW;
1075	}
1076
1077	/* Allocate new argv vector (adding + 2 for argv0 + termination). */
1078	size_t cbSize = (fExecutingSelf + cArgs + 2) * sizeof(char *);
1079	char papszNewArgv = (char )RTMemAlloc(cbSize);
1080	if (!papszNewArgv)
1081	return VERR_NO_MEMORY;
1082
1083	VGSvcVerbose(3, "VGSvcGstCtrlProcessAllocateArgv: pszArgv0 = '%s', cArgs=%RU32, cbSize=%zu\n", pszArgv0, cArgs, cbSize);
1084	#ifdef DEBUG /* Never log this stuff in release mode! */
1085	if (cArgs)
1086	{
1087	for (uint32_t i = 0; i < cArgs; i++)
1088	VGSvcVerbose(3, "VGSvcGstCtrlProcessAllocateArgv: papszArgs[%RU32] = '%s'\n", i, papszArgs[i]);
1089	}
1090	#endif
1091
1092	/* HACK ALERT! Older hosts (< VBox 6.1.x) did not allow the user to really specify
1093	the first argument separately from the executable image, so we have
1094	to fudge a little in the unquoted argument case to deal with executables
1095	containing spaces. Windows only, as RTPROC_FLAGS_UNQUOTED_ARGS is
1096	ignored on all other hosts. */
1097	#ifdef RT_OS_WINDOWS
1098	if ( (fFlags & GUEST_PROC_CREATE_FLAG_UNQUOTED_ARGS)
1099	&& strpbrk(pszArgv0, " \t\n\r")
1100	&& pszArgv0[0] == '"')
1101	{
1102	size_t cchArgv0 = strlen(pszArgv0);
1103	AssertReturn(cchArgv0, VERR_INVALID_PARAMETER); /* Paranoia. */
1104	rc = RTStrAllocEx(&papszNewArgv[0], 1 + cchArgv0 + 1 + 1);
1105	if (RT_SUCCESS(rc))
1106	{
1107	char *pszDst = papszNewArgv[0];
1108	*pszDst++ = '"';
1109	memcpy(pszDst, pszArgv0, cchArgv0);
1110	pszDst += cchArgv0;
1111	*pszDst++ = '"';
1112	*pszDst = '\0';
1113	}
1114	}
1115	else
1116	#endif
1117	rc = RTStrDupEx(&papszNewArgv[0], pszArgv0);
1118	if (RT_SUCCESS(rc))
1119	{
1120	size_t iDst = 1;
1121
1122	#ifdef VBOXSERVICE_ARG1_UTF8_ARGV
1123	/* Insert --utf8-argv as the first argument if executing the VBoxService binary. */
1124	if (fExecutingSelf)
1125	{
1126	rc = RTStrDupEx(&papszNewArgv[iDst], VBOXSERVICE_ARG1_UTF8_ARGV);
1127	if (RT_SUCCESS(rc))
1128	iDst++;
1129	}
1130	#endif
1131	/* Copy over the other arguments. */
1132	if (RT_SUCCESS(rc))
1133	for (size_t iSrc = 0; iSrc < cArgs; iSrc++)
1134	{
1135	#if 0 /* Arguments expansion -- untested. */
1136	if (fFlags & GUEST_PROC_CREATE_FLAG_EXPAND_ARGUMENTS)
1137	{
1138	/** @todo r=bird: If you want this, we need a generic implementation, preferably in RTEnv or somewhere like that. The marking
1139	* up of the variables must be the same on all platforms. */
1140	/* According to MSDN the limit on older Windows version is 32K, whereas
1141	* Vista+ there are no limits anymore. We still stick to 4K. */
1142	char szExpanded[_4K];
1143	# ifdef RT_OS_WINDOWS
1144	if (!ExpandEnvironmentStrings(papszArgs[i], szExpanded, sizeof(szExpanded)))
1145	rc = RTErrConvertFromWin32(GetLastError());
1146	# else
1147	/* No expansion for non-Windows yet. */
1148	rc = RTStrCopy(papszArgs[i], sizeof(szExpanded), szExpanded);
1149	# endif
1150	if (RT_SUCCESS(rc))
1151	rc = RTStrDupEx(&pszArg, szExpanded);
1152	}
1153	else
1154	#endif
1155	rc = RTStrDupEx(&papszNewArgv[iDst], papszArgs[iSrc]);
1156	if (RT_SUCCESS(rc))
1157	iDst++;
1158	else
1159	break;
1160	}
1161
1162	if (RT_SUCCESS(rc))
1163	{
1164	/* Terminate array. */
1165	papszNewArgv[iDst] = NULL;
1166
1167	*ppapszArgv = papszNewArgv;
1168	return VINF_SUCCESS;
1169	}
1170
1171	/* Failed, bail out. */
1172	while (iDst-- > 0)
1173	RTStrFree(papszNewArgv[iDst]);
1174	}
1175	RTMemFree(papszNewArgv);
1176	return rc;
1177	}
1178
1179
1180	/**
1181	* Assigns a valid PID to a guest control thread and also checks if there already was
1182	* another (stale) guest process which was using that PID before and destroys it.
1183	*
1184	* @return IPRT status code.
1185	* @param pProcess Process to assign PID to.
1186	* @param uPID PID to assign to the specified guest control execution thread.
1187	*/
1188	static int vgsvcGstCtrlProcessAssignPID(PVBOXSERVICECTRLPROCESS pProcess, uint32_t uPID)
1189	{
1190	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
1191	AssertReturn(uPID, VERR_INVALID_PARAMETER);
1192
1193	AssertPtr(pProcess->pSession);
1194	int rc = RTCritSectEnter(&pProcess->pSession->CritSect);
1195	if (RT_SUCCESS(rc))
1196	{
1197	/* Search old threads using the desired PID and shut them down completely -- it's
1198	* not used anymore. */
1199	bool fTryAgain;
1200	do
1201	{
1202	fTryAgain = false;
1203	PVBOXSERVICECTRLPROCESS pProcessCur;
1204	RTListForEach(&pProcess->pSession->lstProcesses, pProcessCur, VBOXSERVICECTRLPROCESS, Node)
1205	{
1206	if (pProcessCur->uPID == uPID)
1207	{
1208	Assert(pProcessCur != pProcess); /* can't happen */
1209	uint32_t uTriedPID = uPID;
1210	uPID += 391939;
1211	VGSvcVerbose(2, "PID %RU32 was used before (process %p), trying again with %RU32 ...\n",
1212	uTriedPID, pProcessCur, uPID);
1213	fTryAgain = true;
1214	break;
1215	}
1216	}
1217	} while (fTryAgain);
1218
1219	/* Assign PID to current thread. */
1220	pProcess->uPID = uPID;
1221
1222	rc = RTCritSectLeave(&pProcess->pSession->CritSect);
1223	AssertRC(rc);
1224	}
1225
1226	return rc;
1227	}
1228
1229
1230	static void vgsvcGstCtrlProcessFreeArgv(char **papszArgv)
1231	{
1232	if (papszArgv)
1233	{
1234	size_t i = 0;
1235	while (papszArgv[i])
1236	RTStrFree(papszArgv[i++]);
1237	RTMemFree(papszArgv);
1238	}
1239	}
1240
1241
1242	/**
1243	* Helper function to create/start a process on the guest.
1244	*
1245	* @return IPRT status code.
1246	* @param pszExec Full qualified path of process to start (without arguments).
1247	* @param papszArgs Pointer to array of command line arguments.
1248	* @param hEnv Handle to environment block to use.
1249	* @param fFlags Process execution flags.
1250	* @param phStdIn Handle for the process' stdin pipe.
1251	* @param phStdOut Handle for the process' stdout pipe.
1252	* @param phStdErr Handle for the process' stderr pipe.
1253	* @param pszAsUser User name (account) to start the process under.
1254	* @param pszPassword Password of the specified user.
1255	* @param pszDomain Domain to use for authentication.
1256	* @param phProcess Pointer which will receive the process handle after
1257	* successful process start.
1258	*/
1259	static int vgsvcGstCtrlProcessCreateProcess(const char pszExec, const char const *papszArgs, RTENV hEnv, uint32_t fFlags,
1260	PCRTHANDLE phStdIn, PCRTHANDLE phStdOut, PCRTHANDLE phStdErr,
1261	const char pszAsUser, const char pszPassword, const char *pszDomain,
1262	PRTPROCESS phProcess)
1263	{
1264	#ifndef RT_OS_WINDOWS
1265	RT_NOREF1(pszDomain);
1266	#endif
1267	AssertPtrReturn(pszExec, VERR_INVALID_PARAMETER);
1268	AssertPtrReturn(papszArgs, VERR_INVALID_PARAMETER);
1269	/* phStdIn is optional. */
1270	/* phStdOut is optional. */
1271	/* phStdErr is optional. */
1272	/* pszPassword is optional. */
1273	/* pszDomain is optional. */
1274	AssertPtrReturn(phProcess, VERR_INVALID_PARAMETER);
1275
1276	int rc = VINF_SUCCESS;
1277	char szExecExp[RTPATH_MAX];
1278
1279	#ifdef DEBUG
1280	/* Never log this in release mode! */
1281	VGSvcVerbose(4, "pszUser=%s, pszPassword=%s, pszDomain=%s\n", pszAsUser, pszPassword, pszDomain);
1282	#endif
1283
1284	#ifdef RT_OS_WINDOWS
1285	/*
1286	* If sysprep should be executed do this in the context of VBoxService, which
1287	* (usually, if started by SCM) has administrator rights. Because of that a UI
1288	* won't be shown (doesn't have a desktop).
1289	*/
1290	if (!RTStrICmp(pszExec, "sysprep"))
1291	{
1292	/* Use a predefined sysprep path as default. */
1293	char szSysprepCmd[RTPATH_MAX] = "C:\\sysprep\\sysprep.exe";
1294	/** @todo Check digital signature of file above before executing it? */
1295
1296	/*
1297	* On Windows Vista (and up) sysprep is located in "system32\\Sysprep\\sysprep.exe",
1298	* so detect the OS and use a different path.
1299	*/
1300	if (RTSystemGetNtVersion() >= RTSYSTEM_MAKE_NT_VERSION(6,0,0) /* Vista and later */)
1301	{
1302	rc = RTEnvGetEx(RTENV_DEFAULT, "windir", szSysprepCmd, sizeof(szSysprepCmd), NULL);
1303	#ifndef RT_ARCH_AMD64
1304	/* Don't execute 64-bit sysprep from a 32-bit service host! */
1305	char szSysWow64[RTPATH_MAX];
1306	if (RTStrPrintf(szSysWow64, sizeof(szSysWow64), "%s", szSysprepCmd))
1307	{
1308	rc = RTPathAppend(szSysWow64, sizeof(szSysWow64), "SysWow64");
1309	AssertRC(rc);
1310	}
1311	if ( RT_SUCCESS(rc)
1312	&& RTPathExists(szSysWow64))
1313	VGSvcVerbose(0, "Warning: This service is 32-bit; could not execute sysprep on 64-bit OS!\n");
1314	#endif
1315	if (RT_SUCCESS(rc))
1316	rc = RTPathAppend(szSysprepCmd, sizeof(szSysprepCmd), "system32\\Sysprep\\sysprep.exe");
1317	if (RT_SUCCESS(rc))
1318	RTPathChangeToDosSlashes(szSysprepCmd, false /* No forcing necessary */);
1319
1320	if (RT_FAILURE(rc))
1321	VGSvcError("Failed to detect sysrep location, rc=%Rrc\n", rc);
1322	}
1323
1324	VGSvcVerbose(3, "Sysprep executable is: %s\n", szSysprepCmd);
1325
1326	if (RT_SUCCESS(rc))
1327	{
1328	char **papszArgsExp;
1329	rc = vgsvcGstCtrlProcessAllocateArgv(szSysprepCmd /* argv0 */, papszArgs, fFlags,
1330	false /fExecutingSelf/, &papszArgsExp);
1331	if (RT_SUCCESS(rc))
1332	{
1333	/* As we don't specify credentials for the sysprep process, it will
1334	* run under behalf of the account VBoxService was started under, most
1335	* likely local system. */
1336	rc = RTProcCreateEx(szSysprepCmd, papszArgsExp, hEnv, 0 /* fFlags */,
1337	phStdIn, phStdOut, phStdErr, NULL /* pszAsUser */,
1338	NULL /* pszPassword */, NULL, phProcess);
1339	vgsvcGstCtrlProcessFreeArgv(papszArgsExp);
1340	}
1341	}
1342
1343	if (RT_FAILURE(rc))
1344	VGSvcVerbose(3, "Starting sysprep returned rc=%Rrc\n", rc);
1345
1346	return rc;
1347	}
1348	#endif /* RT_OS_WINDOWS */
1349
1350	bool fExecutingSelf = false;
1351	#ifdef VBOX_WITH_VBOXSERVICE_TOOLBOX
1352	/* The "vbox_" prefix is reserved for the toolbox (vbox_cat, vbox_mkdir,
1353	et al.) and we will replace pszExec with the full VBoxService path instead. */
1354	if (RTStrStartsWith(pszExec, "vbox_"))
1355	{
1356	fExecutingSelf = true;
1357	rc = vgsvcGstCtrlProcessResolveExecutable(VBOXSERVICE_NAME, szExecExp, sizeof(szExecExp));
1358	}
1359	else
1360	{
1361	#endif
1362	/*
1363	* Do the environment variables expansion on executable and arguments.
1364	*/
1365	rc = vgsvcGstCtrlProcessResolveExecutable(pszExec, szExecExp, sizeof(szExecExp));
1366	#ifdef VBOX_WITH_VBOXSERVICE_TOOLBOX
1367	}
1368	#endif
1369	if (RT_SUCCESS(rc))
1370	{
1371	/*
1372	* This one is a bit tricky to also support older hosts:
1373	*
1374	* - If the host does not provide a dedicated argv[0] (< VBox 6.1.x), we use the
1375	* unmodified executable name (pszExec) as the (default) argv[0]. This is wrong, but we can't do
1376	* much about it. The rest (argv[1,2,n]) then gets set starting at papszArgs[0].
1377	*
1378	* - Newer hosts (>= VBox 6.1.x) provide a correct argv[0] independently of the actual
1379	* executable name though, so actually use argv[0] and argv[1,2,n] as intended.
1380	*/
1381	const bool fHasArgv0 = RT_BOOL(g_fControlHostFeatures0 & VBOX_GUESTCTRL_HF_0_PROCESS_ARGV0);
1382
1383	const char *pcszArgv0 = (fHasArgv0 && papszArgs[0]) ? papszArgs[0] : pszExec;
1384	AssertPtrReturn(pcszArgv0, VERR_INVALID_POINTER); /* Paranoia. */
1385
1386	const uint32_t uArgvIdx = pcszArgv0 == papszArgs[0] ? 1 : 0;
1387
1388	VGSvcVerbose(3, "vgsvcGstCtrlProcessCreateProcess: fHasArgv0=%RTbool, pcszArgv0=%p, uArgvIdx=%RU32, "
1389	"g_fControlHostFeatures0=%#x\n",
1390	fHasArgv0, pcszArgv0, uArgvIdx, g_fControlHostFeatures0);
1391
1392	char **papszArgsExp;
1393	rc = vgsvcGstCtrlProcessAllocateArgv(pcszArgv0, &papszArgs[uArgvIdx], fFlags, fExecutingSelf, &papszArgsExp);
1394	if (RT_FAILURE(rc))
1395	{
1396	/* Don't print any arguments -- may contain passwords or other sensible data! */
1397	VGSvcError("Could not prepare arguments, rc=%Rrc\n", rc);
1398	}
1399	else
1400	{
1401	uint32_t fProcCreateFlags = 0;
1402	if (fExecutingSelf)
1403	fProcCreateFlags \|= VBOXSERVICE_PROC_F_UTF8_ARGV;
1404	if (fFlags)
1405	{
1406	if (fFlags & GUEST_PROC_CREATE_FLAG_HIDDEN)
1407	fProcCreateFlags \|= RTPROC_FLAGS_HIDDEN;
1408	if (fFlags & GUEST_PROC_CREATE_FLAG_PROFILE)
1409	fProcCreateFlags \|= RTPROC_FLAGS_PROFILE;
1410	if (fFlags & GUEST_PROC_CREATE_FLAG_UNQUOTED_ARGS)
1411	fProcCreateFlags \|= RTPROC_FLAGS_UNQUOTED_ARGS;
1412	}
1413
1414	/* If no user name specified run with current credentials (e.g.
1415	* full service/system rights). This is prohibited via official Main API!
1416	*
1417	* Otherwise use the RTPROC_FLAGS_SERVICE to use some special authentication
1418	* code (at least on Windows) for running processes as different users
1419	* started from our system service. */
1420	if (pszAsUser && *pszAsUser)
1421	fProcCreateFlags \|= RTPROC_FLAGS_SERVICE;
1422	#ifdef DEBUG
1423	VGSvcVerbose(3, "Command: %s\n", szExecExp);
1424	for (size_t i = 0; papszArgsExp[i]; i++)
1425	VGSvcVerbose(3, " argv[%zu]: %s\n", i, papszArgsExp[i]);
1426	#endif
1427	VGSvcVerbose(3, "Starting process '%s' ...\n", szExecExp);
1428
1429	#ifdef RT_OS_WINDOWS
1430	/* If a domain name is given, construct an UPN (User Principle Name) with
1431	* the domain name built-in, e.g. "[email protected]". */
1432	char *pszUserUPN = NULL;
1433	if (pszDomain && *pszDomain != '\0')
1434	{
1435	pszAsUser = pszUserUPN = RTStrAPrintf2("%s@%s", pszAsUser, pszDomain);
1436	if (pszAsUser)
1437	VGSvcVerbose(3, "Using UPN: %s\n", pszAsUser);
1438	else
1439	rc = VERR_NO_STR_MEMORY;
1440	}
1441	if (RT_SUCCESS(rc))
1442	#endif
1443	{
1444	/* Do normal execution. */
1445	rc = RTProcCreateEx(szExecExp, papszArgsExp, hEnv, fProcCreateFlags,
1446	phStdIn, phStdOut, phStdErr,
1447	pszAsUser,
1448	pszPassword && *pszPassword ? pszPassword : NULL,
1449	NULL /pvExtraData/,
1450	phProcess);
1451
1452	#ifdef RT_OS_WINDOWS
1453	RTStrFree(pszUserUPN);
1454	#endif
1455	VGSvcVerbose(3, "Starting process '%s' returned rc=%Rrc\n", szExecExp, rc);
1456	}
1457	vgsvcGstCtrlProcessFreeArgv(papszArgsExp);
1458	}
1459	}
1460	return rc;
1461	}
1462
1463
1464	#ifdef DEBUG
1465	/**
1466	* Dumps content to a file in the OS temporary directory.
1467	*
1468	* @returns VBox status code.
1469	* @param pvBuf Buffer of content to dump.
1470	* @param cbBuf Size (in bytes) of content to dump.
1471	* @param pszFileNmFmt Pointer to the file name format string, @see pg_rt_str_format.
1472	* @param ... The format argument.
1473	*/
1474	static int vgsvcGstCtrlProcessDbgDumpToFileF(const void pvBuf, size_t cbBuf, const char pszFileNmFmt, ...)
1475	{
1476	AssertPtrReturn(pszFileNmFmt, VERR_INVALID_POINTER);
1477	AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
1478
1479	if (!cbBuf)
1480	return VINF_SUCCESS;
1481
1482	va_list va;
1483	va_start(va, pszFileNmFmt);
1484
1485	char *pszFileName = NULL;
1486	const int cchFileName = RTStrAPrintfV(&pszFileName, pszFileNmFmt, va);
1487
1488	va_end(va);
1489
1490	if (!cchFileName)
1491	return VERR_NO_MEMORY;
1492
1493	char szPathFileAbs[RTPATH_MAX];
1494	int rc = RTPathTemp(szPathFileAbs, sizeof(szPathFileAbs));
1495	if (RT_SUCCESS(rc))
1496	rc = RTPathAppend(szPathFileAbs, sizeof(szPathFileAbs), pszFileName);
1497
1498	RTStrFree(pszFileName);
1499
1500	if (RT_SUCCESS(rc))
1501	{
1502	VGSvcVerbose(4, "Dumping %zu bytes to '%s'\n", cbBuf, szPathFileAbs);
1503
1504	RTFILE fh;
1505	rc = RTFileOpen(&fh, szPathFileAbs, RTFILE_O_OPEN_CREATE \| RTFILE_O_WRITE \| RTFILE_O_DENY_WRITE);
1506	if (RT_SUCCESS(rc))
1507	{
1508	rc = RTFileWrite(fh, pvBuf, cbBuf, NULL /* pcbWritten */);
1509	RTFileClose(fh);
1510	}
1511	}
1512
1513	return rc;
1514	}
1515	#endif /* DEBUG */
1516
1517
1518	/**
1519	* The actual worker routine (loop) for a started guest process.
1520	*
1521	* @return IPRT status code.
1522	* @param pProcess The process we're servicing and monitoring.
1523	*/
1524	static int vgsvcGstCtrlProcessProcessWorker(PVBOXSERVICECTRLPROCESS pProcess)
1525	{
1526	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
1527	VGSvcVerbose(3, "Thread of process pThread=0x%p = '%s' started\n", pProcess, pProcess->pStartupInfo->pszCmd);
1528
1529	VGSvcVerbose(3, "Guest process '%s', flags=0x%x\n", pProcess->pStartupInfo->pszCmd, pProcess->pStartupInfo->fFlags);
1530
1531	int rc = VGSvcGstCtrlSessionProcessAdd(pProcess->pSession, pProcess);
1532	if (RT_FAILURE(rc))
1533	{
1534	VGSvcError("Error while adding guest process '%s' (%p) to session process list, rc=%Rrc\n",
1535	pProcess->pStartupInfo->pszCmd, pProcess, rc);
1536	RTThreadUserSignal(RTThreadSelf());
1537	return rc;
1538	}
1539
1540	bool fSignalled = false; /* Indicator whether we signalled the thread user event already. */
1541
1542	/*
1543	* Prepare argument list.
1544	*/
1545	VGSvcVerbose(3, "vgsvcGstCtrlProcessProcessWorker: fHostFeatures0 = %#x\n", g_fControlHostFeatures0);
1546	VGSvcVerbose(3, "vgsvcGstCtrlProcessProcessWorker: StartupInfo.szCmd = '%s'\n", pProcess->pStartupInfo->pszCmd);
1547	VGSvcVerbose(3, "vgsvcGstCtrlProcessProcessWorker: StartupInfo.uNumArgs = '%RU32'\n", pProcess->pStartupInfo->cArgs);
1548	#ifdef DEBUG /* Never log this stuff in release mode! */
1549	VGSvcVerbose(3, "vgsvcGstCtrlProcessProcessWorker: StartupInfo.szArgs = '%s'\n", pProcess->pStartupInfo->pszArgs);
1550	#endif
1551
1552	char **papszArgs;
1553	int cArgs = 0; /* Initialize in case of RTGetOptArgvFromString() is failing ... */
1554	rc = RTGetOptArgvFromString(&papszArgs, &cArgs,
1555	pProcess->pStartupInfo->cArgs > 0 ? pProcess->pStartupInfo->pszArgs : "",
1556	RTGETOPTARGV_CNV_QUOTE_BOURNE_SH, NULL);
1557
1558	VGSvcVerbose(3, "vgsvcGstCtrlProcessProcessWorker: cArgs = %d\n", cArgs);
1559	#ifdef VBOX_STRICT
1560	for (int i = 0; i < cArgs; i++)
1561	VGSvcVerbose(3, "vgsvcGstCtrlProcessProcessWorker: papszArgs[%d] = '%s'\n", i, papszArgs[i] ? papszArgs[i] : "<NULL>");
1562
1563	const bool fHasArgv0 = RT_BOOL(g_fControlHostFeatures0 & VBOX_GUESTCTRL_HF_0_PROCESS_ARGV0); RT_NOREF(fHasArgv0);
1564	const int cArgsToCheck = cArgs + (fHasArgv0 ? 0 : 1);
1565
1566	/* Did we get the same result?
1567	* Take into account that we might not have supplied a (correct) argv[0] from the host. */
1568	AssertMsg((int)pProcess->pStartupInfo->cArgs == cArgsToCheck,
1569	("rc=%Rrc, StartupInfo.uNumArgs=%RU32 != cArgsToCheck=%d, cArgs=%d, fHostFeatures0=%#x\n",
1570	rc, pProcess->pStartupInfo->cArgs, cArgsToCheck, cArgs, g_fControlHostFeatures0));
1571	#endif
1572
1573	/*
1574	* Create the environment.
1575	*/
1576	uint32_t const cbEnv = pProcess->pStartupInfo->cbEnv;
1577	if (RT_SUCCESS(rc))
1578	AssertStmt( cbEnv <= GUEST_PROC_MAX_ENV_LEN
1579	\|\| pProcess->pStartupInfo->cEnvVars == 0,
1580	rc = VERR_INVALID_PARAMETER);
1581	if (RT_SUCCESS(rc))
1582	{
1583	RTENV hEnv;
1584	rc = RTEnvClone(&hEnv, RTENV_DEFAULT);
1585	if (RT_SUCCESS(rc))
1586	{
1587	VGSvcVerbose(3, "Additional environment variables: %RU32 (%RU32 bytes)\n",
1588	pProcess->pStartupInfo->cEnvVars, cbEnv);
1589
1590	if ( pProcess->pStartupInfo->cEnvVars
1591	&& cbEnv > 0)
1592	{
1593	size_t offCur = 0;
1594	while (offCur < cbEnv)
1595	{
1596	const char * const pszCur = &pProcess->pStartupInfo->pszEnv[offCur];
1597	size_t const cchCur = RTStrNLen(pszCur, cbEnv - offCur);
1598	AssertBreakStmt(cchCur < cbEnv - offCur, rc = VERR_INVALID_PARAMETER);
1599	VGSvcVerbose(3, "Setting environment variable: '%s'\n", pszCur);
1600	rc = RTEnvPutEx(hEnv, pszCur);
1601	if (RT_SUCCESS(rc))
1602	offCur += cchCur + 1;
1603	else
1604	{
1605	VGSvcError("Setting environment variable '%s' failed: %Rrc\n", pszCur, rc);
1606	break;
1607	}
1608	}
1609	}
1610
1611	if (RT_SUCCESS(rc))
1612	{
1613	/*
1614	* Setup the redirection of the standard stuff.
1615	*/
1616	/** @todo consider supporting: gcc stuff.c >file 2>&1. */
1617	RTHANDLE hStdIn;
1618	PRTHANDLE phStdIn;
1619	rc = vgsvcGstCtrlProcessSetupPipe("\|", 0 /STDIN_FILENO/,
1620	&hStdIn, &phStdIn, &pProcess->hPipeStdInW);
1621	if (RT_SUCCESS(rc))
1622	{
1623	RTHANDLE hStdOut;
1624	PRTHANDLE phStdOut;
1625	rc = vgsvcGstCtrlProcessSetupPipe( (pProcess->pStartupInfo->fFlags & GUEST_PROC_CREATE_FLAG_WAIT_STDOUT)
1626	? "\|" : "/dev/null",
1627	1 /STDOUT_FILENO/,
1628	&hStdOut, &phStdOut, &pProcess->hPipeStdOutR);
1629	if (RT_SUCCESS(rc))
1630	{
1631	RTHANDLE hStdErr;
1632	PRTHANDLE phStdErr;
1633	rc = vgsvcGstCtrlProcessSetupPipe( (pProcess->pStartupInfo->fFlags & GUEST_PROC_CREATE_FLAG_WAIT_STDERR)
1634	? "\|" : "/dev/null",
1635	2 /STDERR_FILENO/,
1636	&hStdErr, &phStdErr, &pProcess->hPipeStdErrR);
1637	if (RT_SUCCESS(rc))
1638	{
1639	/*
1640	* Create a poll set for the pipes and let the
1641	* transport layer add stuff to it as well.
1642	*/
1643	rc = RTPollSetCreate(&pProcess->hPollSet);
1644	if (RT_SUCCESS(rc))
1645	{
1646	uint32_t uFlags = RTPOLL_EVT_ERROR;
1647	#if 0
1648	/* Add reading event to pollset to get some more information. */
1649	uFlags \|= RTPOLL_EVT_READ;
1650	#endif
1651	/* Stdin. */
1652	if (RT_SUCCESS(rc))
1653	rc = RTPollSetAddPipe(pProcess->hPollSet,
1654	pProcess->hPipeStdInW, RTPOLL_EVT_ERROR, VBOXSERVICECTRLPIPEID_STDIN);
1655	/* Stdout. */
1656	if (RT_SUCCESS(rc))
1657	rc = RTPollSetAddPipe(pProcess->hPollSet,
1658	pProcess->hPipeStdOutR, uFlags, VBOXSERVICECTRLPIPEID_STDOUT);
1659	/* Stderr. */
1660	if (RT_SUCCESS(rc))
1661	rc = RTPollSetAddPipe(pProcess->hPollSet,
1662	pProcess->hPipeStdErrR, uFlags, VBOXSERVICECTRLPIPEID_STDERR);
1663	/* IPC notification pipe. */
1664	if (RT_SUCCESS(rc))
1665	rc = RTPipeCreate(&pProcess->hNotificationPipeR, &pProcess->hNotificationPipeW, 0 /* Flags */);
1666	if (RT_SUCCESS(rc))
1667	rc = RTPollSetAddPipe(pProcess->hPollSet,
1668	pProcess->hNotificationPipeR, RTPOLL_EVT_READ, VBOXSERVICECTRLPIPEID_IPC_NOTIFY);
1669	if (RT_SUCCESS(rc))
1670	{
1671	AssertPtr(pProcess->pSession);
1672	bool fNeedsImpersonation = !(pProcess->pSession->fFlags & VBOXSERVICECTRLSESSION_FLAG_SPAWN);
1673
1674	rc = vgsvcGstCtrlProcessCreateProcess(pProcess->pStartupInfo->pszCmd, papszArgs, hEnv,
1675	pProcess->pStartupInfo->fFlags,
1676	phStdIn, phStdOut, phStdErr,
1677	fNeedsImpersonation ? pProcess->pStartupInfo->pszUser : NULL,
1678	fNeedsImpersonation ? pProcess->pStartupInfo->pszPassword : NULL,
1679	fNeedsImpersonation ? pProcess->pStartupInfo->pszDomain : NULL,
1680	&pProcess->hProcess);
1681	if (RT_FAILURE(rc))
1682	VGSvcError("Error starting process, rc=%Rrc\n", rc);
1683	/*
1684	* Tell the session thread that it can continue
1685	* spawning guest processes. This needs to be done after the new
1686	* process has been started because otherwise signal handling
1687	* on (Open) Solaris does not work correctly (see @bugref{5068}).
1688	*/
1689	int rc2 = RTThreadUserSignal(RTThreadSelf());
1690	if (RT_SUCCESS(rc))
1691	rc = rc2;
1692	fSignalled = true;
1693
1694	if (RT_SUCCESS(rc))
1695	{
1696	/*
1697	* Close the child ends of any pipes and redirected files.
1698	*/
1699	rc2 = RTHandleClose(phStdIn); AssertRC(rc2);
1700	phStdIn = NULL;
1701	rc2 = RTHandleClose(phStdOut); AssertRC(rc2);
1702	phStdOut = NULL;
1703	rc2 = RTHandleClose(phStdErr); AssertRC(rc2);
1704	phStdErr = NULL;
1705
1706	/* Enter the process main loop. */
1707	rc = vgsvcGstCtrlProcessProcLoop(pProcess);
1708
1709	/*
1710	* The handles that are no longer in the set have
1711	* been closed by the above call in order to prevent
1712	* the guest from getting stuck accessing them.
1713	* So, NIL the handles to avoid closing them again.
1714	*/
1715	if (RT_FAILURE(RTPollSetQueryHandle(pProcess->hPollSet,
1716	VBOXSERVICECTRLPIPEID_IPC_NOTIFY, NULL)))
1717	pProcess->hNotificationPipeW = NIL_RTPIPE;
1718	if (RT_FAILURE(RTPollSetQueryHandle(pProcess->hPollSet,
1719	VBOXSERVICECTRLPIPEID_STDERR, NULL)))
1720	pProcess->hPipeStdErrR = NIL_RTPIPE;
1721	if (RT_FAILURE(RTPollSetQueryHandle(pProcess->hPollSet,
1722	VBOXSERVICECTRLPIPEID_STDOUT, NULL)))
1723	pProcess->hPipeStdOutR = NIL_RTPIPE;
1724	if (RT_FAILURE(RTPollSetQueryHandle(pProcess->hPollSet,
1725	VBOXSERVICECTRLPIPEID_STDIN, NULL)))
1726	pProcess->hPipeStdInW = NIL_RTPIPE;
1727	}
1728	}
1729	RTPollSetDestroy(pProcess->hPollSet);
1730	pProcess->hPollSet = NIL_RTPOLLSET;
1731
1732	RTPipeClose(pProcess->hNotificationPipeR);
1733	pProcess->hNotificationPipeR = NIL_RTPIPE;
1734	RTPipeClose(pProcess->hNotificationPipeW);
1735	pProcess->hNotificationPipeW = NIL_RTPIPE;
1736	}
1737	RTPipeClose(pProcess->hPipeStdErrR);
1738	pProcess->hPipeStdErrR = NIL_RTPIPE;
1739	RTHandleClose(&hStdErr);
1740	if (phStdErr)
1741	RTHandleClose(phStdErr);
1742	}
1743	RTPipeClose(pProcess->hPipeStdOutR);
1744	pProcess->hPipeStdOutR = NIL_RTPIPE;
1745	RTHandleClose(&hStdOut);
1746	if (phStdOut)
1747	RTHandleClose(phStdOut);
1748	}
1749	RTPipeClose(pProcess->hPipeStdInW);
1750	pProcess->hPipeStdInW = NIL_RTPIPE;
1751	RTHandleClose(&hStdIn);
1752	if (phStdIn)
1753	RTHandleClose(phStdIn);
1754	}
1755	}
1756	RTEnvDestroy(hEnv);
1757	}
1758	}
1759
1760	if (RT_FAILURE(rc))
1761	{
1762	VBGLR3GUESTCTRLCMDCTX ctx = { g_idControlSvcClient, pProcess->uContextID, 0 /* uProtocol /, 0 / uNumParms */ };
1763	int rc2 = VbglR3GuestCtrlProcCbStatus(&ctx,
1764	pProcess->uPID, PROC_STS_ERROR, rc,
1765	NULL /* pvData /, 0 / cbData */);
1766	if ( RT_FAILURE(rc2)
1767	&& rc2 != VERR_NOT_FOUND)
1768	VGSvcError("[PID %RU32]: Could not report process failure error; rc=%Rrc (process error %Rrc)\n",
1769	pProcess->uPID, rc2, rc);
1770	}
1771
1772	/* Update stopped status. */
1773	ASMAtomicWriteBool(&pProcess->fStopped, true);
1774
1775	if (cArgs)
1776	RTGetOptArgvFree(papszArgs);
1777
1778	/*
1779	* If something went wrong signal the user event so that others don't wait
1780	* forever on this thread.
1781	*/
1782	if ( RT_FAILURE(rc)
1783	&& !fSignalled)
1784	{
1785	RTThreadUserSignal(RTThreadSelf());
1786	}
1787
1788	/* Set shut down flag in case we've forgotten it. */
1789	ASMAtomicWriteBool(&pProcess->fShutdown, true);
1790
1791	VGSvcVerbose(3, "[PID %RU32]: Thread of process '%s' ended with rc=%Rrc (fSignalled=%RTbool)\n",
1792	pProcess->uPID, pProcess->pStartupInfo->pszCmd, rc, fSignalled);
1793
1794	return rc;
1795	}
1796
1797
1798	static int vgsvcGstCtrlProcessLock(PVBOXSERVICECTRLPROCESS pProcess)
1799	{
1800	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
1801	int rc = RTCritSectEnter(&pProcess->CritSect);
1802	AssertRC(rc);
1803	return rc;
1804	}
1805
1806
1807	/**
1808	* Thread main routine for a started process.
1809	*
1810	* @return IPRT status code.
1811	* @param hThreadSelf The thread handle.
1812	* @param pvUser Pointer to a VBOXSERVICECTRLPROCESS structure.
1813	*
1814	*/
1815	static DECLCALLBACK(int) vgsvcGstCtrlProcessThread(RTTHREAD hThreadSelf, void *pvUser)
1816	{
1817	RT_NOREF1(hThreadSelf);
1818	PVBOXSERVICECTRLPROCESS pProcess = (PVBOXSERVICECTRLPROCESS)pvUser;
1819	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
1820	return vgsvcGstCtrlProcessProcessWorker(pProcess);
1821	}
1822
1823
1824	static int vgsvcGstCtrlProcessUnlock(PVBOXSERVICECTRLPROCESS pProcess)
1825	{
1826	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
1827	int rc = RTCritSectLeave(&pProcess->CritSect);
1828	AssertRC(rc);
1829	return rc;
1830	}
1831
1832
1833	/**
1834	* Executes (starts) a process on the guest. This causes a new thread to be created
1835	* so that this function will not block the overall program execution.
1836	*
1837	* @return IPRT status code.
1838	* @param pSession Guest session.
1839	* @param pStartupInfo Startup info.
1840	* @param uContextID Context ID to associate the process to start with.
1841	*/
1842	int VGSvcGstCtrlProcessStart(const PVBOXSERVICECTRLSESSION pSession,
1843	const PVBGLR3GUESTCTRLPROCSTARTUPINFO pStartupInfo, uint32_t uContextID)
1844	{
1845	AssertPtrReturn(pSession, VERR_INVALID_POINTER);
1846	AssertPtrReturn(pStartupInfo, VERR_INVALID_POINTER);
1847
1848	/*
1849	* Allocate new thread data and assign it to our thread list.
1850	*/
1851	PVBOXSERVICECTRLPROCESS pProcess = (PVBOXSERVICECTRLPROCESS)RTMemAlloc(sizeof(VBOXSERVICECTRLPROCESS));
1852	if (!pProcess)
1853	return VERR_NO_MEMORY;
1854
1855	int rc = vgsvcGstCtrlProcessInit(pProcess, pSession, pStartupInfo, uContextID);
1856	if (RT_SUCCESS(rc))
1857	{
1858	static uint32_t s_uCtrlExecThread = 0;
1859	rc = RTThreadCreateF(&pProcess->Thread, vgsvcGstCtrlProcessThread,
1860	pProcess /pvUser/, 0 /cbStack/,
1861	RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "gctl%RU32", s_uCtrlExecThread++);
1862	if (RT_FAILURE(rc))
1863	{
1864	VGSvcError("Creating thread for guest process '%s' failed: rc=%Rrc, pProcess=%p\n",
1865	pStartupInfo->pszCmd, rc, pProcess);
1866
1867	/* Process has not been added to the session's process list yet, so skip VGSvcGstCtrlSessionProcessRemove() here. */
1868	VGSvcGstCtrlProcessFree(pProcess);
1869	}
1870	else
1871	{
1872	VGSvcVerbose(4, "Waiting for thread to initialize ...\n");
1873
1874	/* Wait for the thread to initialize. */
1875	rc = RTThreadUserWait(pProcess->Thread, 60 * 1000 /* 60 seconds max. */);
1876	AssertRC(rc);
1877	if ( ASMAtomicReadBool(&pProcess->fShutdown)
1878	\|\| ASMAtomicReadBool(&pProcess->fStopped)
1879	\|\| RT_FAILURE(rc))
1880	{
1881	VGSvcError("Thread for process '%s' failed to start, rc=%Rrc\n", pStartupInfo->pszCmd, rc);
1882	int rc2 = RTThreadWait(pProcess->Thread, RT_MS_1SEC * 30, NULL);
1883	if (RT_SUCCESS(rc2))
1884	pProcess->Thread = NIL_RTTHREAD;
1885
1886	VGSvcGstCtrlSessionProcessRemove(pSession, pProcess);
1887	VGSvcGstCtrlProcessFree(pProcess);
1888	}
1889	else
1890	{
1891	ASMAtomicXchgBool(&pProcess->fStarted, true);
1892	}
1893	}
1894	}
1895
1896	return rc;
1897	}
1898
1899
1900	static DECLCALLBACK(int) vgsvcGstCtrlProcessOnInput(PVBOXSERVICECTRLPROCESS pThis,
1901	const PVBGLR3GUESTCTRLCMDCTX pHostCtx,
1902	bool fPendingClose, void *pvBuf, uint32_t cbBuf)
1903	{
1904	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1905	AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
1906
1907	int rc;
1908
1909	size_t cbWritten = 0;
1910	if (pvBuf && cbBuf)
1911	{
1912	if (pThis->hPipeStdInW != NIL_RTPIPE)
1913	rc = RTPipeWrite(pThis->hPipeStdInW, pvBuf, cbBuf, &cbWritten);
1914	else
1915	rc = VINF_EOF;
1916	}
1917	else
1918	rc = VERR_INVALID_PARAMETER;
1919
1920	/*
1921	* If this is the last write + we have really have written all data
1922	* we need to close the stdin pipe on our end and remove it from
1923	* the poll set.
1924	*/
1925	if ( fPendingClose
1926	&& cbBuf == cbWritten)
1927	{
1928	int rc2 = vgsvcGstCtrlProcessPollsetCloseInput(pThis, &pThis->hPipeStdInW);
1929	if (RT_SUCCESS(rc))
1930	rc = rc2;
1931	}
1932
1933	uint32_t uStatus = INPUT_STS_UNDEFINED; /* Status to send back to the host. */
1934	uint32_t fFlags = 0; /* No flags at the moment. */
1935	if (RT_SUCCESS(rc))
1936	{
1937	VGSvcVerbose(4, "[PID %RU32]: Written %RU32 bytes input, CID=%RU32, fPendingClose=%RTbool\n",
1938	pThis->uPID, cbWritten, pHostCtx->uContextID, fPendingClose);
1939	uStatus = INPUT_STS_WRITTEN;
1940	}
1941	else
1942	{
1943	if (rc == VERR_BAD_PIPE)
1944	uStatus = INPUT_STS_TERMINATED;
1945	else if (rc == VERR_BUFFER_OVERFLOW)
1946	uStatus = INPUT_STS_OVERFLOW;
1947	/* else undefined */
1948	}
1949
1950	/*
1951	* If there was an error and we did not set the host status
1952	* yet, then do it now.
1953	*/
1954	if ( RT_FAILURE(rc)
1955	&& uStatus == INPUT_STS_UNDEFINED)
1956	{
1957	uStatus = INPUT_STS_ERROR;
1958	fFlags = rc; /* funny thing to call a "flag"... */
1959	}
1960	Assert(uStatus > INPUT_STS_UNDEFINED);
1961
1962	int rc2 = VbglR3GuestCtrlProcCbStatusInput(pHostCtx, pThis->uPID, uStatus, fFlags, (uint32_t)cbWritten);
1963	if (RT_SUCCESS(rc))
1964	rc = rc2;
1965
1966	#ifdef DEBUG
1967	VGSvcVerbose(3, "[PID %RU32]: vgsvcGstCtrlProcessOnInput returned with rc=%Rrc\n", pThis->uPID, rc);
1968	#endif
1969	return rc;
1970	}
1971
1972
1973	static DECLCALLBACK(int) vgsvcGstCtrlProcessOnOutput(PVBOXSERVICECTRLPROCESS pThis,
1974	const PVBGLR3GUESTCTRLCMDCTX pHostCtx,
1975	uint32_t uHandle, uint32_t cbToRead, uint32_t fFlags)
1976	{
1977	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1978	AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
1979
1980	const PVBOXSERVICECTRLSESSION pSession = pThis->pSession;
1981	AssertPtrReturn(pSession, VERR_INVALID_POINTER);
1982
1983	int rc;
1984
1985	uint32_t cbBuf = cbToRead;
1986	uint8_t pvBuf = (uint8_t )RTMemAlloc(cbBuf);
1987	if (pvBuf)
1988	{
1989	PRTPIPE phPipe = uHandle == GUEST_PROC_OUT_H_STDOUT
1990	? &pThis->hPipeStdOutR
1991	: &pThis->hPipeStdErrR;
1992	AssertPtr(phPipe);
1993
1994	size_t cbRead = 0;
1995	if (*phPipe != NIL_RTPIPE)
1996	{
1997	rc = RTPipeRead(*phPipe, pvBuf, cbBuf, &cbRead);
1998	if (RT_FAILURE(rc))
1999	{
2000	RTPollSetRemove(pThis->hPollSet, uHandle == GUEST_PROC_OUT_H_STDERR
2001	? VBOXSERVICECTRLPIPEID_STDERR : VBOXSERVICECTRLPIPEID_STDOUT);
2002	RTPipeClose(*phPipe);
2003	*phPipe = NIL_RTPIPE;
2004	if (rc == VERR_BROKEN_PIPE)
2005	rc = VINF_EOF;
2006	}
2007	}
2008	else
2009	rc = VINF_EOF;
2010
2011	#ifdef DEBUG
2012	if (RT_SUCCESS(rc))
2013	{
2014	if ( pSession->fFlags & VBOXSERVICECTRLSESSION_FLAG_DUMPSTDOUT
2015	&& ( uHandle == GUEST_PROC_OUT_H_STDOUT
2016	\|\| uHandle == GUEST_PROC_OUT_H_STDOUT_DEPRECATED)
2017	)
2018	{
2019	rc = vgsvcGstCtrlProcessDbgDumpToFileF(pvBuf, cbRead, "VBoxService_Session%RU32_PID%RU32_StdOut.txt",
2020	pSession->StartupInfo.uSessionID, pThis->uPID);
2021	AssertRC(rc);
2022	}
2023	else if ( pSession->fFlags & VBOXSERVICECTRLSESSION_FLAG_DUMPSTDERR
2024	&& uHandle == GUEST_PROC_OUT_H_STDERR)
2025	{
2026	rc = vgsvcGstCtrlProcessDbgDumpToFileF(pvBuf, cbRead, "VBoxService_Session%RU32_PID%RU32_StdErr.txt",
2027	pSession->StartupInfo.uSessionID, pThis->uPID);
2028	AssertRC(rc);
2029	}
2030	}
2031	#endif
2032
2033	if (RT_SUCCESS(rc))
2034	{
2035	#ifdef DEBUG
2036	VGSvcVerbose(3, "[PID %RU32]: Read %RU32 bytes output: uHandle=%RU32, CID=%RU32, fFlags=%x\n",
2037	pThis->uPID, cbRead, uHandle, pHostCtx->uContextID, fFlags);
2038	#endif
2039	/** Note: Don't convert/touch/modify/whatever the output data here! This might be binary
2040	* data which the host needs to work with -- so just pass through all data unfiltered! */
2041
2042	/* Note: Since the context ID is unique the request has to be completed here,
2043	* regardless whether we got data or not! Otherwise the waiting events
2044	* on the host never will get completed! */
2045	Assert((uint32_t)cbRead == cbRead);
2046	rc = VbglR3GuestCtrlProcCbOutput(pHostCtx, pThis->uPID, uHandle, fFlags, pvBuf, (uint32_t)cbRead);
2047	if ( RT_FAILURE(rc)
2048	&& rc == VERR_NOT_FOUND) /* Not critical if guest PID is not found on the host (anymore). */
2049	rc = VINF_SUCCESS;
2050	}
2051
2052	RTMemFree(pvBuf);
2053	}
2054	else
2055	rc = VERR_NO_MEMORY;
2056
2057	#ifdef DEBUG
2058	VGSvcVerbose(3, "[PID %RU32]: Reading output returned with rc=%Rrc\n", pThis->uPID, rc);
2059	#endif
2060	return rc;
2061	}
2062
2063
2064	static DECLCALLBACK(int) vgsvcGstCtrlProcessOnTerm(PVBOXSERVICECTRLPROCESS pThis)
2065	{
2066	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
2067
2068	if (!ASMAtomicXchgBool(&pThis->fShutdown, true))
2069	VGSvcVerbose(3, "[PID %RU32]: Setting shutdown flag ...\n", pThis->uPID);
2070
2071	return VINF_SUCCESS;
2072	}
2073
2074
2075	static int vgsvcGstCtrlProcessRequestExV(PVBOXSERVICECTRLPROCESS pProcess, const PVBGLR3GUESTCTRLCMDCTX pHostCtx, bool fAsync,
2076	RTMSINTERVAL uTimeoutMS, PFNRT pfnFunction, unsigned cArgs, va_list Args)
2077	{
2078	RT_NOREF1(pHostCtx);
2079	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
2080	/* pHostCtx is optional. */
2081	AssertPtrReturn(pfnFunction, VERR_INVALID_POINTER);
2082	if (!fAsync)
2083	AssertPtrReturn(pfnFunction, VERR_INVALID_POINTER);
2084
2085	int rc = vgsvcGstCtrlProcessLock(pProcess);
2086	if (RT_SUCCESS(rc))
2087	{
2088	#ifdef DEBUG
2089	VGSvcVerbose(3, "[PID %RU32]: vgsvcGstCtrlProcessRequestExV fAsync=%RTbool, uTimeoutMS=%RU32, cArgs=%u\n",
2090	pProcess->uPID, fAsync, uTimeoutMS, cArgs);
2091	#endif
2092	uint32_t fFlags = RTREQFLAGS_IPRT_STATUS;
2093	if (fAsync)
2094	{
2095	Assert(uTimeoutMS == 0);
2096	fFlags \|= RTREQFLAGS_NO_WAIT;
2097	}
2098
2099	PRTREQ hReq = NIL_RTREQ;
2100	rc = RTReqQueueCallV(pProcess->hReqQueue, &hReq, uTimeoutMS, fFlags, pfnFunction, cArgs, Args);
2101	RTReqRelease(hReq);
2102	if (RT_SUCCESS(rc))
2103	{
2104	/* Wake up the process' notification pipe to get
2105	* the request being processed. */
2106	Assert(pProcess->hNotificationPipeW != NIL_RTPIPE \|\| pProcess->fShutdown /* latter in case of race */);
2107	size_t cbWritten = 0;
2108	rc = RTPipeWrite(pProcess->hNotificationPipeW, "i", 1, &cbWritten);
2109	if ( RT_SUCCESS(rc)
2110	&& cbWritten != 1)
2111	{
2112	VGSvcError("[PID %RU32]: Notification pipe got %zu bytes instead of 1\n",
2113	pProcess->uPID, cbWritten);
2114	}
2115	else if (RT_UNLIKELY(RT_FAILURE(rc)))
2116	VGSvcError("[PID %RU32]: Writing to notification pipe failed, rc=%Rrc\n",
2117	pProcess->uPID, rc);
2118	}
2119	else
2120	VGSvcError("[PID %RU32]: RTReqQueueCallV failed, rc=%Rrc\n",
2121	pProcess->uPID, rc);
2122
2123	int rc2 = vgsvcGstCtrlProcessUnlock(pProcess);
2124	if (RT_SUCCESS(rc))
2125	rc = rc2;
2126	}
2127
2128	#ifdef DEBUG
2129	VGSvcVerbose(3, "[PID %RU32]: vgsvcGstCtrlProcessRequestExV returned rc=%Rrc\n", pProcess->uPID, rc);
2130	#endif
2131	return rc;
2132	}
2133
2134
2135	static int vgsvcGstCtrlProcessRequestAsync(PVBOXSERVICECTRLPROCESS pProcess, const PVBGLR3GUESTCTRLCMDCTX pHostCtx,
2136	PFNRT pfnFunction, unsigned cArgs, ...)
2137	{
2138	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
2139	/* pHostCtx is optional. */
2140	AssertPtrReturn(pfnFunction, VERR_INVALID_POINTER);
2141
2142	va_list va;
2143	va_start(va, cArgs);
2144	int rc = vgsvcGstCtrlProcessRequestExV(pProcess, pHostCtx, true /* fAsync /, 0 / uTimeoutMS */,
2145	pfnFunction, cArgs, va);
2146	va_end(va);
2147
2148	return rc;
2149	}
2150
2151
2152	#if 0 /* unused */
2153	static int vgsvcGstCtrlProcessRequestWait(PVBOXSERVICECTRLPROCESS pProcess, const PVBGLR3GUESTCTRLCMDCTX pHostCtx,
2154	RTMSINTERVAL uTimeoutMS, PFNRT pfnFunction, unsigned cArgs, ...)
2155	{
2156	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
2157	/* pHostCtx is optional. */
2158	AssertPtrReturn(pfnFunction, VERR_INVALID_POINTER);
2159
2160	va_list va;
2161	va_start(va, cArgs);
2162	int rc = vgsvcGstCtrlProcessRequestExV(pProcess, pHostCtx, false /* fAsync */, uTimeoutMS,
2163	pfnFunction, cArgs, va);
2164	va_end(va);
2165
2166	return rc;
2167	}
2168	#endif
2169
2170
2171	int VGSvcGstCtrlProcessHandleInput(PVBOXSERVICECTRLPROCESS pProcess, PVBGLR3GUESTCTRLCMDCTX pHostCtx,
2172	bool fPendingClose, void *pvBuf, uint32_t cbBuf)
2173	{
2174	if (!ASMAtomicReadBool(&pProcess->fShutdown) && !ASMAtomicReadBool(&pProcess->fStopped))
2175	return vgsvcGstCtrlProcessRequestAsync(pProcess, pHostCtx, (PFNRT)vgsvcGstCtrlProcessOnInput,
2176	5 /* cArgs */, pProcess, pHostCtx, fPendingClose, pvBuf, cbBuf);
2177
2178	return vgsvcGstCtrlProcessOnInput(pProcess, pHostCtx, fPendingClose, pvBuf, cbBuf);
2179	}
2180
2181
2182	int VGSvcGstCtrlProcessHandleOutput(PVBOXSERVICECTRLPROCESS pProcess, PVBGLR3GUESTCTRLCMDCTX pHostCtx,
2183	uint32_t uHandle, uint32_t cbToRead, uint32_t fFlags)
2184	{
2185	if (!ASMAtomicReadBool(&pProcess->fShutdown) && !ASMAtomicReadBool(&pProcess->fStopped))
2186	return vgsvcGstCtrlProcessRequestAsync(pProcess, pHostCtx, (PFNRT)vgsvcGstCtrlProcessOnOutput,
2187	5 /* cArgs */, pProcess, pHostCtx, uHandle, cbToRead, fFlags);
2188
2189	return vgsvcGstCtrlProcessOnOutput(pProcess, pHostCtx, uHandle, cbToRead, fFlags);
2190	}
2191
2192
2193	int VGSvcGstCtrlProcessHandleTerm(PVBOXSERVICECTRLPROCESS pProcess)
2194	{
2195	if (!ASMAtomicReadBool(&pProcess->fShutdown) && !ASMAtomicReadBool(&pProcess->fStopped))
2196	return vgsvcGstCtrlProcessRequestAsync(pProcess, NULL /* pHostCtx */, (PFNRT)vgsvcGstCtrlProcessOnTerm,
2197	1 /* cArgs */, pProcess);
2198
2199	return vgsvcGstCtrlProcessOnTerm(pProcess);
2200	}
2201

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

source: vbox/trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControlProcess.cpp@ 98613

Download in other formats: