GuestProcessImpl.cpp@ 67414

Last change on this file since 67414 was 65120, checked in by vboxsync, 8 years ago
Main: doxygen fixes
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 79.6 KB

Line
1	/* $Id: GuestProcessImpl.cpp 65120 2017-01-04 17:10:35Z vboxsync $ */
2	/** @file
3	* VirtualBox Main - Guest process handling.
4	*/
5
6	/*
7	* Copyright (C) 2012-2016 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	* Locking rules:
20	* - When the main dispatcher (callbackDispatcher) is called it takes the
21	* WriteLock while dispatching to the various on* methods.
22	* - All other outer functions (accessible by Main) must not own a lock
23	* while waiting for a callback or for an event.
24	* - Only keep Read/WriteLocks as short as possible and only when necessary.
25	*/
26
27
28	/*********************************************************************************************************************************
29	* Header Files *
30	*********************************************************************************************************************************/
31	#ifndef VBOX_WITH_GUEST_CONTROL
32	# error "VBOX_WITH_GUEST_CONTROL must defined in this file"
33	#endif
34	#include "GuestProcessImpl.h"
35	#include "GuestSessionImpl.h"
36	#include "GuestCtrlImplPrivate.h"
37	#include "ConsoleImpl.h"
38	#include "VirtualBoxErrorInfoImpl.h"
39
40	#include "Global.h"
41	#include "AutoCaller.h"
42	#include "VBoxEvents.h"
43	#include "ThreadTask.h"
44
45	#include <memory> /* For auto_ptr. */
46
47	#include <iprt/asm.h>
48	#include <iprt/cpp/utils.h> /* For unconst(). */
49	#include <iprt/getopt.h>
50
51	#include <VBox/com/listeners.h>
52
53	#include <VBox/com/array.h>
54
55	#ifdef LOG_GROUP
56	#undef LOG_GROUP
57	#endif
58	#define LOG_GROUP LOG_GROUP_GUEST_CONTROL
59	#include <VBox/log.h>
60
61
62	class GuestProcessTask : public ThreadTask
63	{
64	public:
65
66	GuestProcessTask(GuestProcess *pProcess)
67	: ThreadTask("GenericGuestProcessTask")
68	, mProcess(pProcess)
69	, mRC(VINF_SUCCESS) { }
70
71	virtual ~GuestProcessTask(void) { }
72
73	int i_rc(void) const { return mRC; }
74	bool i_isOk(void) const { return RT_SUCCESS(mRC); }
75	const ComObjPtr<GuestProcess> &i_process(void) const { return mProcess; }
76
77	protected:
78
79	const ComObjPtr<GuestProcess> mProcess;
80	int mRC;
81	};
82
83	class GuestProcessStartTask : public GuestProcessTask
84	{
85	public:
86
87	GuestProcessStartTask(GuestProcess *pProcess)
88	: GuestProcessTask(pProcess)
89	{
90	m_strTaskName = "gctlPrcStart";
91	}
92
93	void handler()
94	{
95	GuestProcess::i_startProcessThreadTask(this);
96	}
97	};
98
99	/**
100	* Internal listener class to serve events in an
101	* active manner, e.g. without polling delays.
102	*/
103	class GuestProcessListener
104	{
105	public:
106
107	GuestProcessListener(void)
108	{
109	}
110
111	virtual ~GuestProcessListener(void)
112	{
113	}
114
115	HRESULT init(GuestProcess *pProcess)
116	{
117	AssertPtrReturn(pProcess, E_POINTER);
118	mProcess = pProcess;
119	return S_OK;
120	}
121
122	void uninit(void)
123	{
124	mProcess = NULL;
125	}
126
127	STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent *aEvent)
128	{
129	switch (aType)
130	{
131	case VBoxEventType_OnGuestProcessStateChanged:
132	case VBoxEventType_OnGuestProcessInputNotify:
133	case VBoxEventType_OnGuestProcessOutput:
134	{
135	AssertPtrReturn(mProcess, E_POINTER);
136	int rc2 = mProcess->signalWaitEvent(aType, aEvent);
137	RT_NOREF(rc2);
138	#ifdef LOG_ENABLED
139	LogFlowThisFunc(("Signalling events of type=%RU32, pProcess=%p resulted in rc=%Rrc\n",
140	aType, &mProcess, rc2));
141	#endif
142	break;
143	}
144
145	default:
146	AssertMsgFailed(("Unhandled event %RU32\n", aType));
147	break;
148	}
149
150	return S_OK;
151	}
152
153	private:
154
155	GuestProcess *mProcess;
156	};
157	typedef ListenerImpl<GuestProcessListener, GuestProcess*> GuestProcessListenerImpl;
158
159	VBOX_LISTENER_DECLARE(GuestProcessListenerImpl)
160
161	// constructor / destructor
162	/////////////////////////////////////////////////////////////////////////////
163
164	DEFINE_EMPTY_CTOR_DTOR(GuestProcess)
165
166	HRESULT GuestProcess::FinalConstruct(void)
167	{
168	LogFlowThisFuncEnter();
169	return BaseFinalConstruct();
170	}
171
172	void GuestProcess::FinalRelease(void)
173	{
174	LogFlowThisFuncEnter();
175	uninit();
176	BaseFinalRelease();
177	LogFlowThisFuncLeave();
178	}
179
180	// public initializer/uninitializer for internal purposes only
181	/////////////////////////////////////////////////////////////////////////////
182
183	int GuestProcess::init(Console aConsole, GuestSession aSession, ULONG aProcessID,
184	const GuestProcessStartupInfo &aProcInfo, const GuestEnvironment *pBaseEnv)
185	{
186	LogFlowThisFunc(("aConsole=%p, aSession=%p, aProcessID=%RU32 pBaseEnv=%p\n",
187	aConsole, aSession, aProcessID, pBaseEnv));
188
189	AssertPtrReturn(aConsole, VERR_INVALID_POINTER);
190	AssertPtrReturn(aSession, VERR_INVALID_POINTER);
191
192	/* Enclose the state transition NotReady->InInit->Ready. */
193	AutoInitSpan autoInitSpan(this);
194	AssertReturn(autoInitSpan.isOk(), VERR_OBJECT_DESTROYED);
195
196	HRESULT hr;
197
198	int vrc = bindToSession(aConsole, aSession, aProcessID /* Object ID */);
199	if (RT_SUCCESS(vrc))
200	{
201	hr = unconst(mEventSource).createObject();
202	if (FAILED(hr))
203	vrc = VERR_NO_MEMORY;
204	else
205	{
206	hr = mEventSource->init();
207	if (FAILED(hr))
208	vrc = VERR_COM_UNEXPECTED;
209	}
210	}
211
212	if (RT_SUCCESS(vrc))
213	{
214	try
215	{
216	GuestProcessListener *pListener = new GuestProcessListener();
217	ComObjPtr<GuestProcessListenerImpl> thisListener;
218	hr = thisListener.createObject();
219	if (SUCCEEDED(hr))
220	hr = thisListener->init(pListener, this);
221
222	if (SUCCEEDED(hr))
223	{
224	com::SafeArray <VBoxEventType_T> eventTypes;
225	eventTypes.push_back(VBoxEventType_OnGuestProcessStateChanged);
226	eventTypes.push_back(VBoxEventType_OnGuestProcessInputNotify);
227	eventTypes.push_back(VBoxEventType_OnGuestProcessOutput);
228	hr = mEventSource->RegisterListener(thisListener,
229	ComSafeArrayAsInParam(eventTypes),
230	TRUE /* Active listener */);
231	if (SUCCEEDED(hr))
232	{
233	vrc = baseInit();
234	if (RT_SUCCESS(vrc))
235	{
236	mLocalListener = thisListener;
237	}
238	}
239	else
240	vrc = VERR_COM_UNEXPECTED;
241	}
242	else
243	vrc = VERR_COM_UNEXPECTED;
244	}
245	catch(std::bad_alloc &)
246	{
247	vrc = VERR_NO_MEMORY;
248	}
249	}
250
251	if (RT_SUCCESS(vrc))
252	{
253	mData.mProcess = aProcInfo;
254	mData.mpSessionBaseEnv = pBaseEnv;
255	if (pBaseEnv)
256	pBaseEnv->retainConst();
257	mData.mExitCode = 0;
258	mData.mPID = 0;
259	mData.mLastError = VINF_SUCCESS;
260	mData.mStatus = ProcessStatus_Undefined;
261	/* Everything else will be set by the actual starting routine. */
262
263	/* Confirm a successful initialization when it's the case. */
264	autoInitSpan.setSucceeded();
265
266	return vrc;
267	}
268
269	autoInitSpan.setFailed();
270	return vrc;
271	}
272
273	/**
274	* Uninitializes the instance.
275	* Called from FinalRelease() or IGuestSession::uninit().
276	*/
277	void GuestProcess::uninit(void)
278	{
279	/* Enclose the state transition Ready->InUninit->NotReady. */
280	AutoUninitSpan autoUninitSpan(this);
281	if (autoUninitSpan.uninitDone())
282	return;
283
284	LogFlowThisFunc(("mExe=%s, PID=%RU32\n", mData.mProcess.mExecutable.c_str(), mData.mPID));
285
286	/* Terminate process if not already done yet. */
287	int guestRc = VINF_SUCCESS;
288	int vrc = i_terminateProcess(30 * 1000, &guestRc); /** @todo Make timeouts configurable. */
289	/* Note: Don't return here yet; first uninit all other stuff in
290	* case of failure. */
291
292	if (mData.mpSessionBaseEnv)
293	{
294	mData.mpSessionBaseEnv->releaseConst();
295	mData.mpSessionBaseEnv = NULL;
296	}
297
298	baseUninit();
299
300	LogFlowThisFunc(("Returning rc=%Rrc, guestRc=%Rrc\n",
301	vrc, guestRc));
302	RT_NOREF_PV(vrc);
303	}
304
305	// implementation of public getters/setters for attributes
306	/////////////////////////////////////////////////////////////////////////////
307	HRESULT GuestProcess::getArguments(std::vector<com::Utf8Str> &aArguments)
308	{
309	LogFlowThisFuncEnter();
310
311	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
312	aArguments = mData.mProcess.mArguments;
313	return S_OK;
314	}
315
316	HRESULT GuestProcess::getEnvironment(std::vector<com::Utf8Str> &aEnvironment)
317	{
318	#ifndef VBOX_WITH_GUEST_CONTROL
319	ReturnComNotImplemented();
320	#else
321	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); /* (Paranoia since both environment objects are immutable.) */
322	HRESULT hrc;
323	if (mData.mpSessionBaseEnv)
324	{
325	int vrc;
326	if (mData.mProcess.mEnvironmentChanges.count() == 0)
327	vrc = mData.mpSessionBaseEnv->queryPutEnvArray(&aEnvironment);
328	else
329	{
330	GuestEnvironment TmpEnv;
331	vrc = TmpEnv.copy(*mData.mpSessionBaseEnv);
332	if (RT_SUCCESS(vrc))
333	{
334	vrc = TmpEnv.applyChanges(mData.mProcess.mEnvironmentChanges);
335	if (RT_SUCCESS(vrc))
336	vrc = TmpEnv.queryPutEnvArray(&aEnvironment);
337	}
338	}
339	hrc = Global::vboxStatusCodeToCOM(vrc);
340	}
341	else
342	hrc = setError(VBOX_E_NOT_SUPPORTED, tr("The base environment feature is not supported by the guest additions"));
343	LogFlowThisFuncLeave();
344	return hrc;
345	#endif
346	}
347
348	HRESULT GuestProcess::getEventSource(ComPtr<IEventSource> &aEventSource)
349	{
350	LogFlowThisFuncEnter();
351
352	// no need to lock - lifetime constant
353	mEventSource.queryInterfaceTo(aEventSource.asOutParam());
354
355	LogFlowThisFuncLeave();
356	return S_OK;
357	}
358
359	HRESULT GuestProcess::getExecutablePath(com::Utf8Str &aExecutablePath)
360	{
361	LogFlowThisFuncEnter();
362
363	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
364
365	aExecutablePath = mData.mProcess.mExecutable;
366
367	return S_OK;
368	}
369
370	HRESULT GuestProcess::getExitCode(LONG *aExitCode)
371	{
372	LogFlowThisFuncEnter();
373
374	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
375
376	*aExitCode = mData.mExitCode;
377
378	return S_OK;
379	}
380
381	HRESULT GuestProcess::getName(com::Utf8Str &aName)
382	{
383	LogFlowThisFuncEnter();
384
385	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
386
387	aName = mData.mProcess.mName;
388
389	return S_OK;
390	}
391
392	HRESULT GuestProcess::getPID(ULONG *aPID)
393	{
394	LogFlowThisFuncEnter();
395
396	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
397
398	*aPID = mData.mPID;
399
400	return S_OK;
401	}
402
403	HRESULT GuestProcess::getStatus(ProcessStatus_T *aStatus)
404	{
405	LogFlowThisFuncEnter();
406
407	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
408
409	*aStatus = mData.mStatus;
410
411	return S_OK;
412	}
413
414	// private methods
415	/////////////////////////////////////////////////////////////////////////////
416
417	int GuestProcess::i_callbackDispatcher(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
418	{
419	AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
420	AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
421	#ifdef DEBUG
422	LogFlowThisFunc(("uPID=%RU32, uContextID=%RU32, uFunction=%RU32, pSvcCb=%p\n",
423	mData.mPID, pCbCtx->uContextID, pCbCtx->uFunction, pSvcCb));
424	#endif
425
426	int vrc;
427	switch (pCbCtx->uFunction)
428	{
429	case GUEST_DISCONNECTED:
430	{
431	vrc = i_onGuestDisconnected(pCbCtx, pSvcCb);
432	break;
433	}
434
435	case GUEST_EXEC_STATUS:
436	{
437	vrc = i_onProcessStatusChange(pCbCtx, pSvcCb);
438	break;
439	}
440
441	case GUEST_EXEC_OUTPUT:
442	{
443	vrc = i_onProcessOutput(pCbCtx, pSvcCb);
444	break;
445	}
446
447	case GUEST_EXEC_INPUT_STATUS:
448	{
449	vrc = i_onProcessInputStatus(pCbCtx, pSvcCb);
450	break;
451	}
452
453	default:
454	/* Silently ignore not implemented functions. */
455	vrc = VERR_NOT_SUPPORTED;
456	break;
457	}
458
459	#ifdef DEBUG
460	LogFlowFuncLeaveRC(vrc);
461	#endif
462	return vrc;
463	}
464
465	/**
466	* Checks if the current assigned PID matches another PID (from a callback).
467	*
468	* In protocol v1 we don't have the possibility to terminate/kill
469	* processes so it can happen that a formerly started process A
470	* (which has the context ID 0 (session=0, process=0, count=0) will
471	* send a delayed message to the host if this process has already
472	* been discarded there and the same context ID was reused by
473	* a process B. Process B in turn then has a different guest PID.
474	*
475	* Note: This also can happen when restoring from a saved state which
476	* had a guest process running.
477	*
478	* @return IPRT status code.
479	* @param uPID PID to check.
480	*/
481	inline int GuestProcess::i_checkPID(uint32_t uPID)
482	{
483	int rc = VINF_SUCCESS;
484
485	/* Was there a PID assigned yet? */
486	if (mData.mPID)
487	{
488	if (RT_UNLIKELY(mData.mPID != uPID))
489	{
490	LogFlowFunc(("Stale guest process (PID=%RU32) sent data to a newly started process (pProcesS=%p, PID=%RU32, status=%RU32)\n",
491	uPID, this, mData.mPID, mData.mStatus));
492	rc = VERR_NOT_FOUND;
493	}
494	}
495
496	return rc;
497	}
498
499	/* static */
500	Utf8Str GuestProcess::i_guestErrorToString(int guestRc)
501	{
502	Utf8Str strError;
503
504	/** @todo pData->u32Flags: int vs. uint32 -- IPRT errors are negative !!! */
505	switch (guestRc)
506	{
507	case VERR_FILE_NOT_FOUND: /* This is the most likely error. */
508	strError += Utf8StrFmt(tr("The specified file was not found on guest"));
509	break;
510
511	case VERR_INVALID_VM_HANDLE:
512	strError += Utf8StrFmt(tr("VMM device is not available (is the VM running?)"));
513	break;
514
515	case VERR_HGCM_SERVICE_NOT_FOUND:
516	strError += Utf8StrFmt(tr("The guest execution service is not available"));
517	break;
518
519	case VERR_PATH_NOT_FOUND:
520	strError += Utf8StrFmt(tr("Could not resolve path to specified file was not found on guest"));
521	break;
522
523	case VERR_BAD_EXE_FORMAT:
524	strError += Utf8StrFmt(tr("The specified file is not an executable format on guest"));
525	break;
526
527	case VERR_AUTHENTICATION_FAILURE:
528	strError += Utf8StrFmt(tr("The specified user was not able to logon on guest"));
529	break;
530
531	case VERR_INVALID_NAME:
532	strError += Utf8StrFmt(tr("The specified file is an invalid name"));
533	break;
534
535	case VERR_TIMEOUT:
536	strError += Utf8StrFmt(tr("The guest did not respond within time"));
537	break;
538
539	case VERR_CANCELLED:
540	strError += Utf8StrFmt(tr("The execution operation was canceled"));
541	break;
542
543	case VERR_PERMISSION_DENIED: /** @todo r=bird: This is probably completely and utterly misleading. VERR_AUTHENTICATION_FAILURE could have this message. */
544	strError += Utf8StrFmt(tr("Invalid user/password credentials"));
545	break;
546
547	case VERR_MAX_PROCS_REACHED:
548	strError += Utf8StrFmt(tr("Maximum number of concurrent guest processes has been reached"));
549	break;
550
551	case VERR_NOT_FOUND:
552	strError += Utf8StrFmt(tr("The guest execution service is not ready (yet)"));
553	break;
554
555	default:
556	strError += Utf8StrFmt("%Rrc", guestRc);
557	break;
558	}
559
560	return strError;
561	}
562
563	/**
564	* Returns @c true if the passed in error code indicates an error which came
565	* from the guest side, or @c false if not.
566	*
567	* @return bool @c true if the passed in error code indicates an error which came
568	* from the guest side, or @c false if not.
569	* @param rc Error code to check.
570	*/
571	/* static */
572	bool GuestProcess::i_isGuestError(int rc)
573	{
574	return ( rc == VERR_GSTCTL_GUEST_ERROR
575	\|\| rc == VWRN_GSTCTL_PROCESS_EXIT_CODE);
576	}
577
578	inline bool GuestProcess::i_isAlive(void)
579	{
580	return ( mData.mStatus == ProcessStatus_Started
581	\|\| mData.mStatus == ProcessStatus_Paused
582	\|\| mData.mStatus == ProcessStatus_Terminating);
583	}
584
585	inline bool GuestProcess::i_hasEnded(void)
586	{
587	return ( mData.mStatus == ProcessStatus_TerminatedNormally
588	\|\| mData.mStatus == ProcessStatus_TerminatedSignal
589	\|\| mData.mStatus == ProcessStatus_TerminatedAbnormally
590	\|\| mData.mStatus == ProcessStatus_TimedOutKilled
591	\|\| mData.mStatus == ProcessStatus_TimedOutAbnormally
592	\|\| mData.mStatus == ProcessStatus_Down
593	\|\| mData.mStatus == ProcessStatus_Error);
594	}
595
596	int GuestProcess::i_onGuestDisconnected(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
597	{
598	AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
599	AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
600
601	int vrc = i_setProcessStatus(ProcessStatus_Down, VINF_SUCCESS);
602
603	LogFlowFuncLeaveRC(vrc);
604	return vrc;
605	}
606
607	int GuestProcess::i_onProcessInputStatus(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
608	{
609	AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
610	AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
611	/* pCallback is optional. */
612
613	if (pSvcCbData->mParms < 5)
614	return VERR_INVALID_PARAMETER;
615
616	CALLBACKDATA_PROC_INPUT dataCb;
617	/* pSvcCb->mpaParms[0] always contains the context ID. */
618	int vrc = pSvcCbData->mpaParms[1].getUInt32(&dataCb.uPID);
619	AssertRCReturn(vrc, vrc);
620	vrc = pSvcCbData->mpaParms[2].getUInt32(&dataCb.uStatus);
621	AssertRCReturn(vrc, vrc);
622	vrc = pSvcCbData->mpaParms[3].getUInt32(&dataCb.uFlags);
623	AssertRCReturn(vrc, vrc);
624	vrc = pSvcCbData->mpaParms[4].getUInt32(&dataCb.uProcessed);
625	AssertRCReturn(vrc, vrc);
626
627	LogFlowThisFunc(("uPID=%RU32, uStatus=%RU32, uFlags=%RI32, cbProcessed=%RU32\n",
628	dataCb.uPID, dataCb.uStatus, dataCb.uFlags, dataCb.uProcessed));
629
630	vrc = i_checkPID(dataCb.uPID);
631	if (RT_SUCCESS(vrc))
632	{
633	ProcessInputStatus_T inputStatus = ProcessInputStatus_Undefined;
634	switch (dataCb.uStatus)
635	{
636	case INPUT_STS_WRITTEN:
637	inputStatus = ProcessInputStatus_Written;
638	break;
639	case INPUT_STS_ERROR:
640	inputStatus = ProcessInputStatus_Broken;
641	break;
642	case INPUT_STS_TERMINATED:
643	inputStatus = ProcessInputStatus_Broken;
644	break;
645	case INPUT_STS_OVERFLOW:
646	inputStatus = ProcessInputStatus_Overflow;
647	break;
648	case INPUT_STS_UNDEFINED:
649	/* Fall through is intentional. */
650	default:
651	AssertMsg(!dataCb.uProcessed, ("Processed data is not 0 in undefined input state\n"));
652	break;
653	}
654
655	if (inputStatus != ProcessInputStatus_Undefined)
656	{
657	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
658
659	/* Copy over necessary data before releasing lock again. */
660	uint32_t uPID = mData.mPID;
661	/** @todo Also handle mSession? */
662
663	alock.release(); /* Release lock before firing off event. */
664
665	fireGuestProcessInputNotifyEvent(mEventSource, mSession, this,
666	uPID, 0 /* StdIn */, dataCb.uProcessed, inputStatus);
667	}
668	}
669
670	LogFlowFuncLeaveRC(vrc);
671	return vrc;
672	}
673
674	int GuestProcess::i_onProcessNotifyIO(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
675	{
676	AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
677	AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
678
679	return VERR_NOT_IMPLEMENTED;
680	}
681
682	int GuestProcess::i_onProcessStatusChange(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
683	{
684	AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
685	AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
686
687	if (pSvcCbData->mParms < 5)
688	return VERR_INVALID_PARAMETER;
689
690	CALLBACKDATA_PROC_STATUS dataCb;
691	/* pSvcCb->mpaParms[0] always contains the context ID. */
692	int vrc = pSvcCbData->mpaParms[1].getUInt32(&dataCb.uPID);
693	AssertRCReturn(vrc, vrc);
694	vrc = pSvcCbData->mpaParms[2].getUInt32(&dataCb.uStatus);
695	AssertRCReturn(vrc, vrc);
696	vrc = pSvcCbData->mpaParms[3].getUInt32(&dataCb.uFlags);
697	AssertRCReturn(vrc, vrc);
698	vrc = pSvcCbData->mpaParms[4].getPointer(&dataCb.pvData, &dataCb.cbData);
699	AssertRCReturn(vrc, vrc);
700
701	LogFlowThisFunc(("uPID=%RU32, uStatus=%RU32, uFlags=%RU32\n",
702	dataCb.uPID, dataCb.uStatus, dataCb.uFlags));
703
704	vrc = i_checkPID(dataCb.uPID);
705	if (RT_SUCCESS(vrc))
706	{
707	ProcessStatus_T procStatus = ProcessStatus_Undefined;
708	int procRc = VINF_SUCCESS;
709
710	switch (dataCb.uStatus)
711	{
712	case PROC_STS_STARTED:
713	{
714	procStatus = ProcessStatus_Started;
715
716	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
717	mData.mPID = dataCb.uPID; /* Set the process PID. */
718	break;
719	}
720
721	case PROC_STS_TEN:
722	{
723	procStatus = ProcessStatus_TerminatedNormally;
724
725	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
726	mData.mExitCode = dataCb.uFlags; /* Contains the exit code. */
727	break;
728	}
729
730	case PROC_STS_TES:
731	{
732	procStatus = ProcessStatus_TerminatedSignal;
733
734	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
735	mData.mExitCode = dataCb.uFlags; /* Contains the signal. */
736	break;
737	}
738
739	case PROC_STS_TEA:
740	{
741	procStatus = ProcessStatus_TerminatedAbnormally;
742	break;
743	}
744
745	case PROC_STS_TOK:
746	{
747	procStatus = ProcessStatus_TimedOutKilled;
748	break;
749	}
750
751	case PROC_STS_TOA:
752	{
753	procStatus = ProcessStatus_TimedOutAbnormally;
754	break;
755	}
756
757	case PROC_STS_DWN:
758	{
759	procStatus = ProcessStatus_Down;
760	break;
761	}
762
763	case PROC_STS_ERROR:
764	{
765	procRc = dataCb.uFlags; /* mFlags contains the IPRT error sent from the guest. */
766	procStatus = ProcessStatus_Error;
767	break;
768	}
769
770	case PROC_STS_UNDEFINED:
771	default:
772	{
773	/* Silently skip this request. */
774	procStatus = ProcessStatus_Undefined;
775	break;
776	}
777	}
778
779	LogFlowThisFunc(("Got rc=%Rrc, procSts=%RU32, procRc=%Rrc\n",
780	vrc, procStatus, procRc));
781
782	/* Set the process status. */
783	int rc2 = i_setProcessStatus(procStatus, procRc);
784	if (RT_SUCCESS(vrc))
785	vrc = rc2;
786	}
787
788	LogFlowFuncLeaveRC(vrc);
789	return vrc;
790	}
791
792	int GuestProcess::i_onProcessOutput(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
793	{
794	RT_NOREF(pCbCtx);
795	AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
796
797	if (pSvcCbData->mParms < 5)
798	return VERR_INVALID_PARAMETER;
799
800	CALLBACKDATA_PROC_OUTPUT dataCb;
801	/* pSvcCb->mpaParms[0] always contains the context ID. */
802	int vrc = pSvcCbData->mpaParms[1].getUInt32(&dataCb.uPID);
803	AssertRCReturn(vrc, vrc);
804	vrc = pSvcCbData->mpaParms[2].getUInt32(&dataCb.uHandle);
805	AssertRCReturn(vrc, vrc);
806	vrc = pSvcCbData->mpaParms[3].getUInt32(&dataCb.uFlags);
807	AssertRCReturn(vrc, vrc);
808	vrc = pSvcCbData->mpaParms[4].getPointer(&dataCb.pvData, &dataCb.cbData);
809	AssertRCReturn(vrc, vrc);
810
811	LogFlowThisFunc(("uPID=%RU32, uHandle=%RU32, uFlags=%RI32, pvData=%p, cbData=%RU32\n",
812	dataCb.uPID, dataCb.uHandle, dataCb.uFlags, dataCb.pvData, dataCb.cbData));
813
814	vrc = i_checkPID(dataCb.uPID);
815	if (RT_SUCCESS(vrc))
816	{
817	com::SafeArray<BYTE> data((size_t)dataCb.cbData);
818	if (dataCb.cbData)
819	data.initFrom((BYTE*)dataCb.pvData, dataCb.cbData);
820
821	fireGuestProcessOutputEvent(mEventSource, mSession, this,
822	mData.mPID, dataCb.uHandle, dataCb.cbData, ComSafeArrayAsInParam(data));
823	}
824
825	LogFlowFuncLeaveRC(vrc);
826	return vrc;
827	}
828
829	/**
830	* Called by IGuestSession right before this process gets
831	* removed from the public process list.
832	*/
833	int GuestProcess::i_onRemove(void)
834	{
835	LogFlowThisFuncEnter();
836
837	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
838
839	int vrc = VINF_SUCCESS;
840
841	/*
842	* Note: The event source stuff holds references to this object,
843	* so make sure that this is cleaned up before calling uninit().
844	*/
845	if (!mEventSource.isNull())
846	{
847	mEventSource->UnregisterListener(mLocalListener);
848
849	mLocalListener.setNull();
850	unconst(mEventSource).setNull();
851	}
852
853	LogFlowFuncLeaveRC(vrc);
854	return vrc;
855	}
856
857	int GuestProcess::i_readData(uint32_t uHandle, uint32_t uSize, uint32_t uTimeoutMS,
858	void pvData, size_t cbData, uint32_t pcbRead, int *pGuestRc)
859	{
860	LogFlowThisFunc(("uPID=%RU32, uHandle=%RU32, uSize=%RU32, uTimeoutMS=%RU32, pvData=%p, cbData=%RU32, pGuestRc=%p\n",
861	mData.mPID, uHandle, uSize, uTimeoutMS, pvData, cbData, pGuestRc));
862	AssertReturn(uSize, VERR_INVALID_PARAMETER);
863	AssertPtrReturn(pvData, VERR_INVALID_POINTER);
864	AssertReturn(cbData >= uSize, VERR_INVALID_PARAMETER);
865	/* pcbRead is optional. */
866
867	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
868
869	if ( mData.mStatus != ProcessStatus_Started
870	/* Skip reading if the process wasn't started with the appropriate
871	* flags. */
872	\|\| ( ( uHandle == OUTPUT_HANDLE_ID_STDOUT
873	\|\| uHandle == OUTPUT_HANDLE_ID_STDOUT_DEPRECATED)
874	&& !(mData.mProcess.mFlags & ProcessCreateFlag_WaitForStdOut))
875	\|\| ( uHandle == OUTPUT_HANDLE_ID_STDERR
876	&& !(mData.mProcess.mFlags & ProcessCreateFlag_WaitForStdErr))
877	)
878	{
879	if (pcbRead)
880	*pcbRead = 0;
881	if (pGuestRc)
882	*pGuestRc = VINF_SUCCESS;
883	return VINF_SUCCESS; /* Nothing to read anymore. */
884	}
885
886	int vrc;
887
888	GuestWaitEvent *pEvent = NULL;
889	GuestEventTypes eventTypes;
890	try
891	{
892	/*
893	* On Guest Additions < 4.3 there is no guarantee that the process status
894	* change arrives after the output event, e.g. if this was the last output
895	* block being read and the process will report status "terminate".
896	* So just skip checking for process status change and only wait for the
897	* output event.
898	*/
899	if (mSession->i_getProtocolVersion() >= 2)
900	eventTypes.push_back(VBoxEventType_OnGuestProcessStateChanged);
901	eventTypes.push_back(VBoxEventType_OnGuestProcessOutput);
902
903	vrc = registerWaitEvent(eventTypes, &pEvent);
904	}
905	catch (std::bad_alloc)
906	{
907	vrc = VERR_NO_MEMORY;
908	}
909
910	if (RT_FAILURE(vrc))
911	return vrc;
912
913	if (RT_SUCCESS(vrc))
914	{
915	VBOXHGCMSVCPARM paParms[8];
916	int i = 0;
917	paParms[i++].setUInt32(pEvent->ContextID());
918	paParms[i++].setUInt32(mData.mPID);
919	paParms[i++].setUInt32(uHandle);
920	paParms[i++].setUInt32(0 /* Flags, none set yet. */);
921
922	alock.release(); /* Drop the write lock before sending. */
923
924	vrc = sendCommand(HOST_EXEC_GET_OUTPUT, i, paParms);
925	}
926
927	if (RT_SUCCESS(vrc))
928	vrc = i_waitForOutput(pEvent, uHandle, uTimeoutMS,
929	pvData, cbData, pcbRead);
930
931	unregisterWaitEvent(pEvent);
932
933	LogFlowFuncLeaveRC(vrc);
934	return vrc;
935	}
936
937	/* Does not do locking; caller is responsible for that! */
938	int GuestProcess::i_setProcessStatus(ProcessStatus_T procStatus, int procRc)
939	{
940	LogFlowThisFuncEnter();
941
942	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
943
944	LogFlowThisFunc(("oldStatus=%RU32, newStatus=%RU32, procRc=%Rrc\n",
945	mData.mStatus, procStatus, procRc));
946
947	if (procStatus == ProcessStatus_Error)
948	{
949	AssertMsg(RT_FAILURE(procRc), ("Guest rc must be an error (%Rrc)\n", procRc));
950	/* Do not allow overwriting an already set error. If this happens
951	* this means we forgot some error checking/locking somewhere. */
952	AssertMsg(RT_SUCCESS(mData.mLastError), ("Guest rc already set (to %Rrc)\n", mData.mLastError));
953	}
954	else
955	AssertMsg(RT_SUCCESS(procRc), ("Guest rc must not be an error (%Rrc)\n", procRc));
956
957	int rc = VINF_SUCCESS;
958
959	if (mData.mStatus != procStatus) /* Was there a process status change? */
960	{
961	mData.mStatus = procStatus;
962	mData.mLastError = procRc;
963
964	ComObjPtr<VirtualBoxErrorInfo> errorInfo;
965	HRESULT hr = errorInfo.createObject();
966	ComAssertComRC(hr);
967	if (RT_FAILURE(mData.mLastError))
968	{
969	hr = errorInfo->initEx(VBOX_E_IPRT_ERROR, mData.mLastError,
970	COM_IIDOF(IGuestProcess), getComponentName(),
971	i_guestErrorToString(mData.mLastError));
972	ComAssertComRC(hr);
973	}
974
975	/* Copy over necessary data before releasing lock again. */
976	uint32_t uPID = mData.mPID;
977	/** @todo Also handle mSession? */
978
979	alock.release(); /* Release lock before firing off event. */
980
981	fireGuestProcessStateChangedEvent(mEventSource, mSession, this,
982	uPID, procStatus, errorInfo);
983	#if 0
984	/*
985	* On Guest Additions < 4.3 there is no guarantee that outstanding
986	* requests will be delivered to the host after the process has ended,
987	* so just cancel all waiting events here to not let clients run
988	* into timeouts.
989	*/
990	if ( mSession->getProtocolVersion() < 2
991	&& hasEnded())
992	{
993	LogFlowThisFunc(("Process ended, canceling outstanding wait events ...\n"));
994	rc = cancelWaitEvents();
995	}
996	#endif
997	}
998
999	return rc;
1000	}
1001
1002	/* static */
1003	HRESULT GuestProcess::i_setErrorExternal(VirtualBoxBase *pInterface, int guestRc)
1004	{
1005	AssertPtr(pInterface);
1006	AssertMsg(RT_FAILURE(guestRc), ("Guest rc does not indicate a failure when setting error\n"));
1007
1008	return pInterface->setError(VBOX_E_IPRT_ERROR, GuestProcess::i_guestErrorToString(guestRc).c_str());
1009	}
1010
1011	int GuestProcess::i_startProcess(uint32_t cMsTimeout, int *pGuestRc)
1012	{
1013	LogFlowThisFunc(("cMsTimeout=%RU32, procExe=%s, procTimeoutMS=%RU32, procFlags=%x, sessionID=%RU32\n",
1014	cMsTimeout, mData.mProcess.mExecutable.c_str(), mData.mProcess.mTimeoutMS, mData.mProcess.mFlags,
1015	mSession->i_getId()));
1016
1017	/* Wait until the caller function (if kicked off by a thread)
1018	* has returned and continue operation. */
1019	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1020
1021	mData.mStatus = ProcessStatus_Starting;
1022
1023	int vrc;
1024
1025	GuestWaitEvent *pEvent = NULL;
1026	GuestEventTypes eventTypes;
1027	try
1028	{
1029	eventTypes.push_back(VBoxEventType_OnGuestProcessStateChanged);
1030	vrc = registerWaitEvent(eventTypes, &pEvent);
1031	}
1032	catch (std::bad_alloc)
1033	{
1034	vrc = VERR_NO_MEMORY;
1035	}
1036	if (RT_FAILURE(vrc))
1037	return vrc;
1038
1039	vrc = i_startProcessInner(cMsTimeout, alock, pEvent, pGuestRc);
1040
1041	unregisterWaitEvent(pEvent);
1042
1043	LogFlowFuncLeaveRC(vrc);
1044	return vrc;
1045	}
1046
1047	int GuestProcess::i_startProcessInner(uint32_t cMsTimeout, AutoWriteLock &rLock, GuestWaitEvent pEvent, int pGuestRc)
1048	{
1049	GuestSession *pSession = mSession;
1050	AssertPtr(pSession);
1051	uint32_t const uProtocol = pSession->i_getProtocolVersion();
1052
1053	const GuestCredentials &sessionCreds = pSession->i_getCredentials();
1054
1055
1056	/* Prepare arguments. */
1057	size_t cArgs = mData.mProcess.mArguments.size();
1058	if (cArgs >= 128*1024)
1059	return VERR_BUFFER_OVERFLOW;
1060
1061	char *pszArgs = NULL;
1062	int vrc = VINF_SUCCESS;
1063	if (cArgs)
1064	{
1065	char const papszArgv = (char const )RTMemAlloc((cArgs + 1) * sizeof(papszArgv[0]));
1066	AssertReturn(papszArgv, VERR_NO_MEMORY);
1067
1068	for (size_t i = 0; i < cArgs; i++)
1069	{
1070	papszArgv[i] = mData.mProcess.mArguments[i].c_str();
1071	AssertPtr(papszArgv[i]);
1072	}
1073	papszArgv[cArgs] = NULL;
1074
1075	if (uProtocol < UINT32_C(0xdeadbeef) ) /** @todo implement a way of sending argv[0], best idea is a new command. */
1076	vrc = RTGetOptArgvToString(&pszArgs, papszArgv + 1, RTGETOPTARGV_CNV_QUOTE_BOURNE_SH);
1077	else
1078	vrc = RTGetOptArgvToString(&pszArgs, papszArgv, RTGETOPTARGV_CNV_QUOTE_BOURNE_SH);
1079
1080	RTMemFree(papszArgv);
1081	if (RT_FAILURE(vrc))
1082	return vrc;
1083
1084	/* Note! No returns after this. */
1085	}
1086
1087	/* Calculate arguments size (in bytes). */
1088	size_t cbArgs = pszArgs ? strlen(pszArgs) + 1 : 0; /* Include terminating zero. */
1089
1090	/* Prepare environment. The guest service dislikes the empty string at the end, so drop it. */
1091	size_t cbEnvBlock;
1092	char *pszzEnvBlock;
1093	vrc = mData.mProcess.mEnvironmentChanges.queryUtf8Block(&pszzEnvBlock, &cbEnvBlock);
1094	if (RT_SUCCESS(vrc))
1095	{
1096	Assert(cbEnvBlock > 0);
1097	cbEnvBlock--;
1098
1099	/* Prepare HGCM call. */
1100	VBOXHGCMSVCPARM paParms[16];
1101	int i = 0;
1102	paParms[i++].setUInt32(pEvent->ContextID());
1103	paParms[i++].setCppString(mData.mProcess.mExecutable);
1104	paParms[i++].setUInt32(mData.mProcess.mFlags);
1105	paParms[i++].setUInt32((uint32_t)mData.mProcess.mArguments.size());
1106	paParms[i++].setPointer(pszArgs, (uint32_t)cbArgs);
1107	paParms[i++].setUInt32(mData.mProcess.mEnvironmentChanges.count());
1108	paParms[i++].setUInt32((uint32_t)cbEnvBlock);
1109	paParms[i++].setPointer(pszzEnvBlock, (uint32_t)cbEnvBlock);
1110	if (uProtocol < 2)
1111	{
1112	/* In protocol v1 (VBox < 4.3) the credentials were part of the execution
1113	* call. In newer protocols these credentials are part of the opened guest
1114	* session, so not needed anymore here. */
1115	paParms[i++].setCppString(sessionCreds.mUser);
1116	paParms[i++].setCppString(sessionCreds.mPassword);
1117	}
1118	/*
1119	* If the WaitForProcessStartOnly flag is set, we only want to define and wait for a timeout
1120	* until the process was started - the process itself then gets an infinite timeout for execution.
1121	* This is handy when we want to start a process inside a worker thread within a certain timeout
1122	* but let the started process perform lengthly operations then.
1123	*/
1124	if (mData.mProcess.mFlags & ProcessCreateFlag_WaitForProcessStartOnly)
1125	paParms[i++].setUInt32(UINT32_MAX /* Infinite timeout */);
1126	else
1127	paParms[i++].setUInt32(mData.mProcess.mTimeoutMS);
1128	if (uProtocol >= 2)
1129	{
1130	paParms[i++].setUInt32(mData.mProcess.mPriority);
1131	/* CPU affinity: We only support one CPU affinity block at the moment,
1132	* so that makes up to 64 CPUs total. This can be more in the future. */
1133	paParms[i++].setUInt32(1);
1134	/* The actual CPU affinity blocks. */
1135	paParms[i++].setPointer((void *)&mData.mProcess.mAffinity, sizeof(mData.mProcess.mAffinity));
1136	}
1137
1138	rLock.release(); /* Drop the write lock before sending. */
1139
1140	vrc = sendCommand(HOST_EXEC_CMD, i, paParms);
1141	if (RT_FAILURE(vrc))
1142	{
1143	int rc2 = i_setProcessStatus(ProcessStatus_Error, vrc);
1144	AssertRC(rc2);
1145	}
1146
1147	mData.mProcess.mEnvironmentChanges.freeUtf8Block(pszzEnvBlock);
1148	}
1149
1150	RTStrFree(pszArgs);
1151
1152	if (RT_SUCCESS(vrc))
1153	vrc = i_waitForStatusChange(pEvent, cMsTimeout,
1154	NULL /* Process status */, pGuestRc);
1155	return vrc;
1156	}
1157
1158	int GuestProcess::i_startProcessAsync(void)
1159	{
1160	LogFlowThisFuncEnter();
1161
1162	int vrc = VINF_SUCCESS;
1163	HRESULT hr = S_OK;
1164
1165	GuestProcessStartTask* pTask = NULL;
1166	try
1167	{
1168	pTask = new GuestProcessStartTask(this);
1169	if (!pTask->i_isOk())
1170	{
1171	delete pTask;
1172	LogFlow(("GuestProcess: Could not create GuestProcessStartTask object \n"));
1173	throw VERR_MEMOBJ_INIT_FAILED;
1174	}
1175	LogFlow(("GuestProcess: Successfully created GuestProcessStartTask object \n"));
1176	//this function delete pTask in case of exceptions, so there is no need in the call of delete operator
1177	hr = pTask->createThread();
1178	}
1179	catch(std::bad_alloc &)
1180	{
1181	vrc = VERR_NO_MEMORY;
1182	}
1183	catch(int eVRC)
1184	{
1185	vrc = eVRC;
1186	LogFlow(("GuestSession: Could not create thread for GuestProcessStartTask task %Rrc\n", vrc));
1187	}
1188
1189	LogFlowFuncLeaveRC(vrc);
1190	return vrc;
1191	}
1192
1193	/* static */
1194	void GuestProcess::i_startProcessThreadTask(GuestProcessStartTask *pTask)
1195	{
1196	LogFlowFunc(("pTask=%p\n", pTask));
1197
1198	const ComObjPtr<GuestProcess> pProcess(pTask->i_process());
1199	Assert(!pProcess.isNull());
1200
1201	AutoCaller autoCaller(pProcess);
1202	if (FAILED(autoCaller.rc()))
1203	return;
1204
1205	int vrc = pProcess->i_startProcess(30 * 1000 /* 30s timeout */,
1206	NULL /* Guest rc, ignored */);
1207	/** @todo
1208	*
1209	* r=bird: what's up with vrc here? Safe to ignore it?
1210	*
1211	*/
1212
1213	/* Nothing to do here anymore. */
1214
1215	LogFlowFunc(("pProcess=%p vrc=%Rrc (ignored)\n", (GuestProcess *)pProcess, vrc));
1216	NOREF(vrc);
1217	}
1218
1219	int GuestProcess::i_terminateProcess(uint32_t uTimeoutMS, int *pGuestRc)
1220	{
1221	/* pGuestRc is optional. */
1222	LogFlowThisFunc(("uTimeoutMS=%RU32\n", uTimeoutMS));
1223
1224	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1225
1226	int vrc = VINF_SUCCESS;
1227
1228	if (mData.mStatus != ProcessStatus_Started)
1229	{
1230	LogFlowThisFunc(("Process not in started state (state is %RU32), skipping termination\n",
1231	mData.mStatus));
1232	}
1233	else
1234	{
1235	AssertPtr(mSession);
1236	/* Note: VBox < 4.3 (aka protocol version 1) does not
1237	* support this, so just skip. */
1238	if (mSession->i_getProtocolVersion() < 2)
1239	vrc = VERR_NOT_SUPPORTED;
1240
1241	if (RT_SUCCESS(vrc))
1242	{
1243	GuestWaitEvent *pEvent = NULL;
1244	GuestEventTypes eventTypes;
1245	try
1246	{
1247	eventTypes.push_back(VBoxEventType_OnGuestProcessStateChanged);
1248
1249	vrc = registerWaitEvent(eventTypes, &pEvent);
1250	}
1251	catch (std::bad_alloc)
1252	{
1253	vrc = VERR_NO_MEMORY;
1254	}
1255
1256	if (RT_FAILURE(vrc))
1257	return vrc;
1258
1259	VBOXHGCMSVCPARM paParms[4];
1260	int i = 0;
1261	paParms[i++].setUInt32(pEvent->ContextID());
1262	paParms[i++].setUInt32(mData.mPID);
1263
1264	alock.release(); /* Drop the write lock before sending. */
1265
1266	vrc = sendCommand(HOST_EXEC_TERMINATE, i, paParms);
1267	if (RT_SUCCESS(vrc))
1268	vrc = i_waitForStatusChange(pEvent, uTimeoutMS,
1269	NULL /* ProcessStatus */, pGuestRc);
1270	unregisterWaitEvent(pEvent);
1271	}
1272	}
1273
1274	LogFlowFuncLeaveRC(vrc);
1275	return vrc;
1276	}
1277
1278	/* static */
1279	ProcessWaitResult_T GuestProcess::i_waitFlagsToResultEx(uint32_t fWaitFlags,
1280	ProcessStatus_T oldStatus, ProcessStatus_T newStatus,
1281	uint32_t uProcFlags, uint32_t uProtocol)
1282	{
1283	ProcessWaitResult_T waitResult = ProcessWaitResult_None;
1284
1285	switch (newStatus)
1286	{
1287	case ProcessStatus_TerminatedNormally:
1288	case ProcessStatus_TerminatedSignal:
1289	case ProcessStatus_TerminatedAbnormally:
1290	case ProcessStatus_Down:
1291	/* Nothing to wait for anymore. */
1292	waitResult = ProcessWaitResult_Terminate;
1293	break;
1294
1295	case ProcessStatus_TimedOutKilled:
1296	case ProcessStatus_TimedOutAbnormally:
1297	/* Dito. */
1298	waitResult = ProcessWaitResult_Timeout;
1299	break;
1300
1301	case ProcessStatus_Started:
1302	switch (oldStatus)
1303	{
1304	case ProcessStatus_Undefined:
1305	case ProcessStatus_Starting:
1306	/* Also wait for process start. */
1307	if (fWaitFlags & ProcessWaitForFlag_Start)
1308	waitResult = ProcessWaitResult_Start;
1309	else
1310	{
1311	/*
1312	* If ProcessCreateFlag_WaitForProcessStartOnly was specified on process creation the
1313	* caller is not interested in getting further process statuses -- so just don't notify
1314	* anything here anymore and return.
1315	*/
1316	if (uProcFlags & ProcessCreateFlag_WaitForProcessStartOnly)
1317	waitResult = ProcessWaitResult_Start;
1318	}
1319	break;
1320
1321	case ProcessStatus_Started:
1322	/* Only wait for process start. */
1323	if (fWaitFlags == ProcessWaitForFlag_Start)
1324	waitResult = ProcessWaitResult_Start;
1325	break;
1326
1327	default:
1328	AssertMsgFailed(("Unhandled old status %RU32 before new status 'started'\n",
1329	oldStatus));
1330	waitResult = ProcessWaitResult_Start;
1331	break;
1332	}
1333	break;
1334
1335	case ProcessStatus_Error:
1336	/* Nothing to wait for anymore. */
1337	waitResult = ProcessWaitResult_Error;
1338	break;
1339
1340	case ProcessStatus_Undefined:
1341	case ProcessStatus_Starting:
1342	case ProcessStatus_Terminating:
1343	case ProcessStatus_Paused:
1344	/* No result available yet, leave wait
1345	* flags untouched. */
1346	break;
1347	}
1348
1349	if (newStatus == ProcessStatus_Started)
1350	{
1351	/**
1352	* Filter out waits which are not supported using
1353	* older guest control Guest Additions.
1354	*
1355	** @todo ProcessWaitForFlag_Std* flags are not implemented yet.
1356	*/
1357	if (uProtocol < 99) /* See @todo above. */
1358	{
1359	if ( waitResult == ProcessWaitResult_None
1360	/* We don't support waiting for stdin, out + err,
1361	* just skip waiting then. */
1362	&& ( (fWaitFlags & ProcessWaitForFlag_StdIn)
1363	\|\| (fWaitFlags & ProcessWaitForFlag_StdOut)
1364	\|\| (fWaitFlags & ProcessWaitForFlag_StdErr)
1365	)
1366	)
1367	{
1368	/* Use _WaitFlagNotSupported because we don't know what to tell the caller. */
1369	waitResult = ProcessWaitResult_WaitFlagNotSupported;
1370	}
1371	}
1372	}
1373
1374	#ifdef DEBUG
1375	LogFlowFunc(("oldStatus=%RU32, newStatus=%RU32, fWaitFlags=0x%x, waitResult=%RU32\n",
1376	oldStatus, newStatus, fWaitFlags, waitResult));
1377	#endif
1378	return waitResult;
1379	}
1380
1381	ProcessWaitResult_T GuestProcess::i_waitFlagsToResult(uint32_t fWaitFlags)
1382	{
1383	AssertPtr(mSession);
1384	return GuestProcess::i_waitFlagsToResultEx(fWaitFlags,
1385	mData.mStatus /* curStatus /, mData.mStatus / newStatus */,
1386	mData.mProcess.mFlags, mSession->i_getProtocolVersion());
1387	}
1388
1389	int GuestProcess::i_waitFor(uint32_t fWaitFlags, ULONG uTimeoutMS,
1390	ProcessWaitResult_T &waitResult, int *pGuestRc)
1391	{
1392	AssertReturn(fWaitFlags, VERR_INVALID_PARAMETER);
1393
1394	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1395
1396	LogFlowThisFunc(("fWaitFlags=0x%x, uTimeoutMS=%RU32, procStatus=%RU32, procRc=%Rrc, pGuestRc=%p\n",
1397	fWaitFlags, uTimeoutMS, mData.mStatus, mData.mLastError, pGuestRc));
1398
1399	/* Did some error occur before? Then skip waiting and return. */
1400	ProcessStatus_T curStatus = mData.mStatus;
1401	if (curStatus == ProcessStatus_Error)
1402	{
1403	waitResult = ProcessWaitResult_Error;
1404	AssertMsg(RT_FAILURE(mData.mLastError),
1405	("No error rc (%Rrc) set when guest process indicated an error\n", mData.mLastError));
1406	if (pGuestRc)
1407	pGuestRc = mData.mLastError; / Return last set error. */
1408	LogFlowThisFunc(("Process is in error state (guestRc=%Rrc)\n", mData.mLastError));
1409	return VERR_GSTCTL_GUEST_ERROR;
1410	}
1411
1412	waitResult = i_waitFlagsToResult(fWaitFlags);
1413
1414	/* No waiting needed? Return immediately using the last set error. */
1415	if (waitResult != ProcessWaitResult_None)
1416	{
1417	if (pGuestRc)
1418	pGuestRc = mData.mLastError; / Return last set error (if any). */
1419	LogFlowThisFunc(("Nothing to wait for (guestRc=%Rrc)\n", mData.mLastError));
1420	return RT_SUCCESS(mData.mLastError) ? VINF_SUCCESS : VERR_GSTCTL_GUEST_ERROR;
1421	}
1422
1423	/* Adjust timeout. Passing 0 means RT_INDEFINITE_WAIT. */
1424	if (!uTimeoutMS)
1425	uTimeoutMS = RT_INDEFINITE_WAIT;
1426
1427	int vrc;
1428
1429	GuestWaitEvent *pEvent = NULL;
1430	GuestEventTypes eventTypes;
1431	try
1432	{
1433	eventTypes.push_back(VBoxEventType_OnGuestProcessStateChanged);
1434
1435	vrc = registerWaitEvent(eventTypes, &pEvent);
1436	}
1437	catch (std::bad_alloc)
1438	{
1439	vrc = VERR_NO_MEMORY;
1440	}
1441
1442	if (RT_FAILURE(vrc))
1443	return vrc;
1444
1445	alock.release(); /* Release lock before waiting. */
1446
1447	/*
1448	* Do the actual waiting.
1449	*/
1450	ProcessStatus_T newStatus = ProcessStatus_Undefined;
1451	uint64_t u64StartMS = RTTimeMilliTS();
1452	for (;;)
1453	{
1454	uint64_t u64ElapsedMS = RTTimeMilliTS() - u64StartMS;
1455	if ( uTimeoutMS != RT_INDEFINITE_WAIT
1456	&& u64ElapsedMS >= uTimeoutMS)
1457	{
1458	vrc = VERR_TIMEOUT;
1459	break;
1460	}
1461
1462	vrc = i_waitForStatusChange(pEvent,
1463	uTimeoutMS == RT_INDEFINITE_WAIT
1464	? RT_INDEFINITE_WAIT : uTimeoutMS - (uint32_t)u64ElapsedMS,
1465	&newStatus, pGuestRc);
1466	if (RT_SUCCESS(vrc))
1467	{
1468	alock.acquire();
1469
1470	waitResult = i_waitFlagsToResultEx(fWaitFlags, curStatus, newStatus,
1471	mData.mProcess.mFlags, mSession->i_getProtocolVersion());
1472	#ifdef DEBUG
1473	LogFlowThisFunc(("Got new status change: fWaitFlags=0x%x, newStatus=%RU32, waitResult=%RU32\n",
1474	fWaitFlags, newStatus, waitResult));
1475	#endif
1476	if (ProcessWaitResult_None != waitResult) /* We got a waiting result. */
1477	break;
1478	}
1479	else /* Waiting failed, bail out. */
1480	break;
1481
1482	alock.release(); /* Don't hold lock in next waiting round. */
1483	}
1484
1485	unregisterWaitEvent(pEvent);
1486
1487	LogFlowThisFunc(("Returned waitResult=%RU32, newStatus=%RU32, rc=%Rrc\n",
1488	waitResult, newStatus, vrc));
1489	return vrc;
1490	}
1491
1492	int GuestProcess::i_waitForInputNotify(GuestWaitEvent *pEvent, uint32_t uHandle, uint32_t uTimeoutMS,
1493	ProcessInputStatus_T pInputStatus, uint32_t pcbProcessed)
1494	{
1495	RT_NOREF(uHandle);
1496	AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
1497
1498	VBoxEventType_T evtType;
1499	ComPtr<IEvent> pIEvent;
1500	int vrc = waitForEvent(pEvent, uTimeoutMS,
1501	&evtType, pIEvent.asOutParam());
1502	if (RT_SUCCESS(vrc))
1503	{
1504	if (evtType == VBoxEventType_OnGuestProcessInputNotify)
1505	{
1506	ComPtr<IGuestProcessInputNotifyEvent> pProcessEvent = pIEvent;
1507	Assert(!pProcessEvent.isNull());
1508
1509	if (pInputStatus)
1510	{
1511	HRESULT hr2 = pProcessEvent->COMGETTER(Status)(pInputStatus);
1512	ComAssertComRC(hr2);
1513	}
1514	if (pcbProcessed)
1515	{
1516	HRESULT hr2 = pProcessEvent->COMGETTER(Processed)((ULONG*)pcbProcessed);
1517	ComAssertComRC(hr2);
1518	}
1519	}
1520	else
1521	vrc = VWRN_GSTCTL_OBJECTSTATE_CHANGED;
1522	}
1523
1524	LogFlowThisFunc(("Returning pEvent=%p, uHandle=%RU32, rc=%Rrc\n",
1525	pEvent, uHandle, vrc));
1526	return vrc;
1527	}
1528
1529	int GuestProcess::i_waitForOutput(GuestWaitEvent *pEvent, uint32_t uHandle, uint32_t uTimeoutMS,
1530	void pvData, size_t cbData, uint32_t pcbRead)
1531	{
1532	AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
1533	/* pvData is optional. */
1534	/* cbData is optional. */
1535	/* pcbRead is optional. */
1536
1537	LogFlowThisFunc(("cEventTypes=%zu, pEvent=%p, uHandle=%RU32, uTimeoutMS=%RU32, pvData=%p, cbData=%zu, pcbRead=%p\n",
1538	pEvent->TypeCount(), pEvent, uHandle, uTimeoutMS, pvData, cbData, pcbRead));
1539
1540	int vrc;
1541
1542	VBoxEventType_T evtType;
1543	ComPtr<IEvent> pIEvent;
1544	do
1545	{
1546	vrc = waitForEvent(pEvent, uTimeoutMS,
1547	&evtType, pIEvent.asOutParam());
1548	if (RT_SUCCESS(vrc))
1549	{
1550	if (evtType == VBoxEventType_OnGuestProcessOutput)
1551	{
1552	ComPtr<IGuestProcessOutputEvent> pProcessEvent = pIEvent;
1553	Assert(!pProcessEvent.isNull());
1554
1555	ULONG uHandleEvent;
1556	HRESULT hr = pProcessEvent->COMGETTER(Handle)(&uHandleEvent);
1557	if ( SUCCEEDED(hr)
1558	&& uHandleEvent == uHandle)
1559	{
1560	if (pvData)
1561	{
1562	com::SafeArray <BYTE> data;
1563	hr = pProcessEvent->COMGETTER(Data)(ComSafeArrayAsOutParam(data));
1564	ComAssertComRC(hr);
1565	size_t cbRead = data.size();
1566	if (cbRead)
1567	{
1568	if (cbRead <= cbData)
1569	{
1570	/* Copy data from event into our buffer. */
1571	memcpy(pvData, data.raw(), data.size());
1572	}
1573	else
1574	vrc = VERR_BUFFER_OVERFLOW;
1575
1576	LogFlowThisFunc(("Read %zu bytes (uHandle=%RU32), rc=%Rrc\n",
1577	cbRead, uHandleEvent, vrc));
1578	}
1579	}
1580
1581	if ( RT_SUCCESS(vrc)
1582	&& pcbRead)
1583	{
1584	ULONG cbRead;
1585	hr = pProcessEvent->COMGETTER(Processed)(&cbRead);
1586	ComAssertComRC(hr);
1587	*pcbRead = (uint32_t)cbRead;
1588	}
1589
1590	break;
1591	}
1592	else if (FAILED(hr))
1593	vrc = VERR_COM_UNEXPECTED;
1594	}
1595	else
1596	vrc = VWRN_GSTCTL_OBJECTSTATE_CHANGED;
1597	}
1598
1599	} while (vrc == VINF_SUCCESS);
1600
1601	if ( vrc != VINF_SUCCESS
1602	&& pcbRead)
1603	{
1604	*pcbRead = 0;
1605	}
1606
1607	LogFlowFuncLeaveRC(vrc);
1608	return vrc;
1609	}
1610
1611	int GuestProcess::i_waitForStatusChange(GuestWaitEvent *pEvent, uint32_t uTimeoutMS,
1612	ProcessStatus_T pProcessStatus, int pGuestRc)
1613	{
1614	AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
1615	/* pProcessStatus is optional. */
1616	/* pGuestRc is optional. */
1617
1618	VBoxEventType_T evtType;
1619	ComPtr<IEvent> pIEvent;
1620	int vrc = waitForEvent(pEvent, uTimeoutMS,
1621	&evtType, pIEvent.asOutParam());
1622	if (RT_SUCCESS(vrc))
1623	{
1624	Assert(evtType == VBoxEventType_OnGuestProcessStateChanged);
1625	ComPtr<IGuestProcessStateChangedEvent> pProcessEvent = pIEvent;
1626	Assert(!pProcessEvent.isNull());
1627
1628	ProcessStatus_T procStatus;
1629	HRESULT hr = pProcessEvent->COMGETTER(Status)(&procStatus);
1630	ComAssertComRC(hr);
1631	if (pProcessStatus)
1632	*pProcessStatus = procStatus;
1633
1634	ComPtr<IVirtualBoxErrorInfo> errorInfo;
1635	hr = pProcessEvent->COMGETTER(Error)(errorInfo.asOutParam());
1636	ComAssertComRC(hr);
1637
1638	LONG lGuestRc;
1639	hr = errorInfo->COMGETTER(ResultDetail)(&lGuestRc);
1640	ComAssertComRC(hr);
1641
1642	LogFlowThisFunc(("Got procStatus=%RU32, guestRc=%RI32 (%Rrc)\n",
1643	procStatus, lGuestRc, lGuestRc));
1644
1645	if (RT_FAILURE((int)lGuestRc))
1646	vrc = VERR_GSTCTL_GUEST_ERROR;
1647
1648	if (pGuestRc)
1649	*pGuestRc = (int)lGuestRc;
1650	}
1651
1652	LogFlowFuncLeaveRC(vrc);
1653	return vrc;
1654	}
1655
1656	/* static */
1657	bool GuestProcess::i_waitResultImpliesEx(ProcessWaitResult_T waitResult,
1658	ProcessStatus_T procStatus, uint32_t uProcFlags,
1659	uint32_t uProtocol)
1660	{
1661	/** @todo r=bird: If you subscribe to HN, which the 'u' in 'uProcFlags'
1662	* indicates, you should actually be using 'fProc'! */
1663	RT_NOREF(uProtocol, uProcFlags);
1664	bool fImplies;
1665
1666	switch (waitResult)
1667	{
1668	case ProcessWaitResult_Start:
1669	fImplies = procStatus == ProcessStatus_Started;
1670	break;
1671
1672	case ProcessWaitResult_Terminate:
1673	fImplies = ( procStatus == ProcessStatus_TerminatedNormally
1674	\|\| procStatus == ProcessStatus_TerminatedSignal
1675	\|\| procStatus == ProcessStatus_TerminatedAbnormally
1676	\|\| procStatus == ProcessStatus_TimedOutKilled
1677	\|\| procStatus == ProcessStatus_TimedOutAbnormally
1678	\|\| procStatus == ProcessStatus_Down
1679	\|\| procStatus == ProcessStatus_Error);
1680	break;
1681
1682	default:
1683	fImplies = false;
1684	break;
1685	}
1686
1687	return fImplies;
1688	}
1689
1690	int GuestProcess::i_writeData(uint32_t uHandle, uint32_t uFlags,
1691	void pvData, size_t cbData, uint32_t uTimeoutMS, uint32_t puWritten, int *pGuestRc)
1692	{
1693	LogFlowThisFunc(("uPID=%RU32, uHandle=%RU32, uFlags=%RU32, pvData=%p, cbData=%RU32, uTimeoutMS=%RU32, puWritten=%p, pGuestRc=%p\n",
1694	mData.mPID, uHandle, uFlags, pvData, cbData, uTimeoutMS, puWritten, pGuestRc));
1695	/* All is optional. There can be 0 byte writes. */
1696	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1697
1698	if (mData.mStatus != ProcessStatus_Started)
1699	{
1700	if (puWritten)
1701	*puWritten = 0;
1702	if (pGuestRc)
1703	*pGuestRc = VINF_SUCCESS;
1704	return VINF_SUCCESS; /* Not available for writing (anymore). */
1705	}
1706
1707	int vrc;
1708
1709	GuestWaitEvent *pEvent = NULL;
1710	GuestEventTypes eventTypes;
1711	try
1712	{
1713	/*
1714	* On Guest Additions < 4.3 there is no guarantee that the process status
1715	* change arrives after the input event, e.g. if this was the last input
1716	* block being written and the process will report status "terminate".
1717	* So just skip checking for process status change and only wait for the
1718	* input event.
1719	*/
1720	if (mSession->i_getProtocolVersion() >= 2)
1721	eventTypes.push_back(VBoxEventType_OnGuestProcessStateChanged);
1722	eventTypes.push_back(VBoxEventType_OnGuestProcessInputNotify);
1723
1724	vrc = registerWaitEvent(eventTypes, &pEvent);
1725	}
1726	catch (std::bad_alloc)
1727	{
1728	vrc = VERR_NO_MEMORY;
1729	}
1730
1731	if (RT_FAILURE(vrc))
1732	return vrc;
1733
1734	VBOXHGCMSVCPARM paParms[5];
1735	int i = 0;
1736	paParms[i++].setUInt32(pEvent->ContextID());
1737	paParms[i++].setUInt32(mData.mPID);
1738	paParms[i++].setUInt32(uFlags);
1739	paParms[i++].setPointer(pvData, (uint32_t)cbData);
1740	paParms[i++].setUInt32((uint32_t)cbData);
1741
1742	alock.release(); /* Drop the write lock before sending. */
1743
1744	uint32_t cbProcessed = 0;
1745	vrc = sendCommand(HOST_EXEC_SET_INPUT, i, paParms);
1746	if (RT_SUCCESS(vrc))
1747	{
1748	ProcessInputStatus_T inputStatus;
1749	vrc = i_waitForInputNotify(pEvent, uHandle, uTimeoutMS,
1750	&inputStatus, &cbProcessed);
1751	if (RT_SUCCESS(vrc))
1752	{
1753	/** @todo Set guestRc. */
1754
1755	if (puWritten)
1756	*puWritten = cbProcessed;
1757	}
1758	/** @todo Error handling. */
1759	}
1760
1761	unregisterWaitEvent(pEvent);
1762
1763	LogFlowThisFunc(("Returning cbProcessed=%RU32, rc=%Rrc\n",
1764	cbProcessed, vrc));
1765	return vrc;
1766	}
1767
1768	// implementation of public methods
1769	/////////////////////////////////////////////////////////////////////////////
1770
1771	HRESULT GuestProcess::read(ULONG aHandle, ULONG aToRead, ULONG aTimeoutMS, std::vector<BYTE> &aData)
1772	{
1773	LogFlowThisFuncEnter();
1774
1775	if (aToRead == 0)
1776	return setError(E_INVALIDARG, tr("The size to read is zero"));
1777
1778	aData.resize(aToRead);
1779
1780	HRESULT hr = S_OK;
1781
1782	uint32_t cbRead; int guestRc;
1783	int vrc = i_readData(aHandle, aToRead, aTimeoutMS, &aData.front(), aToRead, &cbRead, &guestRc);
1784	if (RT_SUCCESS(vrc))
1785	{
1786	if (aData.size() != cbRead)
1787	aData.resize(cbRead);
1788	}
1789	else
1790	{
1791	aData.resize(0);
1792
1793	switch (vrc)
1794	{
1795	case VERR_GSTCTL_GUEST_ERROR:
1796	hr = GuestProcess::i_setErrorExternal(this, guestRc);
1797	break;
1798
1799	default:
1800	hr = setError(VBOX_E_IPRT_ERROR,
1801	tr("Reading from process \"%s\" (PID %RU32) failed: %Rrc"),
1802	mData.mProcess.mExecutable.c_str(), mData.mPID, vrc);
1803	break;
1804	}
1805	}
1806
1807	LogFlowThisFunc(("rc=%Rrc, cbRead=%RU32\n", vrc, cbRead));
1808
1809	LogFlowFuncLeaveRC(vrc);
1810	return hr;
1811	}
1812
1813	HRESULT GuestProcess::terminate()
1814	{
1815	HRESULT hr = S_OK;
1816
1817	int guestRc;
1818	int vrc = i_terminateProcess(30 * 1000 /* Timeout in ms */,
1819	&guestRc);
1820	if (RT_FAILURE(vrc))
1821	{
1822	switch (vrc)
1823	{
1824	case VERR_GSTCTL_GUEST_ERROR:
1825	hr = GuestProcess::i_setErrorExternal(this, guestRc);
1826	break;
1827
1828	case VERR_NOT_SUPPORTED:
1829	hr = setError(VBOX_E_IPRT_ERROR,
1830	tr("Terminating process \"%s\" (PID %RU32) not supported by installed Guest Additions"),
1831	mData.mProcess.mExecutable.c_str(), mData.mPID);
1832	break;
1833
1834	default:
1835	hr = setError(VBOX_E_IPRT_ERROR,
1836	tr("Terminating process \"%s\" (PID %RU32) failed: %Rrc"),
1837	mData.mProcess.mExecutable.c_str(), mData.mPID, vrc);
1838	break;
1839	}
1840	}
1841
1842	/* Remove process from guest session list. Now only API clients
1843	* still can hold references to it. */
1844	AssertPtr(mSession);
1845	int rc2 = mSession->i_processRemoveFromList(this);
1846	if (RT_SUCCESS(vrc))
1847	vrc = rc2;
1848
1849	LogFlowFuncLeaveRC(vrc);
1850	return hr;
1851	}
1852
1853	HRESULT GuestProcess::waitFor(ULONG aWaitFor,
1854	ULONG aTimeoutMS,
1855	ProcessWaitResult_T *aReason)
1856	{
1857	/*
1858	* Note: Do not hold any locks here while waiting!
1859	*/
1860	HRESULT hr = S_OK;
1861
1862	int guestRc;
1863	ProcessWaitResult_T waitResult;
1864	int vrc = i_waitFor(aWaitFor, aTimeoutMS, waitResult, &guestRc);
1865	if (RT_SUCCESS(vrc))
1866	{
1867	*aReason = waitResult;
1868	}
1869	else
1870	{
1871	switch (vrc)
1872	{
1873	case VERR_GSTCTL_GUEST_ERROR:
1874	hr = GuestProcess::i_setErrorExternal(this, guestRc);
1875	break;
1876
1877	case VERR_TIMEOUT:
1878	*aReason = ProcessWaitResult_Timeout;
1879	break;
1880
1881	default:
1882	hr = setError(VBOX_E_IPRT_ERROR,
1883	tr("Waiting for process \"%s\" (PID %RU32) failed: %Rrc"),
1884	mData.mProcess.mExecutable.c_str(), mData.mPID, vrc);
1885	break;
1886	}
1887	}
1888
1889	LogFlowFuncLeaveRC(vrc);
1890	return hr;
1891	}
1892
1893	HRESULT GuestProcess::waitForArray(const std::vector<ProcessWaitForFlag_T> &aWaitFor,
1894	ULONG aTimeoutMS, ProcessWaitResult_T *aReason)
1895	{
1896	/*
1897	* Note: Do not hold any locks here while waiting!
1898	*/
1899	uint32_t fWaitFor = ProcessWaitForFlag_None;
1900	for (size_t i = 0; i < aWaitFor.size(); i++)
1901	fWaitFor \|= aWaitFor[i];
1902
1903	return WaitFor(fWaitFor, aTimeoutMS, aReason);
1904	}
1905
1906	HRESULT GuestProcess::write(ULONG aHandle, ULONG aFlags, const std::vector<BYTE> &aData,
1907	ULONG aTimeoutMS, ULONG *aWritten)
1908	{
1909	LogFlowThisFuncEnter();
1910
1911	HRESULT hr = S_OK;
1912
1913	uint32_t cbWritten; int guestRc;
1914	uint32_t cbData = (uint32_t)aData.size();
1915	void pvData = cbData > 0? (void )&aData.front(): NULL;
1916	int vrc = i_writeData(aHandle, aFlags, pvData, cbData, aTimeoutMS, &cbWritten, &guestRc);
1917	if (RT_FAILURE(vrc))
1918	{
1919	switch (vrc)
1920	{
1921	case VERR_GSTCTL_GUEST_ERROR:
1922	hr = GuestProcess::i_setErrorExternal(this, guestRc);
1923	break;
1924
1925	default:
1926	hr = setError(VBOX_E_IPRT_ERROR,
1927	tr("Writing to process \"%s\" (PID %RU32) failed: %Rrc"),
1928	mData.mProcess.mExecutable.c_str(), mData.mPID, vrc);
1929	break;
1930	}
1931	}
1932
1933	LogFlowThisFunc(("rc=%Rrc, aWritten=%RU32\n", vrc, cbWritten));
1934
1935	*aWritten = (ULONG)cbWritten;
1936
1937	LogFlowFuncLeaveRC(vrc);
1938	return hr;
1939	}
1940
1941	HRESULT GuestProcess::writeArray(ULONG aHandle, const std::vector<ProcessInputFlag_T> &aFlags,
1942	const std::vector<BYTE> &aData, ULONG aTimeoutMS, ULONG *aWritten)
1943	{
1944	LogFlowThisFuncEnter();
1945
1946	/*
1947	* Note: Do not hold any locks here while writing!
1948	*/
1949	ULONG fWrite = ProcessInputFlag_None;
1950	for (size_t i = 0; i < aFlags.size(); i++)
1951	fWrite \|= aFlags[i];
1952
1953	return write(aHandle, fWrite, aData, aTimeoutMS, aWritten);
1954	}
1955
1956	///////////////////////////////////////////////////////////////////////////////
1957
1958	GuestProcessTool::GuestProcessTool(void)
1959	: pSession(NULL),
1960	pProcess(NULL)
1961	{
1962	}
1963
1964	GuestProcessTool::~GuestProcessTool(void)
1965	{
1966	i_terminate(30 * 1000, NULL /* pGuestRc */);
1967	}
1968
1969	int GuestProcessTool::Init(GuestSession *pGuestSession, const GuestProcessStartupInfo &startupInfo,
1970	bool fAsync, int *pGuestRc)
1971	{
1972	LogFlowThisFunc(("pGuestSession=%p, exe=%s, fAsync=%RTbool\n",
1973	pGuestSession, startupInfo.mExecutable.c_str(), fAsync));
1974
1975	AssertPtrReturn(pGuestSession, VERR_INVALID_POINTER);
1976	Assert(startupInfo.mArguments[0] == startupInfo.mExecutable);
1977
1978	pSession = pGuestSession;
1979	mStartupInfo = startupInfo;
1980
1981	/* Make sure the process is hidden. */
1982	mStartupInfo.mFlags \|= ProcessCreateFlag_Hidden;
1983
1984	int vrc = pSession->i_processCreateExInternal(mStartupInfo, pProcess);
1985	if (RT_SUCCESS(vrc))
1986	{
1987	int vrcGuest = VINF_SUCCESS;
1988	vrc = fAsync
1989	? pProcess->i_startProcessAsync()
1990	: pProcess->i_startProcess(30 * 1000 /* 30s timeout */, &vrcGuest);
1991
1992	if ( RT_SUCCESS(vrc)
1993	&& !fAsync
1994	&& RT_FAILURE(vrcGuest)
1995	)
1996	{
1997	if (pGuestRc)
1998	*pGuestRc = vrcGuest;
1999	vrc = VERR_GSTCTL_GUEST_ERROR;
2000	}
2001	}
2002
2003	LogFlowFuncLeaveRC(vrc);
2004	return vrc;
2005	}
2006
2007	int GuestProcessTool::i_getCurrentBlock(uint32_t uHandle, GuestProcessStreamBlock &strmBlock)
2008	{
2009	const GuestProcessStream *pStream = NULL;
2010	if (uHandle == OUTPUT_HANDLE_ID_STDOUT)
2011	pStream = &mStdOut;
2012	else if (uHandle == OUTPUT_HANDLE_ID_STDERR)
2013	pStream = &mStdErr;
2014
2015	if (!pStream)
2016	return VERR_INVALID_PARAMETER;
2017
2018	int vrc;
2019	do
2020	{
2021	/* Try parsing the data to see if the current block is complete. */
2022	vrc = mStdOut.ParseBlock(strmBlock);
2023	if (strmBlock.GetCount())
2024	break;
2025	} while (RT_SUCCESS(vrc));
2026
2027	LogFlowThisFunc(("rc=%Rrc, %RU64 pairs\n",
2028	vrc, strmBlock.GetCount()));
2029	return vrc;
2030	}
2031
2032	int GuestProcessTool::i_getRc(void) const
2033	{
2034	LONG exitCode = -1;
2035	HRESULT hr = pProcess->COMGETTER(ExitCode(&exitCode));
2036	AssertComRC(hr);
2037
2038	return GuestProcessTool::i_exitCodeToRc(mStartupInfo, exitCode);
2039	}
2040
2041	bool GuestProcessTool::i_isRunning(void)
2042	{
2043	AssertReturn(!pProcess.isNull(), false);
2044
2045	ProcessStatus_T procStatus = ProcessStatus_Undefined;
2046	HRESULT hr = pProcess->COMGETTER(Status(&procStatus));
2047	AssertComRC(hr);
2048
2049	if ( procStatus == ProcessStatus_Started
2050	\|\| procStatus == ProcessStatus_Paused
2051	\|\| procStatus == ProcessStatus_Terminating)
2052	{
2053	return true;
2054	}
2055
2056	return false;
2057	}
2058
2059	/* static */
2060	int GuestProcessTool::i_run( GuestSession *pGuestSession,
2061	const GuestProcessStartupInfo &startupInfo,
2062	int pGuestRc / = NULL */)
2063	{
2064	int guestRc;
2065
2066	GuestProcessToolErrorInfo errorInfo;
2067	int vrc = i_runErrorInfo(pGuestSession, startupInfo, errorInfo);
2068	if (RT_SUCCESS(vrc))
2069	{
2070	if (errorInfo.guestRc == VWRN_GSTCTL_PROCESS_EXIT_CODE)
2071	{
2072	guestRc = GuestProcessTool::i_exitCodeToRc(startupInfo, errorInfo.lExitCode);
2073	}
2074	else
2075	guestRc = errorInfo.guestRc;
2076
2077	if (pGuestRc)
2078	*pGuestRc = guestRc;
2079	}
2080
2081	return vrc;
2082	}
2083
2084	/**
2085	* Static helper function to start and wait for a certain toolbox tool.
2086	*
2087	* @return IPRT status code.
2088	* @param pGuestSession Guest control session to use for starting the toolbox tool in.
2089	* @param startupInfo Startup information about the toolbox tool.
2090	* @param errorInfo Error information returned for error handling.
2091	*/
2092	/* static */
2093	int GuestProcessTool::i_runErrorInfo( GuestSession *pGuestSession,
2094	const GuestProcessStartupInfo &startupInfo,
2095	GuestProcessToolErrorInfo &errorInfo)
2096	{
2097	return i_runExErrorInfo(pGuestSession, startupInfo,
2098	NULL /* paStrmOutObjects /, 0 / cStrmOutObjects */,
2099	errorInfo);
2100	}
2101
2102	/**
2103	* Static helper function to start and wait for output of a certain toolbox tool.
2104	*
2105	* @return IPRT status code.
2106	* @param pGuestSession Guest control session to use for starting the toolbox tool in.
2107	* @param startupInfo Startup information about the toolbox tool.
2108	* @param paStrmOutObjects Pointer to stream objects array to use for retrieving the output of the toolbox tool.
2109	* Optional.
2110	* @param cStrmOutObjects Number of stream objects passed in. Optional.
2111	* @param pGuestRc Error code returned from the guest side if VERR_GSTCTL_GUEST_ERROR is returned. Optional.
2112	*/
2113	/* static */
2114	int GuestProcessTool::i_runEx( GuestSession *pGuestSession,
2115	const GuestProcessStartupInfo &startupInfo,
2116	GuestCtrlStreamObjects *paStrmOutObjects,
2117	uint32_t cStrmOutObjects,
2118	int pGuestRc / = NULL */)
2119	{
2120	int guestRc;
2121
2122	GuestProcessToolErrorInfo errorInfo;
2123	int vrc = GuestProcessTool::i_runExErrorInfo(pGuestSession, startupInfo, paStrmOutObjects, cStrmOutObjects, errorInfo);
2124	if (RT_SUCCESS(vrc))
2125	{
2126	if (errorInfo.guestRc == VWRN_GSTCTL_PROCESS_EXIT_CODE)
2127	{
2128	guestRc = GuestProcessTool::i_exitCodeToRc(startupInfo, errorInfo.lExitCode);
2129	}
2130	else
2131	guestRc = errorInfo.guestRc;
2132
2133	/* Return VERR_GSTCTL_GUEST_ERROR if we retrieved a guest return code. */
2134	if (RT_FAILURE(guestRc))
2135	vrc = VERR_GSTCTL_GUEST_ERROR;
2136
2137	if (pGuestRc)
2138	*pGuestRc = guestRc;
2139	}
2140
2141	return vrc;
2142	}
2143
2144	/**
2145	* Static helper function to start and wait for output of a certain toolbox tool.
2146	*
2147	* This is the extended version, which addds the possibility of retrieving parsable so-called guest stream
2148	* objects. Those objects are issued on the guest side as part of VBoxService's toolbox tools (think of a BusyBox-like approach)
2149	* on stdout and can be used on the host side to retrieve more information about the actual command issued on the guest side.
2150	*
2151	* @return IPRT status code.
2152	* @param pGuestSession Guest control session to use for starting the toolbox tool in.
2153	* @param startupInfo Startup information about the toolbox tool.
2154	* @param paStrmOutObjects Pointer to stream objects array to use for retrieving the output of the toolbox tool.
2155	* Optional.
2156	* @param cStrmOutObjects Number of stream objects passed in. Optional.
2157	* @param errorInfo Error information returned for error handling.
2158	*/
2159	/* static */
2160	int GuestProcessTool::i_runExErrorInfo( GuestSession *pGuestSession,
2161	const GuestProcessStartupInfo &startupInfo,
2162	GuestCtrlStreamObjects *paStrmOutObjects,
2163	uint32_t cStrmOutObjects,
2164	GuestProcessToolErrorInfo &errorInfo)
2165	{
2166	AssertPtrReturn(pGuestSession, VERR_INVALID_POINTER);
2167	/* paStrmOutObjects is optional. */
2168
2169	/** @todo Check if this is a valid toolbox. */
2170
2171	GuestProcessTool procTool;
2172	int vrc = procTool.Init(pGuestSession, startupInfo, false /* Async */, &errorInfo.guestRc);
2173	if (RT_SUCCESS(vrc))
2174	{
2175	while (cStrmOutObjects--)
2176	{
2177	try
2178	{
2179	GuestProcessStreamBlock strmBlk;
2180	vrc = procTool.i_waitEx( paStrmOutObjects
2181	? GUESTPROCESSTOOL_FLAG_STDOUT_BLOCK
2182	: GUESTPROCESSTOOL_FLAG_NONE, &strmBlk, &errorInfo.guestRc);
2183	if (paStrmOutObjects)
2184	paStrmOutObjects->push_back(strmBlk);
2185	}
2186	catch (std::bad_alloc)
2187	{
2188	vrc = VERR_NO_MEMORY;
2189	}
2190	}
2191	}
2192
2193	if (RT_SUCCESS(vrc))
2194	{
2195	/* Make sure the process runs until completion. */
2196	vrc = procTool.i_wait(GUESTPROCESSTOOL_FLAG_NONE, &errorInfo.guestRc);
2197	if (RT_SUCCESS(vrc))
2198	errorInfo.guestRc = procTool.i_terminatedOk(&errorInfo.lExitCode);
2199	}
2200
2201	LogFlowFunc(("Returned rc=%Rrc, guestRc=%Rrc, exitCode=%ld\n", vrc, errorInfo.guestRc, errorInfo.lExitCode));
2202	return vrc;
2203	}
2204
2205	/**
2206	* Reports if the tool has been run correctly.
2207	*
2208	* @return Will return VWRN_GSTCTL_PROCESS_EXIT_CODE if the tool process returned an exit code <> 0,
2209	* VERR_GSTCTL_PROCESS_WRONG_STATE if the tool process is in a wrong state (e.g. still running),
2210	* or VINF_SUCCESS otherwise.
2211	*
2212	* @param plExitCode Exit code of the tool. Optional.
2213	*/
2214	int GuestProcessTool::i_terminatedOk(LONG plExitCode / = NULL */)
2215	{
2216	Assert(!pProcess.isNull());
2217	/* pExitCode is optional. */
2218
2219	int vrc;
2220	if (!i_isRunning())
2221	{
2222	LONG lExitCode = -1;
2223	HRESULT hr = pProcess->COMGETTER(ExitCode(&lExitCode));
2224	AssertComRC(hr);
2225
2226	if (plExitCode)
2227	*plExitCode = lExitCode;
2228
2229	vrc = (lExitCode != 0)
2230	? VWRN_GSTCTL_PROCESS_EXIT_CODE : VINF_SUCCESS;
2231	}
2232	else
2233	vrc = VERR_GSTCTL_PROCESS_WRONG_STATE;
2234
2235	LogFlowFuncLeaveRC(vrc);
2236	return vrc;
2237	}
2238
2239	int GuestProcessTool::i_wait(uint32_t fFlags, int *pGuestRc)
2240	{
2241	return i_waitEx(fFlags, NULL /* pStrmBlkOut */, pGuestRc);
2242	}
2243
2244	int GuestProcessTool::i_waitEx(uint32_t fFlags, GuestProcessStreamBlock pStrmBlkOut, int pGuestRc)
2245	{
2246	LogFlowThisFunc(("fFlags=0x%x, pStreamBlock=%p, pGuestRc=%p\n",
2247	fFlags, pStrmBlkOut, pGuestRc));
2248
2249	/* Can we parse the next block without waiting? */
2250	int vrc;
2251	if (fFlags & GUESTPROCESSTOOL_FLAG_STDOUT_BLOCK)
2252	{
2253	AssertPtr(pStrmBlkOut);
2254	vrc = i_getCurrentBlock(OUTPUT_HANDLE_ID_STDOUT, *pStrmBlkOut);
2255	if (RT_SUCCESS(vrc))
2256	return vrc;
2257	/* else do the waiting below. */
2258	}
2259
2260	/* Do the waiting. */
2261	uint32_t fWaitFlags = ProcessWaitForFlag_Terminate;
2262	if (mStartupInfo.mFlags & ProcessCreateFlag_WaitForStdOut)
2263	fWaitFlags \|= ProcessWaitForFlag_StdOut;
2264	if (mStartupInfo.mFlags & ProcessCreateFlag_WaitForStdErr)
2265	fWaitFlags \|= ProcessWaitForFlag_StdErr;
2266
2267	/** @todo Decrease timeout while running. */
2268	uint64_t u64StartMS = RTTimeMilliTS();
2269	uint32_t uTimeoutMS = mStartupInfo.mTimeoutMS;
2270
2271	int vrcGuest = VINF_SUCCESS;
2272	bool fDone = false;
2273
2274	BYTE byBuf[_64K];
2275	uint32_t cbRead;
2276
2277	bool fHandleStdOut = false;
2278	bool fHandleStdErr = false;
2279
2280	/**
2281	* Updates the elapsed time and checks if a
2282	* timeout happened, then breaking out of the loop.
2283	*/
2284	#define UPDATE_AND_CHECK_ELAPSED_TIME() \
2285	u64ElapsedMS = RTTimeMilliTS() - u64StartMS; \
2286	if ( uTimeoutMS != RT_INDEFINITE_WAIT \
2287	&& u64ElapsedMS >= uTimeoutMS) \
2288	{ \
2289	vrc = VERR_TIMEOUT; \
2290	break; \
2291	}
2292
2293	/**
2294	* Returns the remaining time (in ms).
2295	*/
2296	#define GET_REMAINING_TIME \
2297	uTimeoutMS == RT_INDEFINITE_WAIT \
2298	? RT_INDEFINITE_WAIT : uTimeoutMS - (uint32_t)u64ElapsedMS \
2299
2300	ProcessWaitResult_T waitRes = ProcessWaitResult_None;
2301	do
2302	{
2303	uint64_t u64ElapsedMS;
2304	UPDATE_AND_CHECK_ELAPSED_TIME();
2305
2306	vrc = pProcess->i_waitFor(fWaitFlags, GET_REMAINING_TIME,
2307	waitRes, &vrcGuest);
2308	if (RT_FAILURE(vrc))
2309	break;
2310
2311	switch (waitRes)
2312	{
2313	case ProcessWaitResult_StdIn:
2314	vrc = VERR_NOT_IMPLEMENTED;
2315	break;
2316
2317	case ProcessWaitResult_StdOut:
2318	fHandleStdOut = true;
2319	break;
2320
2321	case ProcessWaitResult_StdErr:
2322	fHandleStdErr = true;
2323	break;
2324
2325	case ProcessWaitResult_WaitFlagNotSupported:
2326	if (fWaitFlags & ProcessWaitForFlag_StdOut)
2327	fHandleStdOut = true;
2328	if (fWaitFlags & ProcessWaitForFlag_StdErr)
2329	fHandleStdErr = true;
2330	/* Since waiting for stdout / stderr is not supported by the guest,
2331	* wait a bit to not hog the CPU too much when polling for data. */
2332	RTThreadSleep(1); /* Optional, don't check rc. */
2333	break;
2334
2335	case ProcessWaitResult_Error:
2336	vrc = VERR_GSTCTL_GUEST_ERROR;
2337	break;
2338
2339	case ProcessWaitResult_Terminate:
2340	fDone = true;
2341	break;
2342
2343	case ProcessWaitResult_Timeout:
2344	vrc = VERR_TIMEOUT;
2345	break;
2346
2347	case ProcessWaitResult_Start:
2348	case ProcessWaitResult_Status:
2349	/* Not used here, just skip. */
2350	break;
2351
2352	default:
2353	AssertMsgFailed(("Unhandled process wait result %RU32\n", waitRes));
2354	break;
2355	}
2356
2357	if (RT_FAILURE(vrc))
2358	break;
2359
2360	if (fHandleStdOut)
2361	{
2362	UPDATE_AND_CHECK_ELAPSED_TIME();
2363
2364	cbRead = 0;
2365	vrc = pProcess->i_readData(OUTPUT_HANDLE_ID_STDOUT, sizeof(byBuf),
2366	GET_REMAINING_TIME,
2367	byBuf, sizeof(byBuf),
2368	&cbRead, &vrcGuest);
2369	if ( RT_FAILURE(vrc)
2370	\|\| vrc == VWRN_GSTCTL_OBJECTSTATE_CHANGED)
2371	break;
2372
2373	if (cbRead)
2374	{
2375	LogFlowThisFunc(("Received %RU32 bytes from stdout\n", cbRead));
2376	vrc = mStdOut.AddData(byBuf, cbRead);
2377
2378	if ( RT_SUCCESS(vrc)
2379	&& (fFlags & GUESTPROCESSTOOL_FLAG_STDOUT_BLOCK))
2380	{
2381	AssertPtr(pStrmBlkOut);
2382	vrc = i_getCurrentBlock(OUTPUT_HANDLE_ID_STDOUT, *pStrmBlkOut);
2383
2384	/* When successful, break out of the loop because we're done
2385	* with reading the first stream block. */
2386	if (RT_SUCCESS(vrc))
2387	fDone = true;
2388	}
2389	}
2390
2391	fHandleStdOut = false;
2392	}
2393
2394	if (fHandleStdErr)
2395	{
2396	UPDATE_AND_CHECK_ELAPSED_TIME();
2397
2398	cbRead = 0;
2399	vrc = pProcess->i_readData(OUTPUT_HANDLE_ID_STDERR, sizeof(byBuf),
2400	GET_REMAINING_TIME,
2401	byBuf, sizeof(byBuf),
2402	&cbRead, &vrcGuest);
2403	if ( RT_FAILURE(vrc)
2404	\|\| vrc == VWRN_GSTCTL_OBJECTSTATE_CHANGED)
2405	break;
2406
2407	if (cbRead)
2408	{
2409	LogFlowThisFunc(("Received %RU32 bytes from stderr\n", cbRead));
2410	vrc = mStdErr.AddData(byBuf, cbRead);
2411	}
2412
2413	fHandleStdErr = false;
2414	}
2415
2416	} while (!fDone && RT_SUCCESS(vrc));
2417
2418	#undef UPDATE_AND_CHECK_ELAPSED_TIME
2419	#undef GET_REMAINING_TIME
2420
2421	if (RT_FAILURE(vrcGuest))
2422	vrc = VERR_GSTCTL_GUEST_ERROR;
2423
2424	LogFlowThisFunc(("Loop ended with rc=%Rrc, vrcGuest=%Rrc, waitRes=%RU32\n",
2425	vrc, vrcGuest, waitRes));
2426	if (pGuestRc)
2427	*pGuestRc = vrcGuest;
2428
2429	LogFlowFuncLeaveRC(vrc);
2430	return vrc;
2431	}
2432
2433	int GuestProcessTool::i_terminate(uint32_t uTimeoutMS, int *pGuestRc)
2434	{
2435	LogFlowThisFuncEnter();
2436
2437	int rc = VINF_SUCCESS;
2438	if (!pProcess.isNull())
2439	{
2440	rc = pProcess->i_terminateProcess(uTimeoutMS, pGuestRc);
2441	pProcess.setNull();
2442	}
2443	else
2444	rc = VERR_NOT_FOUND;
2445
2446	LogFlowFuncLeaveRC(rc);
2447	return rc;
2448	}
2449
2450	/**
2451	* Converts a toolbox tool's exit code to an IPRT error code.
2452	*
2453	* @return int Returned IPRT error for the particular tool.
2454	* @param startupInfo Startup info of the toolbox tool to lookup error code for.
2455	* @param lExitCode The toolbox tool's exit code to lookup IPRT error for.
2456	*/
2457	/* static */
2458	int GuestProcessTool::i_exitCodeToRc(const GuestProcessStartupInfo &startupInfo, LONG lExitCode)
2459	{
2460	if (startupInfo.mArguments.size() == 0)
2461	{
2462	AssertFailed();
2463	return VERR_GENERAL_FAILURE; /* Should not happen. */
2464	}
2465
2466	return i_exitCodeToRc(startupInfo.mArguments[0].c_str(), lExitCode);
2467	}
2468
2469	/**
2470	* Converts a toolbox tool's exit code to an IPRT error code.
2471	*
2472	* @return Returned IPRT error for the particular tool.
2473	* @param pszTool Name of toolbox tool to lookup error code for.
2474	* @param lExitCode The toolbox tool's exit code to lookup IPRT error for.
2475	*/
2476	/* static */
2477	int GuestProcessTool::i_exitCodeToRc(const char *pszTool, LONG lExitCode)
2478	{
2479	AssertPtrReturn(pszTool, VERR_INVALID_POINTER);
2480
2481	LogFlowFunc(("%s: %ld\n", pszTool, lExitCode));
2482
2483	if (lExitCode == 0) /* No error? Bail out early. */
2484	return VINF_SUCCESS;
2485
2486	if (!RTStrICmp(pszTool, VBOXSERVICE_TOOL_CAT))
2487	{
2488	switch (lExitCode)
2489	{
2490	case VBOXSERVICETOOLBOX_CAT_EXITCODE_ACCESS_DENIED: return VERR_ACCESS_DENIED;
2491	case VBOXSERVICETOOLBOX_CAT_EXITCODE_FILE_NOT_FOUND: return VERR_FILE_NOT_FOUND;
2492	case VBOXSERVICETOOLBOX_CAT_EXITCODE_PATH_NOT_FOUND: return VERR_PATH_NOT_FOUND;
2493	case VBOXSERVICETOOLBOX_CAT_EXITCODE_SHARING_VIOLATION: return VERR_SHARING_VIOLATION;
2494	default:
2495	break;
2496	}
2497	}
2498	else if (!RTStrICmp(pszTool, VBOXSERVICE_TOOL_STAT))
2499	{
2500	switch (lExitCode)
2501	{
2502	case VBOXSERVICETOOLBOX_STAT_EXITCODE_ACCESS_DENIED: return VERR_ACCESS_DENIED;
2503	case VBOXSERVICETOOLBOX_STAT_EXITCODE_FILE_NOT_FOUND: return VERR_FILE_NOT_FOUND;
2504	case VBOXSERVICETOOLBOX_STAT_EXITCODE_PATH_NOT_FOUND: return VERR_PATH_NOT_FOUND;
2505	default:
2506	break;
2507	}
2508	}
2509
2510	AssertMsgFailed(("Error code %ld for tool '%s' not handled\n", lExitCode, pszTool));
2511	return VERR_GENERAL_FAILURE;
2512	}
2513

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

source: vbox/trunk/src/VBox/Main/src-client/GuestProcessImpl.cpp@ 67414

Download in other formats: