VBoxServiceControlExec.cpp@ 38115

Last change on this file since 38115 was 38115, checked in by vboxsync, 13 years ago
Removed debug output.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 56.8 KB

Line
1	/* $Id: VBoxServiceControlExec.cpp 38115 2011-07-22 14:00:50Z vboxsync $ */
2	/** @file
3	* VBoxServiceControlExec - Utility functions for process execution.
4	*/
5
6	/*
7	* Copyright (C) 2011 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
18
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#include <iprt/assert.h>
23	#include <iprt/crc.h>
24	#include <iprt/ctype.h>
25	#include <iprt/env.h>
26	#include <iprt/file.h>
27	#include <iprt/getopt.h>
28	#include <iprt/handle.h>
29	#include <iprt/mem.h>
30	#include <iprt/path.h>
31	#include <iprt/param.h>
32	#include <iprt/pipe.h>
33	#include <iprt/poll.h>
34	#include <iprt/process.h>
35	#include <iprt/string.h>
36	#include <iprt/stream.h>
37	#include <iprt/thread.h>
38	#include <VBox/version.h>
39	#include <VBox/VBoxGuestLib.h>
40	#include <VBox/HostServices/GuestControlSvc.h>
41
42	#include "VBoxServiceInternal.h"
43	#include "VBoxServiceUtils.h"
44	#include "VBoxServicePipeBuf.h"
45	#include "VBoxServiceControlExecThread.h"
46
47	using namespace guestControl;
48
49	extern RTLISTNODE g_GuestControlExecThreads;
50	extern RTCRITSECT g_GuestControlExecThreadsCritSect;
51
52
53	/**
54	* Handle an error event on standard input.
55	*
56	* @returns IPRT status code.
57	* @param hPollSet The polling set.
58	* @param fPollEvt The event mask returned by RTPollNoResume.
59	* @param phStdInW The standard input pipe handle.
60	* @param pStdInBuf The standard input buffer.
61	*/
62	static int VBoxServiceControlExecProcHandleStdInErrorEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, PRTPIPE phStdInW,
63	PVBOXSERVICECTRLEXECPIPEBUF pStdInBuf)
64	{
65	int rc = RTPollSetRemove(hPollSet, VBOXSERVICECTRLPIPEID_STDIN_WRITABLE);
66	/* Don't assert if writable handle is not in poll set anymore. */
67	if ( RT_FAILURE(rc)
68	&& rc != VERR_POLL_HANDLE_ID_NOT_FOUND)
69	{
70	AssertRC(rc);
71	}
72
73	/* Close writable stdin pipe. */
74	rc = RTPipeClose(*phStdInW);
75	AssertRC(rc);
76	*phStdInW = NIL_RTPIPE;
77
78	/* Mark the stdin buffer as dead; we're not using it anymore. */
79	rc = VBoxServicePipeBufSetStatus(pStdInBuf, false /* Disabled */);
80	AssertRC(rc);
81
82	/* Remove stdin error handle from set. */
83	rc = RTPollSetRemove(hPollSet, VBOXSERVICECTRLPIPEID_STDIN_ERROR);
84	/* Don't assert if writable handle is not in poll set anymore. */
85	if ( RT_FAILURE(rc)
86	&& rc != VERR_POLL_HANDLE_ID_NOT_FOUND)
87	{
88	AssertRC(rc);
89	}
90	else
91	rc = VINF_SUCCESS;
92
93	return rc;
94	}
95
96
97	/**
98	* Try write some more data to the standard input of the child.
99	*
100	* @returns IPRT status code.
101	* @retval VINF_TRY_AGAIN if there is still data left in the buffer.
102	*
103	* @param hPollSet The polling set.
104	* @param pStdInBuf The standard input buffer.
105	* @param hStdInW The standard input pipe.
106	* @param pfClose Pointer to a flag whether the pipe needs to be closed afterwards.
107	*/
108	static int VBoxServiceControlExecProcWriteStdIn(RTPOLLSET hPollSet, PVBOXSERVICECTRLEXECPIPEBUF pStdInBuf, RTPIPE hStdInW,
109	size_t pcbWritten, bool pfClose)
110	{
111	AssertPtrReturn(pStdInBuf, VERR_INVALID_PARAMETER);
112	AssertPtrReturn(pcbWritten, VERR_INVALID_PARAMETER);
113	AssertPtrReturn(pfClose, VERR_INVALID_PARAMETER);
114
115	size_t cbLeft;
116	int rc = VBoxServicePipeBufWriteToPipe(pStdInBuf, hStdInW, pcbWritten, &cbLeft);
117
118	/* If we have written all data which is in the buffer set the close flag. */
119	*pfClose = (cbLeft == 0) && VBoxServicePipeBufIsClosing(pStdInBuf);
120
121	if ( !*pcbWritten
122	&& VBoxServicePipeBufIsEnabled(pStdInBuf))
123	{
124	/*
125	* Nothing else left to write now? Remove the writable event from the poll set
126	* to not trigger too high CPU loads.
127	*/
128	int rc2 = RTPollSetRemove(hPollSet, VBOXSERVICECTRLPIPEID_STDIN_WRITABLE);
129	AssertRC(rc2);
130	}
131
132	VBoxServiceVerbose(3, "VBoxServiceControlExecProcWriteStdIn: Written=%u, Left=%u, rc=%Rrc\n",
133	*pcbWritten, cbLeft, rc);
134	return rc;
135	}
136
137
138	/**
139	* Handle an event indicating we can write to the standard input pipe of the
140	* child process.
141	*
142	* @returns IPRT status code.
143	* @param hPollSet The polling set.
144	* @param fPollEvt The event mask returned by RTPollNoResume.
145	* @param phStdInW The standard input pipe.
146	* @param pStdInBuf The standard input buffer.
147	* @param pcbWritten Where to return the number of bytes written.
148	*/
149	static int VBoxServiceControlExecProcHandleStdInWritableEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, PRTPIPE phStdInW,
150	PVBOXSERVICECTRLEXECPIPEBUF pStdInBuf, size_t *pcbWritten)
151	{
152	AssertPtrReturn(pcbWritten, VERR_INVALID_PARAMETER);
153	int rc;
154	if (!(fPollEvt & RTPOLL_EVT_ERROR))
155	{
156	bool fClose;
157	rc = VBoxServiceControlExecProcWriteStdIn(hPollSet,
158	pStdInBuf, *phStdInW,
159	pcbWritten, &fClose);
160	if ( rc == VINF_TRY_AGAIN
161	\|\| rc == VERR_MORE_DATA)
162	rc = VINF_SUCCESS;
163	if (RT_FAILURE(rc))
164	{
165	if ( rc == VERR_BAD_PIPE
166	\|\| rc == VERR_BROKEN_PIPE)
167	{
168	rc = RTPollSetRemove(hPollSet, VBOXSERVICECTRLPIPEID_STDIN_WRITABLE);
169	AssertRC(rc);
170	}
171	else
172	{
173	/** @todo Do we need to do something about this error condition? */
174	AssertRC(rc);
175	}
176	}
177	else if (fClose)
178	{
179	/* If the pipe needs to be closed, do so. */
180	rc = VBoxServiceControlExecProcHandleStdInErrorEvent(hPollSet, fPollEvt, phStdInW, pStdInBuf);
181	}
182	}
183	else
184	{
185	*pcbWritten = 0;
186	rc = VBoxServiceControlExecProcHandleStdInErrorEvent(hPollSet, fPollEvt, phStdInW, pStdInBuf);
187	}
188	return rc;
189	}
190
191
192	/**
193	* Handle pending output data/error on stdout or stderr.
194	*
195	* @return IPRT status code.
196	* @param hPollSet The polling set.
197	* @param fPollEvt The event mask returned by RTPollNoResume.
198	* @param phPipeR The pipe to be read from.
199	* @param uHandleId Handle ID of the pipe to be read from.
200	* @param pBuf Pointer to pipe buffer to store the read data into.
201	*/
202	static int VBoxServiceControlExecProcHandleOutputEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, PRTPIPE phPipeR,
203	uint32_t uHandleId, PVBOXSERVICECTRLEXECPIPEBUF pBuf)
204	{
205	AssertPtrReturn(phPipeR, VERR_INVALID_POINTER);
206	AssertPtrReturn(pBuf, VERR_INVALID_POINTER);
207
208	/*
209	* Try drain the pipe before acting on any errors.
210	*/
211	int rc = VINF_SUCCESS;
212	size_t cbRead;
213	uint8_t abBuf[_64K];
214
215	int rc2 = RTPipeRead(*phPipeR, abBuf, sizeof(abBuf), &cbRead);
216	if (RT_SUCCESS(rc2) && cbRead)
217	{
218	uint32_t cbWritten;
219	rc = VBoxServicePipeBufWriteToBuf(pBuf, abBuf,
220	cbRead, false /* Pending close */, &cbWritten);
221	#ifdef DEBUG_andy
222	VBoxServiceVerbose(4, "ControlExec: Written output event [%u %u], cbRead=%u, cbWritten=%u, rc=%Rrc, uHandleId=%u, fPollEvt=%#x\n",
223	pBuf->uPID, pBuf->uPipeId, cbRead, cbWritten, rc, uHandleId, fPollEvt);
224	#endif
225	if (RT_SUCCESS(rc))
226	{
227	Assert(cbRead == cbWritten);
228	/* Make sure we go another poll round in case there was too much data
229	for the buffer to hold. */
230	fPollEvt &= RTPOLL_EVT_ERROR;
231	}
232	}
233	else if (RT_FAILURE(rc2))
234	{
235	fPollEvt \|= RTPOLL_EVT_ERROR;
236	AssertMsg(rc2 == VERR_BROKEN_PIPE, ("%Rrc\n", rc));
237	}
238
239	/*
240	* If an error was signalled, close reading stdout/stderr pipe.
241	*/
242	if (fPollEvt & RTPOLL_EVT_ERROR)
243	{
244	rc2 = RTPollSetRemove(hPollSet, uHandleId);
245	AssertRC(rc2);
246
247	rc2 = RTPipeClose(*phPipeR);
248	AssertRC(rc2);
249	*phPipeR = NIL_RTPIPE;
250	}
251	return rc;
252	}
253
254
255	int VBoxServiceControlExecProcHandleStdInputNotify(RTPOLLSET hPollSet,
256	PRTPIPE phNotificationPipeR, PRTPIPE phInputPipeW)
257	{
258	#ifdef DEBUG_andy
259	VBoxServiceVerbose(4, "ControlExec: HandleStdInputNotify\n");
260	#endif
261	/* Drain the notification pipe. */
262	uint8_t abBuf[8];
263	size_t cbIgnore;
264	int rc = RTPipeRead(*phNotificationPipeR, abBuf, sizeof(abBuf), &cbIgnore);
265	if (RT_SUCCESS(rc))
266	{
267	/*
268	* When the writable handle previously was removed from the poll set we need to add
269	* it here again so that writable events from the started procecss get handled correctly.
270	*/
271	RTHANDLE hWritableIgnored;
272	rc = RTPollSetQueryHandle(hPollSet, VBOXSERVICECTRLPIPEID_STDIN_WRITABLE, &hWritableIgnored);
273	if (rc == VERR_POLL_HANDLE_ID_NOT_FOUND)
274	rc = RTPollSetAddPipe(hPollSet, *phInputPipeW, RTPOLL_EVT_WRITE, VBOXSERVICECTRLPIPEID_STDIN_WRITABLE);
275	}
276	return rc;
277	}
278
279
280	/**
281	* Execution loop which runs in a dedicated per-started-process thread and
282	* handles all pipe input/output and signalling stuff.
283	*
284	* @return IPRT status code.
285	* @param pThread The process' thread handle.
286	* @param hProcess The actual process handle.
287	* @param cMsTimeout Time limit (in ms) of the process' life time.
288	* @param hPollSet The poll set to use.
289	* @param hStdInW Handle to the process' stdin write end.
290	* @param hStdOutR Handle to the process' stdout read end.
291	* @param hStdErrR Handle to the process' stderr read end.
292	*/
293	static int VBoxServiceControlExecProcLoop(PVBOXSERVICECTRLTHREAD pThread,
294	RTPROCESS hProcess, RTMSINTERVAL cMsTimeout, RTPOLLSET hPollSet,
295	PRTPIPE phStdInW, PRTPIPE phStdOutR, PRTPIPE phStdErrR)
296	{
297	AssertPtrReturn(phStdInW, VERR_INVALID_PARAMETER);
298	AssertPtrReturn(phStdOutR, VERR_INVALID_PARAMETER);
299	AssertPtrReturn(phStdErrR, VERR_INVALID_PARAMETER);
300
301	int rc;
302	int rc2;
303	uint64_t const MsStart = RTTimeMilliTS();
304	RTPROCSTATUS ProcessStatus = { 254, RTPROCEXITREASON_ABEND };
305	bool fProcessAlive = true;
306	bool fProcessTimedOut = false;
307	uint64_t MsProcessKilled = UINT64_MAX;
308	RTMSINTERVAL const cMsPollBase = *phStdInW != NIL_RTPIPE
309	? 100 /* Need to poll for input. */
310	: 1000; /* Need only poll for process exit and aborts. */
311	RTMSINTERVAL cMsPollCur = 0;
312
313	AssertPtr(pThread);
314	Assert(pThread->enmType == kVBoxServiceCtrlThreadDataExec);
315	PVBOXSERVICECTRLTHREADDATAEXEC pData = (PVBOXSERVICECTRLTHREADDATAEXEC)pThread->pvData;
316	AssertPtr(pData);
317
318	/*
319	* Assign PID to thread data.
320	* Also check if there already was a thread with the same PID and shut it down -- otherwise
321	* the first (stale) entry will be found and we get really weird results!
322	*/
323	rc = VBoxServiceControlExecThreadAssignPID(pData, hProcess);
324	if (RT_FAILURE(rc))
325	{
326	VBoxServiceError("ControlExec: Unable to assign PID to new thread, rc=%Rrc\n", rc);
327	return rc;
328	}
329
330	/*
331	* Before entering the loop, tell the host that we've started the guest
332	* and that it's now OK to send input to the process.
333	*/
334	VBoxServiceVerbose(3, "ControlExec: [PID %u]: Process started, CID=%u, User=%s\n",
335	pData->uPID, pThread->uContextID, pData->pszUser);
336	rc = VbglR3GuestCtrlExecReportStatus(pThread->uClientID, pThread->uContextID,
337	pData->uPID, PROC_STS_STARTED, 0 /* u32Flags */,
338	NULL /* pvData /, 0 / cbData */);
339
340	/*
341	* Process input, output, the test pipe and client requests.
342	*/
343	while ( RT_SUCCESS(rc)
344	&& RT_UNLIKELY(!pThread->fShutdown))
345	{
346	/*
347	* Wait/Process all pending events.
348	*/
349	uint32_t idPollHnd;
350	uint32_t fPollEvt;
351	rc2 = RTPollNoResume(hPollSet, cMsPollCur, &fPollEvt, &idPollHnd);
352	if (pThread->fShutdown)
353	continue;
354
355	cMsPollCur = 0; /* No rest until we've checked everything. */
356
357	if (RT_SUCCESS(rc2))
358	{
359	/*VBoxServiceVerbose(4, "ControlExec: [PID %u}: RTPollNoResume idPollHnd=%u\n",
360	pData->uPID, idPollHnd);*/
361	switch (idPollHnd)
362	{
363	case VBOXSERVICECTRLPIPEID_STDIN_ERROR:
364	rc = VBoxServiceControlExecProcHandleStdInErrorEvent(hPollSet, fPollEvt, phStdInW, &pData->stdIn);
365	break;
366
367	case VBOXSERVICECTRLPIPEID_STDIN_INPUT_NOTIFY:
368	rc = VBoxServiceControlExecProcHandleStdInputNotify(hPollSet,
369	&pData->stdIn.hNotificationPipeR, &pData->pipeStdInW);
370	AssertRC(rc);
371	/* Fall through. */
372	case VBOXSERVICECTRLPIPEID_STDIN_WRITABLE:
373	{
374	size_t cbWritten;
375	rc = VBoxServiceControlExecProcHandleStdInWritableEvent(hPollSet, fPollEvt, phStdInW,
376	&pData->stdIn, &cbWritten);
377	break;
378	}
379
380	case VBOXSERVICECTRLPIPEID_STDOUT:
381	#ifdef DEBUG
382	VBoxServiceVerbose(4, "ControlExec: [PID %u]: StdOut fPollEvt=%#x\n",
383	pData->uPID, fPollEvt);
384	#endif
385	rc = VBoxServiceControlExecProcHandleOutputEvent(hPollSet, fPollEvt, phStdOutR,
386	VBOXSERVICECTRLPIPEID_STDOUT, &pData->stdOut);
387	break;
388
389	case VBOXSERVICECTRLPIPEID_STDERR:
390	#ifdef DEBUG
391	VBoxServiceVerbose(4, "ControlExec: [PID %u]: StdErr: fPollEvt=%#x\n",
392	pData->uPID, fPollEvt);
393	#endif
394	rc = VBoxServiceControlExecProcHandleOutputEvent(hPollSet, fPollEvt, phStdErrR,
395	VBOXSERVICECTRLPIPEID_STDERR, &pData->stdErr);
396	break;
397
398	default:
399	AssertMsgFailed(("PID=%u idPollHnd=%u fPollEvt=%#x\n",
400	pData->uPID, idPollHnd, fPollEvt));
401	break;
402	}
403	if (RT_FAILURE(rc) \|\| rc == VINF_EOF)
404	break; /* Abort command, or client dead or something. */
405	continue;
406	}
407
408	/*
409	* Check for process death.
410	*/
411	if (fProcessAlive)
412	{
413	rc2 = RTProcWaitNoResume(hProcess, RTPROCWAIT_FLAGS_NOBLOCK, &ProcessStatus);
414	if (RT_SUCCESS_NP(rc2))
415	{
416	fProcessAlive = false;
417	continue;
418	}
419	if (RT_UNLIKELY(rc2 == VERR_INTERRUPTED))
420	continue;
421	if (RT_UNLIKELY(rc2 == VERR_PROCESS_NOT_FOUND))
422	{
423	fProcessAlive = false;
424	ProcessStatus.enmReason = RTPROCEXITREASON_ABEND;
425	ProcessStatus.iStatus = 255;
426	AssertFailed();
427	}
428	else
429	AssertMsg(rc2 == VERR_PROCESS_RUNNING, ("%Rrc\n", rc2));
430	}
431
432	/*
433	* If the process has terminated, we're should head out.
434	*/
435	if (!fProcessAlive)
436	break;
437
438	/*
439	* Check for timed out, killing the process.
440	*/
441	uint32_t cMilliesLeft = RT_INDEFINITE_WAIT;
442	if (cMsTimeout != RT_INDEFINITE_WAIT)
443	{
444	uint64_t u64Now = RTTimeMilliTS();
445	uint64_t cMsElapsed = u64Now - MsStart;
446	if (cMsElapsed >= cMsTimeout)
447	{
448	VBoxServiceVerbose(3, "ControlExec: [PID %u]: Timed out (%ums elapsed > %ums timeout), killing ...",
449	pData->uPID, cMsElapsed, cMsTimeout);
450
451	fProcessTimedOut = true;
452	if ( MsProcessKilled == UINT64_MAX
453	\|\| u64Now - MsProcessKilled > 1000)
454	{
455	if (u64Now - MsProcessKilled > 20601000)
456	break; /* Give up after 20 mins. */
457	RTProcTerminate(hProcess);
458	MsProcessKilled = u64Now;
459	continue;
460	}
461	cMilliesLeft = 10000;
462	}
463	else
464	cMilliesLeft = cMsTimeout - (uint32_t)cMsElapsed;
465	}
466
467	/* Reset the polling interval since we've done all pending work. */
468	cMsPollCur = cMilliesLeft >= cMsPollBase ? cMsPollBase : cMilliesLeft;
469
470	/*
471	* Need to exit?
472	*/
473	if (pThread->fShutdown)
474	break;
475	}
476
477	/*
478	* Try kill the process if it's still alive at this point.
479	*/
480	if (fProcessAlive)
481	{
482	if (MsProcessKilled == UINT64_MAX)
483	{
484	VBoxServiceVerbose(3, "ControlExec: [PID %u]: Is still alive and not killed yet\n",
485	pData->uPID);
486
487	MsProcessKilled = RTTimeMilliTS();
488	RTProcTerminate(hProcess);
489	RTThreadSleep(500);
490	}
491
492	for (size_t i = 0; i < 10; i++)
493	{
494	VBoxServiceVerbose(4, "ControlExec: [PID %u]: Kill attempt %d/10: Waiting to exit ...\n",
495	pData->uPID, i + 1);
496	rc2 = RTProcWait(hProcess, RTPROCWAIT_FLAGS_NOBLOCK, &ProcessStatus);
497	if (RT_SUCCESS(rc2))
498	{
499	VBoxServiceVerbose(4, "ControlExec: [PID %u]: Kill attempt %d/10: Exited\n",
500	pData->uPID, i + 1);
501	fProcessAlive = false;
502	break;
503	}
504	if (i >= 5)
505	{
506	VBoxServiceVerbose(4, "ControlExec: [PID %u]: Kill attempt %d/10: Trying to terminate ...\n",
507	pData->uPID, i + 1);
508	RTProcTerminate(hProcess);
509	}
510	RTThreadSleep(i >= 5 ? 2000 : 500);
511	}
512
513	if (fProcessAlive)
514	VBoxServiceVerbose(3, "ControlExec: [PID %u]: Could not be killed\n", pData->uPID);
515	}
516
517	/*
518	* If we don't have a client problem (RT_FAILURE(rc)) we'll reply to the
519	* clients exec packet now.
520	*/
521	if (RT_SUCCESS(rc))
522	{
523	VBoxServicePipeBufSetStatus(&pData->stdIn, false /* Disabled */);
524	VBoxServicePipeBufSetStatus(&pData->stdOut, false /* Disabled */);
525	VBoxServicePipeBufSetStatus(&pData->stdErr, false /* Disabled */);
526
527	/* Since the process is not alive anymore, destroy its local
528	* stdin pipe buffer - it's not used anymore and can eat up quite
529	* a bit of memory. */
530	VBoxServicePipeBufDestroy(&pData->stdIn);
531
532	uint32_t uStatus = PROC_STS_UNDEFINED;
533	uint32_t uFlags = 0;
534
535	if ( fProcessTimedOut && !fProcessAlive && MsProcessKilled != UINT64_MAX)
536	{
537	VBoxServiceVerbose(3, "ControlExec: [PID %u]: Timed out and got killed\n",
538	pData->uPID);
539	uStatus = PROC_STS_TOK;
540	}
541	else if (fProcessTimedOut && fProcessAlive && MsProcessKilled != UINT64_MAX)
542	{
543	VBoxServiceVerbose(3, "ControlExec: [PID %u]: Timed out and did not get killed\n",
544	pData->uPID);
545	uStatus = PROC_STS_TOA;
546	}
547	else if (pThread->fShutdown && (fProcessAlive \|\| MsProcessKilled != UINT64_MAX))
548	{
549	VBoxServiceVerbose(3, "ControlExec: [PID %u]: Got terminated because system/service is about to shutdown\n",
550	pData->uPID);
551	uStatus = PROC_STS_DWN; /* Service is stopping, process was killed. */
552	uFlags = pData->uFlags; /* Return handed-in execution flags back to the host. */
553	}
554	else if (fProcessAlive)
555	{
556	VBoxServiceError("ControlExec: [PID %u]: Is alive when it should not!\n",
557	pData->uPID);
558	}
559	else if (MsProcessKilled != UINT64_MAX)
560	{
561	VBoxServiceError("ControlExec: [PID %u]: Has been killed when it should not!\n",
562	pData->uPID);
563	}
564	else if (ProcessStatus.enmReason == RTPROCEXITREASON_NORMAL)
565	{
566	VBoxServiceVerbose(3, "ControlExec: [PID %u]: Ended with RTPROCEXITREASON_NORMAL (%u)\n",
567	pData->uPID, ProcessStatus.iStatus);
568
569	uStatus = PROC_STS_TEN;
570	uFlags = ProcessStatus.iStatus;
571	}
572	else if (ProcessStatus.enmReason == RTPROCEXITREASON_SIGNAL)
573	{
574	VBoxServiceVerbose(3, "ControlExec: [PID %u]: Ended with RTPROCEXITREASON_SIGNAL (%u)\n",
575	pData->uPID, ProcessStatus.iStatus);
576
577	uStatus = PROC_STS_TES;
578	uFlags = ProcessStatus.iStatus;
579	}
580	else if (ProcessStatus.enmReason == RTPROCEXITREASON_ABEND)
581	{
582	VBoxServiceVerbose(3, "ControlExec: [PID %u]: Ended with RTPROCEXITREASON_ABEND (%u)\n",
583	pData->uPID, ProcessStatus.iStatus);
584
585	uStatus = PROC_STS_TEA;
586	uFlags = ProcessStatus.iStatus;
587	}
588	else
589	VBoxServiceError("ControlExec: [PID %u]: Reached an undefined state!\n",
590	pData->uPID);
591
592	VBoxServiceVerbose(3, "ControlExec: [PID %u]: Ended, CID=%u, Status=%u, Flags=%u\n",
593	pData->uPID, pThread->uContextID, uStatus, uFlags);
594	rc = VbglR3GuestCtrlExecReportStatus(pThread->uClientID, pThread->uContextID,
595	pData->uPID, uStatus, uFlags,
596	NULL /* pvData /, 0 / cbData */);
597	VBoxServiceVerbose(3, "ControlExec: [PID %u]: Process loop ended with rc=%Rrc\n",
598	pData->uPID, rc);
599
600	/*
601	* Dump stdout for debugging purposes.
602	* Only do that on very high verbosity (5+).
603	*/
604	if (g_cVerbosity >= 5)
605	{
606	VBoxServiceVerbose(5, "[PID %u]: StdOut:\n", pData->uPID);
607
608	uint8_t szBuf[_64K];
609	uint32_t cbOffset = 0;
610	uint32_t cbRead, cbLeft;
611	while ( RT_SUCCESS(VBoxServicePipeBufPeek(&pData->stdOut, szBuf, sizeof(szBuf),
612	cbOffset, &cbRead, &cbLeft))
613	&& cbRead)
614	{
615	cbOffset += cbRead;
616	if (!cbLeft)
617	break;
618	}
619
620	VBoxServiceVerbose(5, "\n");
621	}
622	}
623	else
624	VBoxServiceError("ControlExec: [PID %u]: Loop failed with rc=%Rrc\n",
625	pData->uPID, rc);
626	return rc;
627	}
628
629
630	/**
631	* Sets up the redirection / pipe / nothing for one of the standard handles.
632	*
633	* @returns IPRT status code. No client replies made.
634	* @param fd Which standard handle it is (0 == stdin, 1 ==
635	* stdout, 2 == stderr).
636	* @param ph The generic handle that @a pph may be set
637	* pointing to. Always set.
638	* @param pph Pointer to the RTProcCreateExec argument.
639	* Always set.
640	* @param phPipe Where to return the end of the pipe that we
641	* should service. Always set.
642	*/
643	static int VBoxServiceControlExecSetupPipe(int fd, PRTHANDLE ph, PRTHANDLE *pph, PRTPIPE phPipe)
644	{
645	AssertPtrReturn(ph, VERR_INVALID_PARAMETER);
646	AssertPtrReturn(pph, VERR_INVALID_PARAMETER);
647	AssertPtrReturn(phPipe, VERR_INVALID_PARAMETER);
648
649	ph->enmType = RTHANDLETYPE_PIPE;
650	ph->u.hPipe = NIL_RTPIPE;
651	*pph = NULL;
652	*phPipe = NIL_RTPIPE;
653
654	int rc;
655
656	/*
657	* Setup a pipe for forwarding to/from the client.
658	* The ph union struct will be filled with a pipe read/write handle
659	* to represent the "other" end to phPipe.
660	*/
661	if (fd == 0) /* stdin? */
662	{
663	/* Connect a wrtie pipe specified by phPipe to stdin. */
664	rc = RTPipeCreate(&ph->u.hPipe, phPipe, RTPIPE_C_INHERIT_READ);
665	}
666	else /* stdout or stderr? */
667	{
668	/* Connect a read pipe specified by phPipe to stdout or stderr. */
669	rc = RTPipeCreate(phPipe, &ph->u.hPipe, RTPIPE_C_INHERIT_WRITE);
670	}
671	if (RT_FAILURE(rc))
672	return rc;
673	ph->enmType = RTHANDLETYPE_PIPE;
674	*pph = ph;
675
676	return rc;
677	}
678
679
680	/**
681	* Expands a file name / path to its real content. This only works on Windows
682	* for now (e.g. translating "%TEMP%\foo.exe" to "C:\Windows\Temp" when starting
683	* with system / administrative rights).
684	*
685	* @return IPRT status code.
686	* @param pszPath Path to resolve.
687	* @param pszExpanded Pointer to string to store the resolved path in.
688	* @param cbExpanded Size (in bytes) of string to store the resolved path.
689	*/
690	static int VBoxServiceControlExecMakeFullPath(const char pszPath, char pszExpanded, size_t cbExpanded)
691	{
692	int rc = VINF_SUCCESS;
693	#ifdef RT_OS_WINDOWS
694	if (!ExpandEnvironmentStrings(pszPath, pszExpanded, cbExpanded))
695	rc = RTErrConvertFromWin32(GetLastError());
696	#else
697	/* No expansion for non-Windows yet. */
698	rc = RTStrCopy(pszExpanded, cbExpanded, pszPath);
699	#endif
700	#ifdef DEBUG
701	VBoxServiceVerbose(3, "ControlExec: VBoxServiceControlExecMakeFullPath: %s -> %s\n",
702	pszPath, pszExpanded);
703	#endif
704	return rc;
705	}
706
707
708	/**
709	* Resolves the full path of a specified executable name. This function also
710	* resolves internal VBoxService tools to its appropriate executable path + name.
711	*
712	* @return IPRT status code.
713	* @param pszFileName File name to resovle.
714	* @param pszResolved Pointer to a string where the resolved file name will be stored.
715	* @param cbResolved Size (in bytes) of resolved file name string.
716	*/
717	static int VBoxServiceControlExecResolveExecutable(const char pszFileName, char pszResolved, size_t cbResolved)
718	{
719	int rc = VINF_SUCCESS;
720
721	/* Search the path of our executable. */
722	char szVBoxService[RTPATH_MAX];
723	if (RTProcGetExecutablePath(szVBoxService, sizeof(szVBoxService)))
724	{
725	char *pszExecResolved = NULL;
726	if ( (g_pszProgName && RTStrICmp(pszFileName, g_pszProgName) == 0)
727	\|\| !RTStrICmp(pszFileName, VBOXSERVICE_NAME))
728	{
729	/* We just want to execute VBoxService (no toolbox). */
730	pszExecResolved = RTStrDup(szVBoxService);
731	}
732	else /* Nothing to resolve, copy original. */
733	pszExecResolved = RTStrDup(pszFileName);
734	AssertPtr(pszExecResolved);
735
736	rc = VBoxServiceControlExecMakeFullPath(pszExecResolved, pszResolved, cbResolved);
737	#ifdef DEBUG
738	VBoxServiceVerbose(3, "ControlExec: VBoxServiceControlExecResolveExecutable: %s -> %s\n",
739	pszFileName, pszResolved);
740	#endif
741	RTStrFree(pszExecResolved);
742	}
743	return rc;
744	}
745
746
747	/**
748	* Constructs the argv command line by resolving environment variables
749	* and relative paths.
750	*
751	* @return IPRT status code.
752	* @param pszArgv0 First argument (argv0), either original or modified version.
753	* @param papszArgs Original argv command line from the host, starting at argv[1].
754	* @param ppapszArgv Pointer to a pointer with the new argv command line.
755	* Needs to be freed with RTGetOptArgvFree.
756	*/
757	static int VBoxServiceControlExecPrepareArgv(const char *pszArgv0,
758	const char * const papszArgs, char **ppapszArgv)
759	{
760	/** @todo RTGetOptArgvToString converts to MSC quoted string, while
761	* RTGetOptArgvFromString takes bourne shell according to the docs...
762	* Actually, converting to and from here is a very roundabout way of prepending
763	* an entry (pszFilename) to an array (ppapszArgv). /
764	int rc = VINF_SUCCESS;
765	char *pszNewArgs = NULL;
766	if (pszArgv0)
767	rc = RTStrAAppend(&pszNewArgs, pszArgv0);
768	if ( RT_SUCCESS(rc)
769	&& papszArgs)
770
771	{
772	char *pszArgs;
773	rc = RTGetOptArgvToString(&pszArgs, papszArgs,
774	RTGETOPTARGV_CNV_QUOTE_MS_CRT); /* RTGETOPTARGV_CNV_QUOTE_BOURNE_SH */
775	if (RT_SUCCESS(rc))
776	{
777	rc = RTStrAAppend(&pszNewArgs, " ");
778	if (RT_SUCCESS(rc))
779	rc = RTStrAAppend(&pszNewArgs, pszArgs);
780	}
781	}
782
783	if (RT_SUCCESS(rc))
784	{
785	int iNumArgsIgnored;
786	rc = RTGetOptArgvFromString(ppapszArgv, &iNumArgsIgnored,
787	pszNewArgs ? pszNewArgs : "", NULL /* Use standard separators. */);
788	}
789
790	if (pszNewArgs)
791	RTStrFree(pszNewArgs);
792	return rc;
793	}
794
795
796	/**
797	* Helper function to create/start a process on the guest.
798	*
799	* @return IPRT status code.
800	* @param pszExec Full qualified path of process to start (without arguments).
801	* @param papszArgs Pointer to array of command line arguments.
802	* @param hEnv Handle to environment block to use.
803	* @param fFlags Process execution flags.
804	* @param phStdIn Handle for the process' stdin pipe.
805	* @param phStdOut Handle for the process' stdout pipe.
806	* @param phStdErr Handle for the process' stderr pipe.
807	* @param pszAsUser User name (account) to start the process under.
808	* @param pszPassword Password of the specified user.
809	* @param phProcess Pointer which will receive the process handle after
810	* successful process start.
811	*/
812	static int VBoxServiceControlExecCreateProcess(const char pszExec, const char const *papszArgs, RTENV hEnv, uint32_t fFlags,
813	PCRTHANDLE phStdIn, PCRTHANDLE phStdOut, PCRTHANDLE phStdErr, const char *pszAsUser,
814	const char *pszPassword, PRTPROCESS phProcess)
815	{
816	AssertPtrReturn(pszExec, VERR_INVALID_PARAMETER);
817	AssertPtrReturn(papszArgs, VERR_INVALID_PARAMETER);
818	AssertPtrReturn(phProcess, VERR_INVALID_PARAMETER);
819
820	int rc = VINF_SUCCESS;
821	char szExecExp[RTPATH_MAX];
822	#ifdef RT_OS_WINDOWS
823	/*
824	* If sysprep should be executed do this in the context of VBoxService, which
825	* (usually, if started by SCM) has administrator rights. Because of that a UI
826	* won't be shown (doesn't have a desktop).
827	*/
828	if (RTStrICmp(pszExec, "sysprep") == 0)
829	{
830	/* Use a predefined sysprep path as default. */
831	char szSysprepCmd[RTPATH_MAX] = "C:\\sysprep\\sysprep.exe";
832
833	/*
834	* On Windows Vista (and up) sysprep is located in "system32\\sysprep\\sysprep.exe",
835	* so detect the OS and use a different path.
836	*/
837	OSVERSIONINFOEX OSInfoEx;
838	RT_ZERO(OSInfoEx);
839	OSInfoEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
840	if ( GetVersionEx((LPOSVERSIONINFO) &OSInfoEx)
841	&& OSInfoEx.dwPlatformId == VER_PLATFORM_WIN32_NT
842	&& OSInfoEx.dwMajorVersion >= 6 /* Vista or later */)
843	{
844	rc = RTEnvGetEx(RTENV_DEFAULT, "windir", szSysprepCmd, sizeof(szSysprepCmd), NULL);
845	if (RT_SUCCESS(rc))
846	rc = RTPathAppend(szSysprepCmd, sizeof(szSysprepCmd), "system32\\sysprep\\sysprep.exe");
847	}
848
849	if (RT_SUCCESS(rc))
850	{
851	char **papszArgsExp;
852	rc = VBoxServiceControlExecPrepareArgv(szSysprepCmd /* argv0 */, papszArgs, &papszArgsExp);
853	if (RT_SUCCESS(rc))
854	{
855	rc = RTProcCreateEx(szSysprepCmd, papszArgsExp, hEnv, 0 /* fFlags */,
856	phStdIn, phStdOut, phStdErr, NULL /* pszAsUser */,
857	NULL /* pszPassword */, phProcess);
858	}
859	RTGetOptArgvFree(papszArgsExp);
860	}
861	return rc;
862	}
863	#endif /* RT_OS_WINDOWS */
864
865	#ifdef VBOXSERVICE_TOOLBOX
866	if (RTStrStr(pszExec, "vbox_") == pszExec)
867	{
868	/* We want to use the internal toolbox (all internal
869	* tools are starting with "vbox_" (e.g. "vbox_cat"). */
870	rc = VBoxServiceControlExecResolveExecutable(VBOXSERVICE_NAME, szExecExp, sizeof(szExecExp));
871	}
872	else
873	{
874	#endif
875	/*
876	* Do the environment variables expansion on executable and arguments.
877	*/
878	rc = VBoxServiceControlExecResolveExecutable(pszExec, szExecExp, sizeof(szExecExp));
879	#ifdef VBOXSERVICE_TOOLBOX
880	}
881	#endif
882	if (RT_SUCCESS(rc))
883	{
884	char **papszArgsExp;
885	rc = VBoxServiceControlExecPrepareArgv(pszExec /* Always use the unmodified executable name as argv0. */,
886	papszArgs /* Append the rest of the argument vector (if any). */, &papszArgsExp);
887	if (RT_SUCCESS(rc))
888	{
889	uint32_t uProcFlags = 0;
890	if (fFlags)
891	{
892	/* Process Main flag "ExecuteProcessFlag_Hidden". */
893	if (fFlags & RT_BIT(2))
894	uProcFlags = RTPROC_FLAGS_HIDDEN;
895	/* Process Main flag "ExecuteProcessFlag_NoProfile". */
896	if (fFlags & RT_BIT(3))
897	uProcFlags = RTPROC_FLAGS_NO_PROFILE;
898	}
899
900	/* If no user name specified run with current credentials (e.g.
901	* full service/system rights). This is prohibited via official Main API!
902	*
903	* Otherwise use the RTPROC_FLAGS_SERVICE to use some special authentication
904	* code (at least on Windows) for running processes as different users
905	* started from our system service. */
906	if (*pszAsUser)
907	uProcFlags \|= RTPROC_FLAGS_SERVICE;
908	#ifdef DEBUG
909	VBoxServiceVerbose(3, "ControlExec: Command: %s\n", szExecExp);
910	for (size_t i = 0; papszArgsExp[i]; i++)
911	VBoxServiceVerbose(3, "ControlExec:\targv[%ld]: %s\n", i, papszArgsExp[i]);
912	#endif
913	/* Do normal execution. */
914	rc = RTProcCreateEx(szExecExp, papszArgsExp, hEnv, uProcFlags,
915	phStdIn, phStdOut, phStdErr,
916	*pszAsUser ? pszAsUser : NULL,
917	*pszPassword ? pszPassword : NULL,
918	phProcess);
919	RTGetOptArgvFree(papszArgsExp);
920	}
921	}
922	return rc;
923	}
924
925	/**
926	* The actual worker routine (lopp) for a started guest process.
927	*
928	* @return IPRT status code.
929	* @param PVBOXSERVICECTRLTHREAD Thread data associated with a started process.
930	*/
931	static DECLCALLBACK(int) VBoxServiceControlExecProcessWorker(PVBOXSERVICECTRLTHREAD pThread)
932	{
933	AssertPtr(pThread);
934	PVBOXSERVICECTRLTHREADDATAEXEC pData = (PVBOXSERVICECTRLTHREADDATAEXEC)pThread->pvData;
935	AssertPtr(pData);
936
937	VBoxServiceVerbose(3, "ControlExec: Thread of process \"%s\" started\n", pData->pszCmd);
938
939	int rc = VbglR3GuestCtrlConnect(&pThread->uClientID);
940	if (RT_FAILURE(rc))
941	{
942	VBoxServiceError("ControlExec: Thread failed to connect to the guest control service, aborted! Error: %Rrc\n", rc);
943	RTThreadUserSignal(RTThreadSelf());
944	return rc;
945	}
946
947	bool fSignalled = false; /* Indicator whether we signalled the thread user event already. */
948
949	/*
950	* Create the environment.
951	*/
952	RTENV hEnv;
953	rc = RTEnvClone(&hEnv, RTENV_DEFAULT);
954	if (RT_SUCCESS(rc))
955	{
956	size_t i;
957	for (i = 0; i < pData->uNumEnvVars && pData->papszEnv; i++)
958	{
959	rc = RTEnvPutEx(hEnv, pData->papszEnv[i]);
960	if (RT_FAILURE(rc))
961	break;
962	}
963	if (RT_SUCCESS(rc))
964	{
965	/*
966	* Setup the redirection of the standard stuff.
967	*/
968	/** @todo consider supporting: gcc stuff.c >file 2>&1. */
969	RTHANDLE hStdIn;
970	PRTHANDLE phStdIn;
971	rc = VBoxServiceControlExecSetupPipe(0 /STDIN_FILENO/, &hStdIn, &phStdIn, &pData->pipeStdInW);
972	if (RT_SUCCESS(rc))
973	{
974	RTHANDLE hStdOut;
975	PRTHANDLE phStdOut;
976	RTPIPE hStdOutR;
977	rc = VBoxServiceControlExecSetupPipe(1 /STDOUT_FILENO/, &hStdOut, &phStdOut, &hStdOutR);
978	if (RT_SUCCESS(rc))
979	{
980	RTHANDLE hStdErr;
981	PRTHANDLE phStdErr;
982	RTPIPE hStdErrR;
983	rc = VBoxServiceControlExecSetupPipe(2 /STDERR_FILENO/, &hStdErr, &phStdErr, &hStdErrR);
984	if (RT_SUCCESS(rc))
985	{
986	/*
987	* Create a poll set for the pipes and let the
988	* transport layer add stuff to it as well.
989	*/
990	RTPOLLSET hPollSet;
991	rc = RTPollSetCreate(&hPollSet);
992	if (RT_SUCCESS(rc))
993	{
994	rc = RTPollSetAddPipe(hPollSet, pData->pipeStdInW, RTPOLL_EVT_ERROR, VBOXSERVICECTRLPIPEID_STDIN_ERROR);
995	if (RT_SUCCESS(rc))
996	rc = RTPollSetAddPipe(hPollSet, hStdOutR, RTPOLL_EVT_READ \| RTPOLL_EVT_ERROR, VBOXSERVICECTRLPIPEID_STDOUT);
997	if (RT_SUCCESS(rc))
998	rc = RTPollSetAddPipe(hPollSet, hStdErrR, RTPOLL_EVT_READ \| RTPOLL_EVT_ERROR, VBOXSERVICECTRLPIPEID_STDERR);
999	if (RT_SUCCESS(rc))
1000	rc = RTPollSetAddPipe(hPollSet, pData->pipeStdInW, RTPOLL_EVT_WRITE, VBOXSERVICECTRLPIPEID_STDIN_WRITABLE);
1001	if (RT_SUCCESS(rc))
1002	rc = RTPollSetAddPipe(hPollSet, pData->stdIn.hNotificationPipeR, RTPOLL_EVT_READ, VBOXSERVICECTRLPIPEID_STDIN_INPUT_NOTIFY);
1003	if (RT_SUCCESS(rc))
1004	{
1005	RTPROCESS hProcess;
1006	rc = VBoxServiceControlExecCreateProcess(pData->pszCmd, pData->papszArgs, hEnv, pData->uFlags,
1007	phStdIn, phStdOut, phStdErr,
1008	pData->pszUser, pData->pszPassword,
1009	&hProcess);
1010	if (RT_FAILURE(rc))
1011	VBoxServiceError("ControlExec: Error starting process, rc=%Rrc\n", rc);
1012	/*
1013	* Tell the control thread that it can continue
1014	* spawning services. This needs to be done after the new
1015	* process has been started because otherwise signal handling
1016	* on (Open) Solaris does not work correctly (see #5068).
1017	*/
1018	int rc2 = RTThreadUserSignal(RTThreadSelf());
1019	if (RT_FAILURE(rc2))
1020	rc = rc2;
1021	fSignalled = true;
1022
1023	if (RT_SUCCESS(rc))
1024	{
1025	/*
1026	* Close the child ends of any pipes and redirected files.
1027	*/
1028	rc2 = RTHandleClose(phStdIn); AssertRC(rc2);
1029	phStdIn = NULL;
1030	rc2 = RTHandleClose(phStdOut); AssertRC(rc2);
1031	phStdOut = NULL;
1032	rc2 = RTHandleClose(phStdErr); AssertRC(rc2);
1033	phStdErr = NULL;
1034
1035	/* Enter the process loop. */
1036	rc = VBoxServiceControlExecProcLoop(pThread,
1037	hProcess, pData->uTimeLimitMS, hPollSet,
1038	&pData->pipeStdInW, &hStdOutR, &hStdErrR);
1039
1040	/*
1041	* The handles that are no longer in the set have
1042	* been closed by the above call in order to prevent
1043	* the guest from getting stuck accessing them.
1044	* So, NIL the handles to avoid closing them again.
1045	*/
1046	if (RT_FAILURE(RTPollSetQueryHandle(hPollSet, VBOXSERVICECTRLPIPEID_STDIN_WRITABLE, NULL)))
1047	pData->pipeStdInW = NIL_RTPIPE;
1048	if (RT_FAILURE(RTPollSetQueryHandle(hPollSet, VBOXSERVICECTRLPIPEID_STDIN_INPUT_NOTIFY, NULL)))
1049	pData->stdIn.hNotificationPipeR = NIL_RTPIPE;
1050	if (RT_FAILURE(RTPollSetQueryHandle(hPollSet, VBOXSERVICECTRLPIPEID_STDOUT, NULL)))
1051	hStdOutR = NIL_RTPIPE;
1052	if (RT_FAILURE(RTPollSetQueryHandle(hPollSet, VBOXSERVICECTRLPIPEID_STDERR, NULL)))
1053	hStdErrR = NIL_RTPIPE;
1054	}
1055	else /* Something went wrong; report error! */
1056	{
1057	VBoxServiceError("ControlExec: Could not start process '%s' (CID: %u)! Error: %Rrc\n",
1058	pData->pszCmd, pThread->uContextID, rc);
1059
1060	rc2 = VbglR3GuestCtrlExecReportStatus(pThread->uClientID, pThread->uContextID, pData->uPID,
1061	PROC_STS_ERROR, rc,
1062	NULL /* pvData /, 0 / cbData */);
1063	if (RT_FAILURE(rc2))
1064	VBoxServiceError("ControlExec: Could not report process start error! Error: %Rrc (process error %Rrc)\n",
1065	rc2, rc);
1066	}
1067	}
1068	RTPollSetDestroy(hPollSet);
1069	RTPipeClose(pData->stdIn.hNotificationPipeR);
1070	}
1071	RTPipeClose(hStdErrR);
1072	RTHandleClose(phStdErr);
1073	}
1074	RTPipeClose(hStdOutR);
1075	RTHandleClose(phStdOut);
1076	}
1077	RTPipeClose(pData->pipeStdInW);
1078	RTHandleClose(phStdIn);
1079	}
1080	}
1081	RTEnvDestroy(hEnv);
1082	}
1083
1084	VbglR3GuestCtrlDisconnect(pThread->uClientID);
1085	VBoxServiceVerbose(3, "ControlExec: [PID %u]: Thread of process \"%s\" ended with rc=%Rrc\n",
1086	pData->uPID, pData->pszCmd, rc);
1087
1088	/*
1089	* If something went wrong signal the user event so that others don't wait
1090	* forever on this thread.
1091	*/
1092	if (RT_FAILURE(rc) && !fSignalled)
1093	RTThreadUserSignal(RTThreadSelf());
1094	return rc;
1095	}
1096
1097
1098	/**
1099	* Thread main routine for a started process.
1100	*
1101	* @return IPRT status code.
1102	* @param RTTHREAD Pointer to the thread's data.
1103	* @param void* User-supplied argument pointer.
1104	*
1105	*/
1106	static DECLCALLBACK(int) VBoxServiceControlExecThread(RTTHREAD ThreadSelf, void *pvUser)
1107	{
1108	PVBOXSERVICECTRLTHREAD pThread = (VBOXSERVICECTRLTHREAD*)pvUser;
1109	AssertPtr(pThread);
1110	return VBoxServiceControlExecProcessWorker(pThread);
1111	}
1112
1113
1114	/**
1115	* Executes (starts) a process on the guest. This causes a new thread to be created
1116	* so that this function will not block the overall program execution.
1117	*
1118	* @return IPRT status code.
1119	* @param uContextID Context ID to associate the process to start with.
1120	* @param pszCmd Full qualified path of process to start (without arguments).
1121	* @param uFlags Process execution flags.
1122	* @param pszArgs String of arguments to pass to the process to start.
1123	* @param uNumArgs Number of arguments specified in pszArgs.
1124	* @param pszEnv String of environment variables ("FOO=BAR") to pass to the process
1125	* to start.
1126	* @param cbEnv Size (in bytes) of environment variables.
1127	* @param uNumEnvVars Number of environment variables specified in pszEnv.
1128	* @param pszUser User name (account) to start the process under.
1129	* @param pszPassword Password of specified user name (account).
1130	* @param uTimeLimitMS Time limit (in ms) of the process' life time.
1131	*/
1132	int VBoxServiceControlExecProcess(uint32_t uContextID, const char *pszCmd, uint32_t uFlags,
1133	const char *pszArgs, uint32_t uNumArgs,
1134	const char *pszEnv, uint32_t cbEnv, uint32_t uNumEnvVars,
1135	const char pszUser, const char pszPassword, uint32_t uTimeLimitMS)
1136	{
1137	int rc;
1138
1139	PVBOXSERVICECTRLTHREAD pThread = (PVBOXSERVICECTRLTHREAD)RTMemAlloc(sizeof(VBOXSERVICECTRLTHREAD));
1140	if (pThread)
1141	{
1142	rc = VBoxServiceControlExecThreadAlloc(pThread,
1143	uContextID,
1144	pszCmd, uFlags,
1145	pszArgs, uNumArgs,
1146	pszEnv, cbEnv, uNumEnvVars,
1147	pszUser, pszPassword,
1148	uTimeLimitMS);
1149	if (RT_SUCCESS(rc))
1150	{
1151	static uint32_t uCtrlExecThread = 0;
1152	char szThreadName[32];
1153	if (!RTStrPrintf(szThreadName, sizeof(szThreadName), "controlexec%ld", uCtrlExecThread++))
1154	AssertMsgFailed(("Unable to create unique control exec thread name!\n"));
1155
1156	rc = RTThreadCreate(&pThread->Thread, VBoxServiceControlExecThread,
1157	(void )(PVBOXSERVICECTRLTHREAD)pThread, 0,
1158	RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, szThreadName);
1159	if (RT_FAILURE(rc))
1160	{
1161	VBoxServiceError("ControlExec: RTThreadCreate failed, rc=%Rrc\n, pThread=%p\n",
1162	rc, pThread);
1163	}
1164	else
1165	{
1166	VBoxServiceVerbose(4, "ControlExec: Waiting for thread to initialize ...\n");
1167
1168	/* Wait for the thread to initialize. */
1169	RTThreadUserWait(pThread->Thread, 60 * 1000 /* 60 seconds max. */);
1170	if (pThread->fShutdown)
1171	{
1172	VBoxServiceError("ControlExec: Thread for process \"%s\" failed to start!\n", pszCmd);
1173	rc = VERR_GENERAL_FAILURE;
1174	}
1175	else
1176	{
1177	pThread->fStarted = true;
1178	/rc =/ RTListAppend(&g_GuestControlExecThreads, &pThread->Node);
1179	}
1180	}
1181
1182	if (RT_FAILURE(rc))
1183	VBoxServiceControlExecThreadDestroy((PVBOXSERVICECTRLTHREADDATAEXEC)pThread->pvData);
1184	}
1185	if (RT_FAILURE(rc))
1186	RTMemFree(pThread);
1187	}
1188	else
1189	rc = VERR_NO_MEMORY;
1190	return rc;
1191	}
1192
1193
1194	/**
1195	* Handles starting processes on the guest.
1196	*
1197	* @returns IPRT status code.
1198	* @param u32ClientId The HGCM client session ID.
1199	* @param uNumParms The number of parameters the host is offering.
1200	*/
1201	int VBoxServiceControlExecHandleCmdStartProcess(uint32_t u32ClientId, uint32_t uNumParms)
1202	{
1203	uint32_t uContextID;
1204	char szCmd[_1K];
1205	uint32_t uFlags;
1206	char szArgs[_1K];
1207	uint32_t uNumArgs;
1208	char szEnv[_64K];
1209	uint32_t cbEnv = sizeof(szEnv);
1210	uint32_t uNumEnvVars;
1211	char szUser[128];
1212	char szPassword[128];
1213	uint32_t uTimeLimitMS;
1214
1215	#if 0 /* for valgrind */
1216	RT_ZERO(szCmd);
1217	RT_ZERO(szArgs);
1218	RT_ZERO(szEnv);
1219	RT_ZERO(szUser);
1220	RT_ZERO(szPassword);
1221	#endif
1222
1223	if (uNumParms != 11)
1224	return VERR_INVALID_PARAMETER;
1225
1226	int rc = VbglR3GuestCtrlExecGetHostCmd(u32ClientId,
1227	uNumParms,
1228	&uContextID,
1229	/* Command */
1230	szCmd, sizeof(szCmd),
1231	/* Flags */
1232	&uFlags,
1233	/* Arguments */
1234	szArgs, sizeof(szArgs), &uNumArgs,
1235	/* Environment */
1236	szEnv, &cbEnv, &uNumEnvVars,
1237	/* Credentials */
1238	szUser, sizeof(szUser),
1239	szPassword, sizeof(szPassword),
1240	/* Timelimit */
1241	&uTimeLimitMS);
1242	#ifdef DEBUG
1243	VBoxServiceVerbose(3, "ControlExec: Start process szCmd=%s, uFlags=%u, szArgs=%s, szEnv=%s, szUser=%s, szPW=%s, uTimeout=%u\n",
1244	szCmd, uFlags, uNumArgs ? szArgs : "<None>", uNumEnvVars ? szEnv : "<None>", szUser, szPassword, uTimeLimitMS);
1245	#endif
1246	if (RT_SUCCESS(rc))
1247	{
1248	rc = VBoxServiceControlExecProcess(uContextID, szCmd, uFlags, szArgs, uNumArgs,
1249	szEnv, cbEnv, uNumEnvVars,
1250	szUser, szPassword, uTimeLimitMS);
1251	}
1252	else
1253	VBoxServiceError("ControlExec: Failed to retrieve exec start command! Error: %Rrc\n", rc);
1254	return rc;
1255	}
1256
1257
1258	/**
1259	* Handles input for a started process by copying the received data into its
1260	* stdin pipe.
1261	*
1262	* @returns IPRT status code.
1263	* @param u32ClientId The HGCM client session ID.
1264	* @param uNumParms The number of parameters the host is offering.
1265	* @param cMaxBufSize The maximum buffer size for retrieving the input data.
1266	*/
1267	int VBoxServiceControlExecHandleCmdSetInput(uint32_t u32ClientId, uint32_t uNumParms, size_t cbMaxBufSize)
1268	{
1269	uint32_t uContextID;
1270	uint32_t uPID;
1271	uint32_t uFlags;
1272	uint32_t cbSize;
1273
1274	AssertReturn(RT_IS_POWER_OF_TWO(cbMaxBufSize), VERR_INVALID_PARAMETER);
1275	uint8_t pabBuffer = (uint8_t)RTMemAlloc(cbMaxBufSize);
1276	AssertPtrReturn(pabBuffer, VERR_NO_MEMORY);
1277
1278	uint32_t uStatus = INPUT_STS_UNDEFINED; /* Status sent back to the host. */
1279	uint32_t cbWritten = 0; /* Number of bytes written to the guest. */
1280
1281	/*
1282	* Ask the host for the input data.
1283	*/
1284	int rc = VbglR3GuestCtrlExecGetHostCmdInput(u32ClientId, uNumParms,
1285	&uContextID, &uPID, &uFlags,
1286	pabBuffer, cbMaxBufSize, &cbSize);
1287	if (RT_FAILURE(rc))
1288	{
1289	VBoxServiceError("ControlExec: [PID %u]: Failed to retrieve exec input command! Error: %Rrc\n",
1290	uPID, rc);
1291	}
1292	else if (cbSize > cbMaxBufSize)
1293	{
1294	VBoxServiceError("ControlExec: [PID %u]: Maximum input buffer size is too small! cbSize=%u, cbMaxBufSize=%u\n",
1295	uPID, cbSize, cbMaxBufSize);
1296	rc = VERR_INVALID_PARAMETER;
1297	}
1298	else
1299	{
1300	/*
1301	* Is this the last input block we need to deliver? Then let the pipe know ...
1302	*/
1303	bool fPendingClose = false;
1304	if (uFlags & INPUT_FLAG_EOF)
1305	{
1306	fPendingClose = true;
1307	VBoxServiceVerbose(4, "ControlExec: [PID %u]: Got last input block of size %u ...\n",
1308	uPID, cbSize);
1309	}
1310
1311	rc = VBoxServiceControlExecThreadSetInput(uPID, fPendingClose, pabBuffer,
1312	cbSize, &cbWritten);
1313	VBoxServiceVerbose(4, "ControlExec: [PID %u]: Written input, rc=%Rrc, uFlags=0x%x, fPendingClose=%d, cbSize=%u, cbWritten=%u\n",
1314	uPID, rc, uFlags, fPendingClose, cbSize, cbWritten);
1315	if (RT_SUCCESS(rc))
1316	{
1317	if (cbWritten \|\| !cbSize) /* Did we write something or was there anything to write at all? */
1318	{
1319	uStatus = INPUT_STS_WRITTEN;
1320	uFlags = 0;
1321	}
1322	}
1323	else
1324	{
1325	if (rc == VERR_BAD_PIPE)
1326	uStatus = INPUT_STS_TERMINATED;
1327	else if (rc == VERR_BUFFER_OVERFLOW)
1328	uStatus = INPUT_STS_OVERFLOW;
1329	}
1330	}
1331	RTMemFree(pabBuffer);
1332
1333	/*
1334	* If there was an error and we did not set the host status
1335	* yet, then do it now.
1336	*/
1337	if ( RT_FAILURE(rc)
1338	&& uStatus == INPUT_STS_UNDEFINED)
1339	{
1340	uStatus = INPUT_STS_ERROR;
1341	uFlags = rc;
1342	}
1343	Assert(uStatus > INPUT_STS_UNDEFINED);
1344
1345	VBoxServiceVerbose(3, "ControlExec: [PID %u]: Input processed, uStatus=%u, uFlags=0x%x, cbWritten=%u\n",
1346	uPID, uStatus, uFlags, cbWritten);
1347
1348	/* Note: Since the context ID is unique the request has to be completed here,
1349	* regardless whether we got data or not! Otherwise the progress object
1350	* on the host never will get completed! */
1351	rc = VbglR3GuestCtrlExecReportStatusIn(u32ClientId, uContextID, uPID,
1352	uStatus, uFlags, (uint32_t)cbWritten);
1353
1354	if (RT_FAILURE(rc))
1355	VBoxServiceError("ControlExec: [PID %u]: Failed to report input status! Error: %Rrc\n",
1356	uPID, rc);
1357	return rc;
1358	}
1359
1360
1361	/**
1362	* Handles the guest control output command.
1363	*
1364	* @return IPRT status code.
1365	* @param u32ClientId idClient The HGCM client session ID.
1366	* @param uNumParms cParms The number of parameters the host is
1367	* offering.
1368	*/
1369	int VBoxServiceControlExecHandleCmdGetOutput(uint32_t u32ClientId, uint32_t uNumParms)
1370	{
1371	uint32_t uContextID;
1372	uint32_t uPID;
1373	uint32_t uHandleID;
1374	uint32_t uFlags;
1375
1376	int rc = VbglR3GuestCtrlExecGetHostCmdOutput(u32ClientId, uNumParms,
1377	&uContextID, &uPID, &uHandleID, &uFlags);
1378	if (RT_SUCCESS(rc))
1379	{
1380	uint32_t cbRead = 0;
1381	uint8_t pBuf = (uint8_t)RTMemAlloc(_64K);
1382	if (pBuf)
1383	{
1384	rc = VBoxServiceControlExecThreadGetOutput(uPID, uHandleID, RT_INDEFINITE_WAIT /* Timeout */,
1385	pBuf, _64K /* cbSize */, &cbRead);
1386	if (RT_SUCCESS(rc))
1387	VBoxServiceVerbose(3, "ControlExec: [PID %u]: Got output, cbRead=%u, uHandle=%u, uFlags=%u\n",
1388	uPID, cbRead, uHandleID, uFlags);
1389	else
1390	VBoxServiceError("ControlExec: [PID %u]: Failed to retrieve output, uHandle=%u, rc=%Rrc\n",
1391	uPID, uHandleID, rc);
1392
1393	/* Note: Since the context ID is unique the request has to be completed here,
1394	* regardless whether we got data or not! Otherwise the progress object
1395	* on the host never will get completed! */
1396	/* cbRead now contains actual size. */
1397	int rc2 = VbglR3GuestCtrlExecSendOut(u32ClientId, uContextID, uPID, uHandleID, uFlags,
1398	pBuf, cbRead);
1399	if (RT_SUCCESS(rc))
1400	rc = rc2;
1401	RTMemFree(pBuf);
1402	}
1403	else
1404	rc = VERR_NO_MEMORY;
1405	}
1406
1407	if (RT_FAILURE(rc))
1408	VBoxServiceError("ControlExec: [PID %u]: Failed to handle output command! Error: %Rrc\n",
1409	uPID, rc);
1410	return rc;
1411	}
1412

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

source: vbox/trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControlExec.cpp@ 38115

Download in other formats: