GuestProcessImpl.cpp@ 56268

Last change on this file since 56268 was 55645, checked in by vboxsync, 10 years ago
Removed 106 #ifdef/#ifndef VBOX_WITH_GUEST_CONTROL statements that was never really necessary.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 71.5 KB

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

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

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

Download in other formats: