GuestSessionImpl.cpp@ 47167

Last change on this file since 47167 was 45805, checked in by vboxsync, 12 years ago
Main: Removed IGuestErrorInfo, added new attribute resultDetail to IVirtualBoxErrorInfo for (optionally) providing more details on the error happened.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 91.1 KB

Line
1
2	/* $Id: GuestSessionImpl.cpp 45805 2013-04-29 12:30:50Z vboxsync $ */
3	/** @file
4	* VirtualBox Main - Guest session handling.
5	*/
6
7	/*
8	* Copyright (C) 2012-2013 Oracle Corporation
9	*
10	* This file is part of VirtualBox Open Source Edition (OSE), as
11	* available from http://www.virtualbox.org. This file is free software;
12	* you can redistribute it and/or modify it under the terms of the GNU
13	* General Public License (GPL) as published by the Free Software
14	* Foundation, in version 2 as it comes in the "COPYING" file of the
15	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17	*/
18
19
20	/*******************************************************************************
21	* Header Files *
22	*******************************************************************************/
23	#include "GuestImpl.h"
24	#include "GuestSessionImpl.h"
25	#include "GuestCtrlImplPrivate.h"
26	#include "VirtualBoxErrorInfoImpl.h"
27
28	#include "Global.h"
29	#include "AutoCaller.h"
30	#include "ProgressImpl.h"
31	#include "VBoxEvents.h"
32	#include "VMMDev.h"
33
34	#include <memory> /* For auto_ptr. */
35
36	#include <iprt/cpp/utils.h> /* For unconst(). */
37	#include <iprt/env.h>
38	#include <iprt/file.h> /* For CopyTo/From. */
39
40	#include <VBox/com/array.h>
41	#include <VBox/com/listeners.h>
42	#include <VBox/version.h>
43
44	#ifdef LOG_GROUP
45	#undef LOG_GROUP
46	#endif
47	#define LOG_GROUP LOG_GROUP_GUEST_CONTROL
48	#include <VBox/log.h>
49
50
51	/**
52	* Base class representing an internal
53	* asynchronous session task.
54	*/
55	class GuestSessionTaskInternal
56	{
57	public:
58
59	GuestSessionTaskInternal(GuestSession *pSession)
60	: mSession(pSession),
61	mRC(VINF_SUCCESS) { }
62
63	virtual ~GuestSessionTaskInternal(void) { }
64
65	int rc(void) const { return mRC; }
66	bool isOk(void) const { return RT_SUCCESS(mRC); }
67	const ComObjPtr<GuestSession> &Session(void) const { return mSession; }
68
69	protected:
70
71	const ComObjPtr<GuestSession> mSession;
72	int mRC;
73	};
74
75	/**
76	* Class for asynchronously opening a guest session.
77	*/
78	class GuestSessionTaskInternalOpen : public GuestSessionTaskInternal
79	{
80	public:
81
82	GuestSessionTaskInternalOpen(GuestSession *pSession)
83	: GuestSessionTaskInternal(pSession) { }
84	};
85
86	/**
87	* Internal listener class to serve events in an
88	* active manner, e.g. without polling delays.
89	*/
90	class GuestSessionListener
91	{
92	public:
93
94	GuestSessionListener(void)
95	{
96	}
97
98	HRESULT init(GuestSession *pSession)
99	{
100	mSession = pSession;
101	return S_OK;
102	}
103
104	void uninit(void)
105	{
106	mSession.setNull();
107	}
108
109	STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent *aEvent)
110	{
111	switch (aType)
112	{
113	case VBoxEventType_OnGuestSessionStateChanged:
114	{
115	Assert(!mSession.isNull());
116	int rc2 = mSession->signalWaitEvents(aType, aEvent);
117	#ifdef DEBUG_andy
118	LogFlowFunc(("Signalling events of type=%ld, session=%p resulted in rc=%Rrc\n",
119	aType, mSession, rc2));
120	#endif
121	break;
122	}
123
124	default:
125	AssertMsgFailed(("Unhandled event %ld\n", aType));
126	break;
127	}
128
129	return S_OK;
130	}
131
132	private:
133
134	ComObjPtr<GuestSession> mSession;
135	};
136	typedef ListenerImpl<GuestSessionListener, GuestSession*> GuestSessionListenerImpl;
137
138	VBOX_LISTENER_DECLARE(GuestSessionListenerImpl)
139
140	// constructor / destructor
141	/////////////////////////////////////////////////////////////////////////////
142
143	DEFINE_EMPTY_CTOR_DTOR(GuestSession)
144
145	HRESULT GuestSession::FinalConstruct(void)
146	{
147	LogFlowThisFunc(("\n"));
148	return BaseFinalConstruct();
149	}
150
151	void GuestSession::FinalRelease(void)
152	{
153	LogFlowThisFuncEnter();
154	uninit();
155	BaseFinalRelease();
156	LogFlowThisFuncLeave();
157	}
158
159	// public initializer/uninitializer for internal purposes only
160	/////////////////////////////////////////////////////////////////////////////
161
162	/**
163	* Initializes a guest session but does not open in on the guest side
164	* yet. This needs to be done via the openSession() / openSessionAsync calls.
165	*
166	* @return IPRT status code.
167	** @todo Docs!
168	*/
169	int GuestSession::init(Guest *pGuest, const GuestSessionStartupInfo &ssInfo,
170	const GuestCredentials &guestCreds)
171	{
172	LogFlowThisFunc(("pGuest=%p, ssInfo=%p, guestCreds=%p\n",
173	pGuest, &ssInfo, &guestCreds));
174
175	/* Enclose the state transition NotReady->InInit->Ready. */
176	AutoInitSpan autoInitSpan(this);
177	AssertReturn(autoInitSpan.isOk(), VERR_OBJECT_DESTROYED);
178
179	#ifndef VBOX_WITH_GUEST_CONTROL
180	autoInitSpan.setSucceeded();
181	return VINF_SUCCESS;
182	#else
183	AssertPtrReturn(pGuest, VERR_INVALID_POINTER);
184
185	mParent = pGuest;
186
187	/* Copy over startup info. */
188	/** @todo Use an overloaded copy operator. Later. */
189	mData.mSession.mID = ssInfo.mID;
190	mData.mSession.mIsInternal = ssInfo.mIsInternal;
191	mData.mSession.mName = ssInfo.mName;
192	mData.mSession.mOpenFlags = ssInfo.mOpenFlags;
193	mData.mSession.mOpenTimeoutMS = ssInfo.mOpenTimeoutMS;
194
195	/** @todo Use an overloaded copy operator. Later. */
196	mData.mCredentials.mUser = guestCreds.mUser;
197	mData.mCredentials.mPassword = guestCreds.mPassword;
198	mData.mCredentials.mDomain = guestCreds.mDomain;
199
200	mData.mRC = VINF_SUCCESS;
201	mData.mStatus = GuestSessionStatus_Undefined;
202	mData.mNumObjects = 0;
203
204	HRESULT hr;
205
206	int rc = queryInfo();
207	if (RT_SUCCESS(rc))
208	{
209	unconst(mEventSource).createObject();
210	Assert(!mEventSource.isNull());
211	hr = mEventSource->init(static_cast<IGuestSession*>(this));
212	if (FAILED(hr))
213	rc = VERR_COM_UNEXPECTED;
214	}
215
216	if (RT_SUCCESS(rc))
217	{
218	try
219	{
220	GuestSessionListener *pListener = new GuestSessionListener();
221	ComObjPtr<GuestSessionListenerImpl> thisListener;
222	hr = thisListener.createObject();
223	if (SUCCEEDED(hr))
224	hr = thisListener->init(pListener, this);
225
226	if (SUCCEEDED(hr))
227	{
228	mListener = thisListener;
229
230	com::SafeArray <VBoxEventType_T> eventTypes;
231	eventTypes.push_back(VBoxEventType_OnGuestSessionStateChanged);
232	hr = mEventSource->RegisterListener(mListener,
233	ComSafeArrayAsInParam(eventTypes),
234	TRUE /* Active listener */);
235	if (SUCCEEDED(hr))
236	{
237	rc = RTCritSectInit(&mWaitEventCritSect);
238	AssertRC(rc);
239	}
240	else
241	rc = VERR_COM_UNEXPECTED;
242	}
243	else
244	rc = VERR_COM_UNEXPECTED;
245	}
246	catch(std::bad_alloc &)
247	{
248	rc = VERR_NO_MEMORY;
249	}
250	}
251
252	if (RT_SUCCESS(rc))
253	{
254	/* Confirm a successful initialization when it's the case. */
255	autoInitSpan.setSucceeded();
256	}
257	else
258	autoInitSpan.setFailed();
259
260	LogFlowFuncLeaveRC(rc);
261	return rc;
262	#endif /* VBOX_WITH_GUEST_CONTROL */
263	}
264
265	/**
266	* Uninitializes the instance.
267	* Called from FinalRelease().
268	*/
269	void GuestSession::uninit(void)
270	{
271	LogFlowThisFuncEnter();
272
273	/* Enclose the state transition Ready->InUninit->NotReady. */
274	AutoUninitSpan autoUninitSpan(this);
275	if (autoUninitSpan.uninitDone())
276	return;
277
278	int rc = VINF_SUCCESS;
279
280	#ifdef VBOX_WITH_GUEST_CONTROL
281	LogFlowThisFunc(("Closing directories (%RU64 total)\n",
282	mData.mDirectories.size()));
283	for (SessionDirectories::iterator itDirs = mData.mDirectories.begin();
284	itDirs != mData.mDirectories.end(); ++itDirs)
285	{
286	(*itDirs)->uninit();
287	}
288	mData.mDirectories.clear();
289
290	LogFlowThisFunc(("Closing files (%RU64 total)\n",
291	mData.mFiles.size()));
292	for (SessionFiles::iterator itFiles = mData.mFiles.begin();
293	itFiles != mData.mFiles.end(); ++itFiles)
294	{
295	itFiles->second->uninit();
296	}
297	mData.mFiles.clear();
298
299	LogFlowThisFunc(("Closing processes (%RU64 total)\n",
300	mData.mProcesses.size()));
301	for (SessionProcesses::iterator itProcs = mData.mProcesses.begin();
302	itProcs != mData.mProcesses.end(); ++itProcs)
303	{
304	itProcs->second->uninit();
305	}
306	mData.mProcesses.clear();
307
308	LogFlowThisFunc(("mNumObjects=%RU32\n", mData.mNumObjects));
309
310	unconst(mEventSource).setNull();
311	unregisterEventListener();
312
313	#endif /* VBOX_WITH_GUEST_CONTROL */
314	LogFlowFuncLeaveRC(rc);
315	}
316
317	// implementation of public getters/setters for attributes
318	/////////////////////////////////////////////////////////////////////////////
319
320	STDMETHODIMP GuestSession::COMGETTER(User)(BSTR *aUser)
321	{
322	#ifndef VBOX_WITH_GUEST_CONTROL
323	ReturnComNotImplemented();
324	#else
325	LogFlowThisFuncEnter();
326
327	CheckComArgOutPointerValid(aUser);
328
329	AutoCaller autoCaller(this);
330	if (FAILED(autoCaller.rc())) return autoCaller.rc();
331
332	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
333
334	mData.mCredentials.mUser.cloneTo(aUser);
335
336	LogFlowFuncLeaveRC(S_OK);
337	return S_OK;
338	#endif /* VBOX_WITH_GUEST_CONTROL */
339	}
340
341	STDMETHODIMP GuestSession::COMGETTER(Domain)(BSTR *aDomain)
342	{
343	#ifndef VBOX_WITH_GUEST_CONTROL
344	ReturnComNotImplemented();
345	#else
346	LogFlowThisFuncEnter();
347
348	CheckComArgOutPointerValid(aDomain);
349
350	AutoCaller autoCaller(this);
351	if (FAILED(autoCaller.rc())) return autoCaller.rc();
352
353	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
354
355	mData.mCredentials.mDomain.cloneTo(aDomain);
356
357	LogFlowFuncLeaveRC(S_OK);
358	return S_OK;
359	#endif /* VBOX_WITH_GUEST_CONTROL */
360	}
361
362	STDMETHODIMP GuestSession::COMGETTER(Name)(BSTR *aName)
363	{
364	#ifndef VBOX_WITH_GUEST_CONTROL
365	ReturnComNotImplemented();
366	#else
367	LogFlowThisFuncEnter();
368
369	CheckComArgOutPointerValid(aName);
370
371	AutoCaller autoCaller(this);
372	if (FAILED(autoCaller.rc())) return autoCaller.rc();
373
374	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
375
376	mData.mSession.mName.cloneTo(aName);
377
378	LogFlowFuncLeaveRC(S_OK);
379	return S_OK;
380	#endif /* VBOX_WITH_GUEST_CONTROL */
381	}
382
383	STDMETHODIMP GuestSession::COMGETTER(Id)(ULONG *aId)
384	{
385	#ifndef VBOX_WITH_GUEST_CONTROL
386	ReturnComNotImplemented();
387	#else
388	LogFlowThisFuncEnter();
389
390	CheckComArgOutPointerValid(aId);
391
392	AutoCaller autoCaller(this);
393	if (FAILED(autoCaller.rc())) return autoCaller.rc();
394
395	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
396
397	*aId = mData.mSession.mID;
398
399	LogFlowFuncLeaveRC(S_OK);
400	return S_OK;
401	#endif /* VBOX_WITH_GUEST_CONTROL */
402	}
403
404	STDMETHODIMP GuestSession::COMGETTER(Status)(GuestSessionStatus_T *aStatus)
405	{
406	#ifndef VBOX_WITH_GUEST_CONTROL
407	ReturnComNotImplemented();
408	#else
409	LogFlowThisFuncEnter();
410
411	CheckComArgOutPointerValid(aStatus);
412
413	AutoCaller autoCaller(this);
414	if (FAILED(autoCaller.rc())) return autoCaller.rc();
415
416	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
417
418	*aStatus = mData.mStatus;
419
420	LogFlowFuncLeaveRC(S_OK);
421	return S_OK;
422	#endif /* VBOX_WITH_GUEST_CONTROL */
423	}
424
425	STDMETHODIMP GuestSession::COMGETTER(Timeout)(ULONG *aTimeout)
426	{
427	#ifndef VBOX_WITH_GUEST_CONTROL
428	ReturnComNotImplemented();
429	#else
430	LogFlowThisFuncEnter();
431
432	CheckComArgOutPointerValid(aTimeout);
433
434	AutoCaller autoCaller(this);
435	if (FAILED(autoCaller.rc())) return autoCaller.rc();
436
437	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
438
439	*aTimeout = mData.mTimeout;
440
441	LogFlowFuncLeaveRC(S_OK);
442	return S_OK;
443	#endif /* VBOX_WITH_GUEST_CONTROL */
444	}
445
446	STDMETHODIMP GuestSession::COMSETTER(Timeout)(ULONG aTimeout)
447	{
448	#ifndef VBOX_WITH_GUEST_CONTROL
449	ReturnComNotImplemented();
450	#else
451	LogFlowThisFuncEnter();
452
453	AutoCaller autoCaller(this);
454	if (FAILED(autoCaller.rc())) return autoCaller.rc();
455
456	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
457
458	mData.mTimeout = aTimeout;
459
460	LogFlowFuncLeaveRC(S_OK);
461	return S_OK;
462	#endif /* VBOX_WITH_GUEST_CONTROL */
463	}
464
465	STDMETHODIMP GuestSession::COMGETTER(Environment)(ComSafeArrayOut(BSTR, aEnvironment))
466	{
467	#ifndef VBOX_WITH_GUEST_CONTROL
468	ReturnComNotImplemented();
469	#else
470	LogFlowThisFuncEnter();
471
472	CheckComArgOutSafeArrayPointerValid(aEnvironment);
473
474	AutoCaller autoCaller(this);
475	if (FAILED(autoCaller.rc())) return autoCaller.rc();
476
477	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
478
479	size_t cEnvVars = mData.mEnvironment.Size();
480	LogFlowThisFunc(("[%s]: cEnvVars=%RU32\n",
481	mData.mSession.mName.c_str(), cEnvVars));
482	com::SafeArray<BSTR> environment(cEnvVars);
483
484	for (size_t i = 0; i < cEnvVars; i++)
485	{
486	Bstr strEnv(mData.mEnvironment.Get(i));
487	strEnv.cloneTo(&environment[i]);
488	}
489	environment.detachTo(ComSafeArrayOutArg(aEnvironment));
490
491	LogFlowFuncLeaveRC(S_OK);
492	return S_OK;
493	#endif /* VBOX_WITH_GUEST_CONTROL */
494	}
495
496	STDMETHODIMP GuestSession::COMSETTER(Environment)(ComSafeArrayIn(IN_BSTR, aValues))
497	{
498	#ifndef VBOX_WITH_GUEST_CONTROL
499	ReturnComNotImplemented();
500	#else
501	LogFlowThisFuncEnter();
502
503	AutoCaller autoCaller(this);
504	if (FAILED(autoCaller.rc())) return autoCaller.rc();
505
506	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
507
508	com::SafeArray<IN_BSTR> environment(ComSafeArrayInArg(aValues));
509
510	int rc = VINF_SUCCESS;
511	for (size_t i = 0; i < environment.size() && RT_SUCCESS(rc); i++)
512	{
513	Utf8Str strEnv(environment[i]);
514	if (!strEnv.isEmpty()) /* Silently skip empty entries. */
515	rc = mData.mEnvironment.Set(strEnv);
516	}
517
518	HRESULT hr = RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
519	LogFlowFuncLeaveRC(hr);
520	return hr;
521	#endif /* VBOX_WITH_GUEST_CONTROL */
522	}
523
524	STDMETHODIMP GuestSession::COMGETTER(Processes)(ComSafeArrayOut(IGuestProcess *, aProcesses))
525	{
526	#ifndef VBOX_WITH_GUEST_CONTROL
527	ReturnComNotImplemented();
528	#else
529	LogFlowThisFuncEnter();
530
531	CheckComArgOutSafeArrayPointerValid(aProcesses);
532
533	AutoCaller autoCaller(this);
534	if (FAILED(autoCaller.rc())) return autoCaller.rc();
535
536	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
537
538	SafeIfaceArray<IGuestProcess> collection(mData.mProcesses);
539	collection.detachTo(ComSafeArrayOutArg(aProcesses));
540
541	LogFlowFuncLeaveRC(S_OK);
542	return S_OK;
543	#endif /* VBOX_WITH_GUEST_CONTROL */
544	}
545
546	STDMETHODIMP GuestSession::COMGETTER(Directories)(ComSafeArrayOut(IGuestDirectory *, aDirectories))
547	{
548	#ifndef VBOX_WITH_GUEST_CONTROL
549	ReturnComNotImplemented();
550	#else
551	LogFlowThisFuncEnter();
552
553	CheckComArgOutSafeArrayPointerValid(aDirectories);
554
555	AutoCaller autoCaller(this);
556	if (FAILED(autoCaller.rc())) return autoCaller.rc();
557
558	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
559
560	SafeIfaceArray<IGuestDirectory> collection(mData.mDirectories);
561	collection.detachTo(ComSafeArrayOutArg(aDirectories));
562
563	LogFlowFuncLeaveRC(S_OK);
564	return S_OK;
565	#endif /* VBOX_WITH_GUEST_CONTROL */
566	}
567
568	STDMETHODIMP GuestSession::COMGETTER(Files)(ComSafeArrayOut(IGuestFile *, aFiles))
569	{
570	#ifndef VBOX_WITH_GUEST_CONTROL
571	ReturnComNotImplemented();
572	#else
573	LogFlowThisFuncEnter();
574
575	CheckComArgOutSafeArrayPointerValid(aFiles);
576
577	AutoCaller autoCaller(this);
578	if (FAILED(autoCaller.rc())) return autoCaller.rc();
579
580	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
581
582	SafeIfaceArray<IGuestFile> collection(mData.mFiles);
583	collection.detachTo(ComSafeArrayOutArg(aFiles));
584
585	LogFlowFuncLeaveRC(S_OK);
586	return S_OK;
587	#endif /* VBOX_WITH_GUEST_CONTROL */
588	}
589
590	STDMETHODIMP GuestSession::COMGETTER(EventSource)(IEventSource ** aEventSource)
591	{
592	#ifndef VBOX_WITH_GUEST_CONTROL
593	ReturnComNotImplemented();
594	#else
595	LogFlowThisFuncEnter();
596
597	CheckComArgOutPointerValid(aEventSource);
598
599	AutoCaller autoCaller(this);
600	if (FAILED(autoCaller.rc())) return autoCaller.rc();
601
602	// no need to lock - lifetime constant
603	mEventSource.queryInterfaceTo(aEventSource);
604
605	LogFlowFuncLeaveRC(S_OK);
606	return S_OK;
607	#endif /* VBOX_WITH_GUEST_CONTROL */
608	}
609
610	// private methods
611	///////////////////////////////////////////////////////////////////////////////
612
613	int GuestSession::closeSession(uint32_t uFlags, uint32_t uTimeoutMS, int *pGuestRc)
614	{
615	LogFlowThisFunc(("uFlags=%x, uTimeoutMS=%RU32\n", uFlags, uTimeoutMS));
616
617	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
618
619	/* Legacy Guest Additions don't support opening dedicated
620	guest sessions. */
621	if (mData.mProtocolVersion < 2)
622	{
623	LogFlowThisFunc(("Installed Guest Additions don't support closing dedicated sessions, skipping\n"));
624	return VINF_SUCCESS;
625	}
626
627	/** @todo uFlags validation. */
628
629	if (mData.mStatus != GuestSessionStatus_Started)
630	return VINF_SUCCESS;
631
632	int vrc;
633
634	GuestWaitEvent *pEvent = NULL;
635	std::list < VBoxEventType_T > eventTypes;
636	try
637	{
638	eventTypes.push_back(VBoxEventType_OnGuestSessionStateChanged);
639
640	vrc = registerEvent(mData.mSession.mID, 0 /* Object ID */,
641	eventTypes, &pEvent);
642	}
643	catch (std::bad_alloc)
644	{
645	vrc = VERR_NO_MEMORY;
646	}
647
648	if (RT_FAILURE(vrc))
649	return vrc;
650
651	LogFlowThisFunc(("Sending closing request to guest session ID=%RU32, uFlags=%x\n",
652	mData.mSession.mID, uFlags));
653
654	VBOXHGCMSVCPARM paParms[4];
655	int i = 0;
656	paParms[i++].setUInt32(pEvent->ContextID());
657	paParms[i++].setUInt32(uFlags);
658
659	vrc = sendCommand(HOST_SESSION_CLOSE, i, paParms);
660	if (RT_SUCCESS(vrc))
661	{
662	alock.release(); /* Drop the write lock before waiting. */
663
664	vrc = waitForStatusChange(pEvent, GuestSessionWaitForFlag_Terminate, uTimeoutMS,
665	NULL /* Session status */, pGuestRc);
666	}
667
668	unregisterEvent(pEvent);
669
670	LogFlowFuncLeaveRC(vrc);
671	return vrc;
672	}
673
674	int GuestSession::directoryRemoveFromList(GuestDirectory *pDirectory)
675	{
676	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
677
678	for (SessionDirectories::iterator itDirs = mData.mDirectories.begin();
679	itDirs != mData.mDirectories.end(); ++itDirs)
680	{
681	if (pDirectory == (*itDirs))
682	{
683	Bstr strName;
684	HRESULT hr = (*itDirs)->COMGETTER(DirectoryName)(strName.asOutParam());
685	ComAssertComRC(hr);
686
687	Assert(mData.mDirectories.size());
688	LogFlowFunc(("Removing directory \"%s\" (Session: %RU32) (now total %ld directories)\n",
689	Utf8Str(strName).c_str(), mData.mSession.mID, mData.mDirectories.size() - 1));
690
691	mData.mDirectories.erase(itDirs);
692	return VINF_SUCCESS;
693	}
694	}
695
696	return VERR_NOT_FOUND;
697	}
698
699	int GuestSession::directoryCreateInternal(const Utf8Str &strPath, uint32_t uMode, uint32_t uFlags, int *pGuestRc)
700	{
701	/* pGuestRc is optional. */
702
703	LogFlowThisFunc(("strPath=%s, uMode=%x, uFlags=%x\n",
704	strPath.c_str(), uMode, uFlags));
705
706	GuestProcessStartupInfo procInfo;
707	procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_MKDIR);
708	procInfo.mFlags = ProcessCreateFlag_Hidden;
709
710	int vrc = VINF_SUCCESS;
711
712	/* Construct arguments. */
713	if (uFlags & DirectoryCreateFlag_Parents)
714	procInfo.mArguments.push_back(Utf8Str("--parents")); /* We also want to create the parent directories. */
715	if (uMode)
716	{
717	procInfo.mArguments.push_back(Utf8Str("--mode")); /* Set the creation mode. */
718
719	char szMode[16];
720	if (RTStrPrintf(szMode, sizeof(szMode), "%o", uMode))
721	{
722	procInfo.mArguments.push_back(Utf8Str(szMode));
723	}
724	else
725	vrc = VERR_BUFFER_OVERFLOW;
726	}
727	procInfo.mArguments.push_back(strPath); /* The directory we want to create. */
728
729	if (RT_SUCCESS(vrc))
730	{
731	int guestRc;
732	GuestProcessTool procTool;
733	vrc = procTool.Init(this, procInfo, false /* Async */, &guestRc);
734	if (RT_SUCCESS(vrc))
735	{
736	if (RT_SUCCESS(guestRc))
737	vrc = procTool.Wait(GUESTPROCESSTOOL_FLAG_NONE, &guestRc);
738	}
739
740	if (RT_SUCCESS(vrc))
741	{
742	if (RT_SUCCESS(guestRc))
743	guestRc = procTool.TerminatedOk(NULL /* Exit code */);
744	}
745
746	if ( vrc == VERR_GSTCTL_GUEST_ERROR
747	&& pGuestRc)
748	{
749	*pGuestRc = guestRc;
750	}
751	}
752
753	LogFlowFuncLeaveRC(vrc);
754	return vrc;
755	}
756
757	int GuestSession::directoryQueryInfoInternal(const Utf8Str &strPath, GuestFsObjData &objData, int *pGuestRc)
758	{
759	LogFlowThisFunc(("strPath=%s\n", strPath.c_str()));
760
761	int vrc = fsQueryInfoInternal(strPath, objData, pGuestRc);
762	if (RT_SUCCESS(vrc))
763	{
764	vrc = objData.mType == FsObjType_Directory
765	? VINF_SUCCESS : VERR_NOT_A_DIRECTORY;
766	}
767
768	LogFlowFuncLeaveRC(vrc);
769	return vrc;
770	}
771
772	int GuestSession::objectCreateTempInternal(const Utf8Str &strTemplate, const Utf8Str &strPath,
773	bool fDirectory, const Utf8Str &strName, int *pGuestRc)
774	{
775	GuestProcessStartupInfo procInfo;
776	procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_MKTEMP);
777	procInfo.mFlags = ProcessCreateFlag_WaitForStdOut;
778	procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
779	if (fDirectory)
780	procInfo.mArguments.push_back(Utf8Str("-d"));
781	if (strPath.length()) /* Otherwise use /tmp or equivalent. */
782	{
783	procInfo.mArguments.push_back(Utf8Str("-t"));
784	procInfo.mArguments.push_back(strPath);
785	}
786	procInfo.mArguments.push_back(strTemplate);
787
788	GuestProcessTool procTool; int guestRc;
789	int vrc = procTool.Init(this, procInfo, false /* Async */, &guestRc);
790	if (RT_SUCCESS(vrc))
791	{
792	if (RT_SUCCESS(guestRc))
793	vrc = procTool.Wait(GUESTPROCESSTOOL_FLAG_NONE, &guestRc);
794	}
795
796	if (RT_SUCCESS(vrc))
797	{
798	if (RT_SUCCESS(guestRc))
799	guestRc = procTool.TerminatedOk(NULL /* Exit code */);
800	}
801
802	if ( vrc == VERR_GSTCTL_GUEST_ERROR
803	&& pGuestRc)
804	{
805	*pGuestRc = guestRc;
806	}
807
808	LogFlowFuncLeaveRC(vrc);
809	return vrc;
810	}
811
812	int GuestSession::directoryOpenInternal(const Utf8Str &strPath, const Utf8Str &strFilter,
813	uint32_t uFlags, ComObjPtr<GuestDirectory> &pDirectory)
814	{
815	LogFlowThisFunc(("strPath=%s, strPath=%s, uFlags=%x\n",
816	strPath.c_str(), strFilter.c_str(), uFlags));
817
818	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
819
820	/* Create the directory object. */
821	HRESULT hr = pDirectory.createObject();
822	if (FAILED(hr))
823	return VERR_COM_UNEXPECTED;
824
825	int vrc = pDirectory->init(this /* Parent */,
826	strPath, strFilter, uFlags);
827	if (RT_FAILURE(vrc))
828	return vrc;
829
830	/* Add the created directory to our vector. */
831	mData.mDirectories.push_back(pDirectory);
832
833	LogFlowFunc(("Added new directory \"%s\" (Session: %RU32)\n",
834	strPath.c_str(), mData.mSession.mID));
835
836	LogFlowFuncLeaveRC(vrc);
837	return vrc;
838	}
839
840	int GuestSession::dispatchToFile(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
841	{
842	LogFlowFunc(("pCtxCb=%p, pSvcCb=%p\n", pCtxCb, pSvcCb));
843
844	AssertPtrReturn(pCtxCb, VERR_INVALID_POINTER);
845	AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
846
847	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
848
849	uint32_t uFileID = VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(pCtxCb->uContextID);
850	#ifdef DEBUG
851	LogFlowFunc(("uFileID=%RU32 (%RU32 total)\n",
852	uFileID, mData.mFiles.size()));
853	#endif
854	int rc;
855	SessionFiles::const_iterator itFile
856	= mData.mFiles.find(uFileID);
857	if (itFile != mData.mFiles.end())
858	{
859	ComObjPtr<GuestFile> pFile(itFile->second);
860	Assert(!pFile.isNull());
861
862	alock.release();
863
864	rc = pFile->callbackDispatcher(pCtxCb, pSvcCb);
865	}
866	else
867	rc = VERR_NOT_FOUND;
868
869	LogFlowFuncLeaveRC(rc);
870	return rc;
871	}
872
873	int GuestSession::dispatchToProcess(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
874	{
875	LogFlowFunc(("pCtxCb=%p, pSvcCb=%p\n", pCtxCb, pSvcCb));
876
877	AssertPtrReturn(pCtxCb, VERR_INVALID_POINTER);
878	AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
879
880	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
881
882	uint32_t uProcessID = VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(pCtxCb->uContextID);
883	#ifdef DEBUG
884	LogFlowFunc(("uProcessID=%RU32 (%RU32 total)\n",
885	uProcessID, mData.mProcesses.size()));
886	#endif
887	int rc;
888	SessionProcesses::const_iterator itProc
889	= mData.mProcesses.find(uProcessID);
890	if (itProc != mData.mProcesses.end())
891	{
892	ComObjPtr<GuestProcess> pProcess(itProc->second);
893	Assert(!pProcess.isNull());
894
895	/* Set protocol version so that pSvcCb can
896	* be interpreted right. */
897	pCtxCb->uProtocol = mData.mProtocolVersion;
898
899	alock.release();
900	rc = pProcess->callbackDispatcher(pCtxCb, pSvcCb);
901	}
902	else
903	rc = VERR_NOT_FOUND;
904
905	LogFlowFuncLeaveRC(rc);
906	return rc;
907	}
908
909	int GuestSession::dispatchToThis(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
910	{
911	AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
912	AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
913
914	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
915
916	#ifdef DEBUG
917	LogFlowThisFunc(("sessionID=%RU32, CID=%RU32, uFunction=%RU32, pSvcCb=%p\n",
918	mData.mSession.mID, pCbCtx->uContextID, pCbCtx->uFunction, pSvcCb));
919	#endif
920
921	int rc = VINF_SUCCESS;
922	switch (pCbCtx->uFunction)
923	{
924	case GUEST_DISCONNECTED:
925	/** @todo Handle closing all guest objects. */
926	break;
927
928	case GUEST_SESSION_NOTIFY:
929	{
930	rc = onSessionStatusChange(pCbCtx, pSvcCb);
931	break;
932	}
933
934	default:
935	/* Silently skip unknown callbacks. */
936	rc = VERR_NOT_SUPPORTED;
937	break;
938	}
939
940	LogFlowFuncLeaveRC(rc);
941	return rc;
942	}
943
944	inline bool GuestSession::fileExists(uint32_t uFileID, ComObjPtr<GuestFile> *pFile)
945	{
946	SessionFiles::const_iterator it = mData.mFiles.find(uFileID);
947	if (it != mData.mFiles.end())
948	{
949	if (pFile)
950	*pFile = it->second;
951	return true;
952	}
953	return false;
954	}
955
956	int GuestSession::fileRemoveFromList(GuestFile *pFile)
957	{
958	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
959
960	for (SessionFiles::iterator itFiles = mData.mFiles.begin();
961	itFiles != mData.mFiles.end(); ++itFiles)
962	{
963	if (pFile == itFiles->second)
964	{
965	GuestFile *pThis = itFiles->second;
966	AssertPtr(pThis);
967
968	Bstr strName;
969	HRESULT hr = pThis->COMGETTER(FileName)(strName.asOutParam());
970	ComAssertComRC(hr);
971
972	Assert(mData.mNumObjects);
973	LogFlowThisFunc(("Removing guest file \"%s\" (Session: %RU32) (now total %ld files, %ld objects)\n",
974	Utf8Str(strName).c_str(), mData.mSession.mID, mData.mFiles.size() - 1, mData.mNumObjects - 1));
975
976	mData.mFiles.erase(itFiles);
977	mData.mNumObjects--;
978
979	fireGuestFileRegisteredEvent(mEventSource, this, pFile,
980	false /* Unregistered */);
981	return VINF_SUCCESS;
982	}
983	}
984
985	return VERR_NOT_FOUND;
986	}
987
988	int GuestSession::fileRemoveInternal(const Utf8Str &strPath, int *pGuestRc)
989	{
990	GuestProcessStartupInfo procInfo;
991	GuestProcessStream streamOut;
992
993	procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_RM);
994	procInfo.mFlags = ProcessCreateFlag_WaitForStdOut;
995	procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
996	procInfo.mArguments.push_back(strPath); /* The file we want to remove. */
997
998	GuestProcessTool procTool; int guestRc;
999	int vrc = procTool.Init(this, procInfo, false /* Async */, &guestRc);
1000	if (RT_SUCCESS(vrc))
1001	vrc = procTool.Wait(GUESTPROCESSTOOL_FLAG_NONE, &guestRc);
1002
1003	if (RT_SUCCESS(vrc))
1004	{
1005	if (RT_SUCCESS(guestRc))
1006	guestRc = procTool.TerminatedOk(NULL /* Exit code */);
1007	}
1008
1009	if ( vrc == VERR_GSTCTL_GUEST_ERROR
1010	&& pGuestRc)
1011	{
1012	*pGuestRc = guestRc;
1013	}
1014
1015	LogFlowFuncLeaveRC(vrc);
1016	return vrc;
1017	}
1018
1019	int GuestSession::fileOpenInternal(const GuestFileOpenInfo &openInfo, ComObjPtr<GuestFile> &pFile, int *pGuestRc)
1020	{
1021	LogFlowThisFunc(("strPath=%s, strOpenMode=%s, strDisposition=%s, uCreationMode=%x, iOffset=%RI64\n",
1022	openInfo.mFileName.c_str(), openInfo.mOpenMode.c_str(), openInfo.mDisposition.c_str(),
1023	openInfo.mCreationMode, openInfo.mInitialOffset));
1024
1025	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1026
1027	int rc = VERR_MAX_PROCS_REACHED;
1028	if (mData.mNumObjects >= VBOX_GUESTCTRL_MAX_OBJECTS)
1029	return rc;
1030
1031	/* Create a new (host-based) file ID and assign it. */
1032	uint32_t uNewFileID = 0;
1033	ULONG uTries = 0;
1034
1035	for (;;)
1036	{
1037	/* Is the file ID already used? */
1038	if (!fileExists(uNewFileID, NULL /* pProgress */))
1039	{
1040	/* Callback with context ID was not found. This means
1041	* we can use this context ID for our new callback we want
1042	* to add below. */
1043	rc = VINF_SUCCESS;
1044	break;
1045	}
1046	uNewFileID++;
1047	if (uNewFileID == VBOX_GUESTCTRL_MAX_OBJECTS)
1048	uNewFileID = 0;
1049
1050	if (++uTries == UINT32_MAX)
1051	break; /* Don't try too hard. */
1052	}
1053
1054	if (RT_FAILURE(rc))
1055	return rc;
1056
1057	/* Create the directory object. */
1058	HRESULT hr = pFile.createObject();
1059	if (FAILED(hr))
1060	return VERR_COM_UNEXPECTED;
1061
1062	Console *pConsole = mParent->getConsole();
1063	AssertPtr(pConsole);
1064
1065	rc = pFile->init(pConsole, this /* GuestSession */,
1066	uNewFileID, openInfo);
1067	if (RT_FAILURE(rc))
1068	return rc;
1069
1070	int guestRc;
1071	rc = pFile->openFile(&guestRc);
1072	if (RT_SUCCESS(rc))
1073	{
1074	/* Add the created file to our vector. */
1075	mData.mFiles[uNewFileID] = pFile;
1076	mData.mNumObjects++;
1077	Assert(mData.mNumObjects <= VBOX_GUESTCTRL_MAX_OBJECTS);
1078
1079	LogFlowFunc(("Added new guest file \"%s\" (Session: %RU32) (now total %ld files, %ld objects)\n",
1080	openInfo.mFileName.c_str(), mData.mSession.mID, mData.mFiles.size(), mData.mNumObjects));
1081
1082	fireGuestFileRegisteredEvent(mEventSource, this, pFile,
1083	true /* Registered */);
1084	}
1085
1086	if (pGuestRc)
1087	*pGuestRc = guestRc;
1088
1089	LogFlowFuncLeaveRC(rc);
1090	return rc;
1091	}
1092
1093	int GuestSession::fileQueryInfoInternal(const Utf8Str &strPath, GuestFsObjData &objData, int *pGuestRc)
1094	{
1095	LogFlowThisFunc(("strPath=%s\n", strPath.c_str()));
1096
1097	int vrc = fsQueryInfoInternal(strPath, objData, pGuestRc);
1098	if (RT_SUCCESS(vrc))
1099	{
1100	vrc = objData.mType == FsObjType_File
1101	? VINF_SUCCESS : VERR_NOT_A_FILE;
1102	}
1103
1104	LogFlowFuncLeaveRC(vrc);
1105	return vrc;
1106	}
1107
1108	int GuestSession::fileQuerySizeInternal(const Utf8Str &strPath, int64_t pllSize, int pGuestRc)
1109	{
1110	AssertPtrReturn(pllSize, VERR_INVALID_POINTER);
1111
1112	GuestFsObjData objData;
1113	int vrc = fileQueryInfoInternal(strPath, objData, pGuestRc);
1114	if (RT_SUCCESS(vrc))
1115	*pllSize = objData.mObjectSize;
1116
1117	return vrc;
1118	}
1119
1120	int GuestSession::fsQueryInfoInternal(const Utf8Str &strPath, GuestFsObjData &objData, int *pGuestRc)
1121	{
1122	LogFlowThisFunc(("strPath=%s\n", strPath.c_str()));
1123
1124	/** @todo Merge this with IGuestFile::queryInfo(). */
1125	GuestProcessStartupInfo procInfo;
1126	procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_STAT);
1127	procInfo.mFlags = ProcessCreateFlag_WaitForStdOut;
1128
1129	/* Construct arguments. */
1130	procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
1131	procInfo.mArguments.push_back(strPath);
1132
1133	GuestProcessTool procTool; int guestRc;
1134	int vrc = procTool.Init(this, procInfo, false /* Async */, &guestRc);
1135	if (RT_SUCCESS(vrc))
1136	vrc = procTool.Wait(GUESTPROCESSTOOL_FLAG_NONE, &guestRc);
1137	if (RT_SUCCESS(vrc))
1138	{
1139	guestRc = procTool.TerminatedOk(NULL /* Exit code */);
1140	if (RT_SUCCESS(guestRc))
1141	{
1142	GuestProcessStreamBlock curBlock;
1143	vrc = procTool.GetCurrentBlock(OUTPUT_HANDLE_ID_STDOUT, curBlock);
1144	/** @todo Check for more / validate blocks! */
1145	if (RT_SUCCESS(vrc))
1146	vrc = objData.FromStat(curBlock);
1147	}
1148	}
1149
1150	if ( vrc == VERR_GSTCTL_GUEST_ERROR
1151	&& pGuestRc)
1152	{
1153	*pGuestRc = guestRc;
1154	}
1155
1156	LogFlowFuncLeaveRC(vrc);
1157	return vrc;
1158	}
1159
1160	const GuestCredentials& GuestSession::getCredentials(void)
1161	{
1162	return mData.mCredentials;
1163	}
1164
1165	const GuestEnvironment& GuestSession::getEnvironment(void)
1166	{
1167	return mData.mEnvironment;
1168	}
1169
1170	Utf8Str GuestSession::getName(void)
1171	{
1172	return mData.mSession.mName;
1173	}
1174
1175	/* static */
1176	Utf8Str GuestSession::guestErrorToString(int guestRc)
1177	{
1178	Utf8Str strError;
1179
1180	/** @todo pData->u32Flags: int vs. uint32 -- IPRT errors are negative !!! */
1181	switch (guestRc)
1182	{
1183	case VERR_INVALID_VM_HANDLE:
1184	strError += Utf8StrFmt(tr("VMM device is not available (is the VM running?)"));
1185	break;
1186
1187	case VERR_HGCM_SERVICE_NOT_FOUND:
1188	strError += Utf8StrFmt(tr("The guest execution service is not available"));
1189	break;
1190
1191	case VERR_AUTHENTICATION_FAILURE:
1192	strError += Utf8StrFmt(tr("The specified user was not able to logon on guest"));
1193	break;
1194
1195	case VERR_TIMEOUT:
1196	strError += Utf8StrFmt(tr("The guest did not respond within time"));
1197	break;
1198
1199	case VERR_CANCELLED:
1200	strError += Utf8StrFmt(tr("The session operation was canceled"));
1201	break;
1202
1203	case VERR_PERMISSION_DENIED:
1204	strError += Utf8StrFmt(tr("Invalid user/password credentials"));
1205	break;
1206
1207	case VERR_MAX_PROCS_REACHED:
1208	strError += Utf8StrFmt(tr("Maximum number of concurrent guest processes has been reached"));
1209	break;
1210
1211	case VERR_NOT_EQUAL: /** @todo Imprecise to the user; can mean anything and all. */
1212	strError += Utf8StrFmt(tr("Unable to retrieve requested information"));
1213	break;
1214
1215	case VERR_NOT_FOUND:
1216	strError += Utf8StrFmt(tr("The guest execution service is not ready (yet)"));
1217	break;
1218
1219	default:
1220	strError += Utf8StrFmt("%Rrc", guestRc);
1221	break;
1222	}
1223
1224	return strError;
1225	}
1226
1227	/**
1228	* Checks if this session is ready state where it can handle
1229	* all session-bound actions (like guest processes, guest files).
1230	* Only used by official API methods. Will set an external
1231	* error when not ready.
1232	*/
1233	HRESULT GuestSession::isReadyExternal(void)
1234	{
1235	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1236
1237	/** @todo Be a bit more informative. */
1238	if (mData.mStatus != GuestSessionStatus_Started)
1239	return setError(E_UNEXPECTED, tr("Session is not in started state"));
1240
1241	return S_OK;
1242	}
1243
1244	/** No locking! */
1245	int GuestSession::onSessionStatusChange(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
1246	{
1247	AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
1248	/* pCallback is optional. */
1249	AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
1250
1251	if (pSvcCbData->mParms < 3)
1252	return VERR_INVALID_PARAMETER;
1253
1254	CALLBACKDATA_SESSION_NOTIFY dataCb;
1255	/* pSvcCb->mpaParms[0] always contains the context ID. */
1256	pSvcCbData->mpaParms[1].getUInt32(&dataCb.uType);
1257	pSvcCbData->mpaParms[2].getUInt32(&dataCb.uResult);
1258
1259	LogFlowThisFunc(("ID=%RU32, uType=%RU32, guestRc=%Rrc\n",
1260	mData.mSession.mID, dataCb.uType, dataCb.uResult));
1261
1262	int vrc = VINF_SUCCESS;
1263
1264	GuestSessionStatus_T sessionStatus = GuestSessionStatus_Undefined;
1265
1266	int guestRc = dataCb.uResult; /** @todo uint32_t vs. int. */
1267	switch (dataCb.uType)
1268	{
1269	case GUEST_SESSION_NOTIFYTYPE_ERROR:
1270	sessionStatus = GuestSessionStatus_Error;
1271	break;
1272
1273	case GUEST_SESSION_NOTIFYTYPE_STARTED:
1274	sessionStatus = GuestSessionStatus_Started;
1275	break;
1276
1277	case GUEST_SESSION_NOTIFYTYPE_TEN:
1278	case GUEST_SESSION_NOTIFYTYPE_TES:
1279	case GUEST_SESSION_NOTIFYTYPE_TEA:
1280	sessionStatus = GuestSessionStatus_Terminated;
1281	break;
1282
1283	case GUEST_SESSION_NOTIFYTYPE_TOK:
1284	sessionStatus = GuestSessionStatus_TimedOutKilled;
1285	break;
1286
1287	case GUEST_SESSION_NOTIFYTYPE_TOA:
1288	sessionStatus = GuestSessionStatus_TimedOutAbnormally;
1289	break;
1290
1291	case GUEST_SESSION_NOTIFYTYPE_DWN:
1292	sessionStatus = GuestSessionStatus_Down;
1293	break;
1294
1295	case GUEST_SESSION_NOTIFYTYPE_UNDEFINED:
1296	default:
1297	vrc = VERR_NOT_SUPPORTED;
1298	break;
1299	}
1300
1301	if (RT_SUCCESS(vrc))
1302	{
1303	if (RT_FAILURE(guestRc))
1304	sessionStatus = GuestSessionStatus_Error;
1305	}
1306
1307	/* Set the session status. */
1308	if (sessionStatus != GuestSessionStatus_Undefined)
1309	{
1310	int rc2 = setSessionStatus(sessionStatus, guestRc);
1311	if (RT_SUCCESS(vrc))
1312	vrc = rc2;
1313	}
1314
1315	LogFlowThisFunc(("ID=%RU32, guestRc=%Rrc\n", mData.mSession.mID, guestRc));
1316
1317	LogFlowFuncLeaveRC(vrc);
1318	return vrc;
1319	}
1320
1321	int GuestSession::startSessionIntenal(int *pGuestRc)
1322	{
1323	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1324
1325	LogFlowThisFunc(("mID=%RU32, mName=%s, uProtocolVersion=%RU32, openFlags=%x, openTimeoutMS=%RU32\n",
1326	mData.mSession.mID, mData.mSession.mName.c_str(), mData.mProtocolVersion,
1327	mData.mSession.mOpenFlags, mData.mSession.mOpenTimeoutMS));
1328
1329	/* Legacy Guest Additions don't support opening dedicated
1330	guest sessions. Simply return success here. */
1331	if (mData.mProtocolVersion < 2)
1332	{
1333	mData.mStatus = GuestSessionStatus_Started;
1334
1335	LogFlowThisFunc(("Installed Guest Additions don't support opening dedicated sessions, skipping\n"));
1336	return VINF_SUCCESS;
1337	}
1338
1339	if (mData.mStatus != GuestSessionStatus_Undefined)
1340	return VINF_SUCCESS;
1341
1342	/** @todo mData.mSession.uFlags validation. */
1343
1344	/* Set current session status. */
1345	mData.mStatus = GuestSessionStatus_Starting;
1346
1347	int vrc;
1348
1349	GuestWaitEvent *pEvent = NULL;
1350	std::list < VBoxEventType_T > eventTypes;
1351	try
1352	{
1353	eventTypes.push_back(VBoxEventType_OnGuestSessionStateChanged);
1354
1355	vrc = registerEvent(mData.mSession.mID, 0 /* Object ID */,
1356	eventTypes, &pEvent);
1357	}
1358	catch (std::bad_alloc)
1359	{
1360	vrc = VERR_NO_MEMORY;
1361	}
1362
1363	if (RT_FAILURE(vrc))
1364	return vrc;
1365
1366	VBOXHGCMSVCPARM paParms[8];
1367
1368	int i = 0;
1369	paParms[i++].setUInt32(pEvent->ContextID());
1370	paParms[i++].setUInt32(mData.mProtocolVersion);
1371	paParms[i++].setPointer((void*)mData.mCredentials.mUser.c_str(),
1372	(ULONG)mData.mCredentials.mUser.length() + 1);
1373	paParms[i++].setPointer((void*)mData.mCredentials.mPassword.c_str(),
1374	(ULONG)mData.mCredentials.mPassword.length() + 1);
1375	paParms[i++].setPointer((void*)mData.mCredentials.mDomain.c_str(),
1376	(ULONG)mData.mCredentials.mDomain.length() + 1);
1377	paParms[i++].setUInt32(mData.mSession.mOpenFlags);
1378
1379	vrc = sendCommand(HOST_SESSION_CREATE, i, paParms);
1380	if (RT_SUCCESS(vrc))
1381	{
1382	alock.release(); /* Drop write lock before waiting. */
1383
1384	vrc = waitForStatusChange(pEvent, GuestSessionWaitForFlag_Start,
1385	30 * 1000 /* 30s timeout */,
1386	NULL /* Session status */, pGuestRc);
1387	}
1388
1389	unregisterEvent(pEvent);
1390
1391	LogFlowFuncLeaveRC(vrc);
1392	return vrc;
1393	}
1394
1395	int GuestSession::startSessionAsync(void)
1396	{
1397	LogFlowThisFuncEnter();
1398
1399	int vrc;
1400
1401	try
1402	{
1403	/* Asynchronously open the session on the guest by kicking off a
1404	* worker thread. */
1405	std::auto_ptr<GuestSessionTaskInternalOpen> pTask(new GuestSessionTaskInternalOpen(this));
1406	AssertReturn(pTask->isOk(), pTask->rc());
1407
1408	vrc = RTThreadCreate(NULL, GuestSession::startSessionThread,
1409	(void *)pTask.get(), 0,
1410	RTTHREADTYPE_MAIN_WORKER, 0,
1411	"gctlSesStart");
1412	if (RT_SUCCESS(vrc))
1413	{
1414	/* pTask is now owned by openSessionThread(), so release it. */
1415	pTask.release();
1416	}
1417	}
1418	catch(std::bad_alloc &)
1419	{
1420	vrc = VERR_NO_MEMORY;
1421	}
1422
1423	LogFlowFuncLeaveRC(vrc);
1424	return vrc;
1425	}
1426
1427	/* static */
1428	DECLCALLBACK(int) GuestSession::startSessionThread(RTTHREAD Thread, void *pvUser)
1429	{
1430	LogFlowFunc(("pvUser=%p\n", pvUser));
1431
1432	std::auto_ptr<GuestSessionTaskInternalOpen> pTask(static_cast<GuestSessionTaskInternalOpen*>(pvUser));
1433	AssertPtr(pTask.get());
1434
1435	const ComObjPtr<GuestSession> pSession(pTask->Session());
1436	Assert(!pSession.isNull());
1437
1438	AutoCaller autoCaller(pSession);
1439	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1440
1441	int vrc = pSession->startSessionIntenal(NULL /* Guest rc, ignored */);
1442	/* Nothing to do here anymore. */
1443
1444	LogFlowFuncLeaveRC(vrc);
1445	return vrc;
1446	}
1447
1448	int GuestSession::processRemoveFromList(GuestProcess *pProcess)
1449	{
1450	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
1451
1452	LogFlowThisFunc(("pProcess=%p\n", pProcess));
1453
1454	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1455
1456	int rc = VERR_NOT_FOUND;
1457
1458	ULONG uPID;
1459	HRESULT hr = pProcess->COMGETTER(PID)(&uPID);
1460	ComAssertComRC(hr);
1461
1462	LogFlowFunc(("Closing process (PID=%RU32) ...\n", uPID));
1463
1464	SessionProcesses::iterator itProcs = mData.mProcesses.begin();
1465	while (itProcs != mData.mProcesses.end())
1466	{
1467	if (pProcess == itProcs->second)
1468	{
1469	GuestProcess *pCurProc = itProcs->second;
1470	AssertPtr(pCurProc);
1471
1472	hr = pCurProc->COMGETTER(PID)(&uPID);
1473	ComAssertComRC(hr);
1474
1475	Assert(mData.mNumObjects);
1476	LogFlowFunc(("Removing process ID=%RU32 (Session: %RU32), guest PID=%RU32 (now total %ld processes, %ld objects)\n",
1477	pCurProc->getObjectID(), mData.mSession.mID, uPID, mData.mProcesses.size() - 1, mData.mNumObjects - 1));
1478
1479	mData.mProcesses.erase(itProcs);
1480	mData.mNumObjects--;
1481
1482	fireGuestProcessRegisteredEvent(mEventSource, this /* Session /, NULL / Process */,
1483	uPID, false /* Process unregistered */);
1484	rc = VINF_SUCCESS;
1485	break;
1486	}
1487
1488	itProcs++;
1489	}
1490
1491	LogFlowFuncLeaveRC(rc);
1492	return rc;
1493	}
1494
1495	/**
1496	* Creates but does not start the process yet. See GuestProcess::startProcess() or
1497	* GuestProcess::startProcessAsync() for that.
1498	*
1499	* @return IPRT status code.
1500	* @param procInfo
1501	* @param pProcess
1502	*/
1503	int GuestSession::processCreateExInteral(GuestProcessStartupInfo &procInfo, ComObjPtr<GuestProcess> &pProcess)
1504	{
1505	LogFlowFunc(("mCmd=%s, mFlags=%x, mTimeoutMS=%RU32\n",
1506	procInfo.mCommand.c_str(), procInfo.mFlags, procInfo.mTimeoutMS));
1507	#ifdef DEBUG
1508	if (procInfo.mArguments.size())
1509	{
1510	LogFlowFunc(("Arguments:"));
1511	ProcessArguments::const_iterator it = procInfo.mArguments.begin();
1512	while (it != procInfo.mArguments.end())
1513	{
1514	LogFlow((" %s", (*it).c_str()));
1515	it++;
1516	}
1517	LogFlow(("\n"));
1518	}
1519	#endif
1520
1521	/* Validate flags. */
1522	if (procInfo.mFlags)
1523	{
1524	if ( !(procInfo.mFlags & ProcessCreateFlag_IgnoreOrphanedProcesses)
1525	&& !(procInfo.mFlags & ProcessCreateFlag_WaitForProcessStartOnly)
1526	&& !(procInfo.mFlags & ProcessCreateFlag_Hidden)
1527	&& !(procInfo.mFlags & ProcessCreateFlag_NoProfile)
1528	&& !(procInfo.mFlags & ProcessCreateFlag_WaitForStdOut)
1529	&& !(procInfo.mFlags & ProcessCreateFlag_WaitForStdErr))
1530	{
1531	return VERR_INVALID_PARAMETER;
1532	}
1533	}
1534
1535	if ( (procInfo.mFlags & ProcessCreateFlag_WaitForProcessStartOnly)
1536	&& ( (procInfo.mFlags & ProcessCreateFlag_WaitForStdOut)
1537	\|\| (procInfo.mFlags & ProcessCreateFlag_WaitForStdErr)
1538	)
1539	)
1540	{
1541	return VERR_INVALID_PARAMETER;
1542	}
1543
1544	/* Adjust timeout. If set to 0, we define
1545	* an infinite timeout. */
1546	if (procInfo.mTimeoutMS == 0)
1547	procInfo.mTimeoutMS = UINT32_MAX;
1548
1549	/** @tood Implement process priority + affinity. */
1550
1551	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1552
1553	int rc = VERR_MAX_PROCS_REACHED;
1554	if (mData.mNumObjects >= VBOX_GUESTCTRL_MAX_OBJECTS)
1555	return rc;
1556
1557	/* Create a new (host-based) process ID and assign it. */
1558	uint32_t uNewProcessID = 0;
1559	ULONG uTries = 0;
1560
1561	for (;;)
1562	{
1563	/* Is the context ID already used? */
1564	if (!processExists(uNewProcessID, NULL /* pProgress */))
1565	{
1566	/* Callback with context ID was not found. This means
1567	* we can use this context ID for our new callback we want
1568	* to add below. */
1569	rc = VINF_SUCCESS;
1570	break;
1571	}
1572	uNewProcessID++;
1573	if (uNewProcessID == VBOX_GUESTCTRL_MAX_OBJECTS)
1574	uNewProcessID = 0;
1575
1576	if (++uTries == VBOX_GUESTCTRL_MAX_OBJECTS)
1577	break; /* Don't try too hard. */
1578	}
1579
1580	if (RT_FAILURE(rc))
1581	return rc;
1582
1583	/* Create the process object. */
1584	HRESULT hr = pProcess.createObject();
1585	if (FAILED(hr))
1586	return VERR_COM_UNEXPECTED;
1587
1588	rc = pProcess->init(mParent->getConsole() /* Console /, this / Session */,
1589	uNewProcessID, procInfo);
1590	if (RT_FAILURE(rc))
1591	return rc;
1592
1593	/* Add the created process to our map. */
1594	mData.mProcesses[uNewProcessID] = pProcess;
1595	mData.mNumObjects++;
1596	Assert(mData.mNumObjects <= VBOX_GUESTCTRL_MAX_OBJECTS);
1597
1598	fireGuestProcessRegisteredEvent(mEventSource, this /* Session */, pProcess,
1599	0 /* PID /, true / Process registered */);
1600
1601	LogFlowFunc(("Added new process (Session: %RU32) with process ID=%RU32 (now total %ld processes, %ld objects)\n",
1602	mData.mSession.mID, uNewProcessID, mData.mProcesses.size(), mData.mNumObjects));
1603
1604	return rc;
1605	}
1606
1607	inline bool GuestSession::processExists(uint32_t uProcessID, ComObjPtr<GuestProcess> *pProcess)
1608	{
1609	SessionProcesses::const_iterator it = mData.mProcesses.find(uProcessID);
1610	if (it != mData.mProcesses.end())
1611	{
1612	if (pProcess)
1613	*pProcess = it->second;
1614	return true;
1615	}
1616	return false;
1617	}
1618
1619	inline int GuestSession::processGetByPID(ULONG uPID, ComObjPtr<GuestProcess> *pProcess)
1620	{
1621	AssertReturn(uPID, false);
1622	/* pProcess is optional. */
1623
1624	SessionProcesses::iterator itProcs = mData.mProcesses.begin();
1625	for (; itProcs != mData.mProcesses.end(); itProcs++)
1626	{
1627	ComObjPtr<GuestProcess> pCurProc = itProcs->second;
1628	AutoCaller procCaller(pCurProc);
1629	if (procCaller.rc())
1630	return VERR_COM_INVALID_OBJECT_STATE;
1631
1632	ULONG uCurPID;
1633	HRESULT hr = pCurProc->COMGETTER(PID)(&uCurPID);
1634	ComAssertComRC(hr);
1635
1636	if (uCurPID == uPID)
1637	{
1638	if (pProcess)
1639	*pProcess = pCurProc;
1640	return VINF_SUCCESS;
1641	}
1642	}
1643
1644	return VERR_NOT_FOUND;
1645	}
1646
1647	int GuestSession::sendCommand(uint32_t uFunction,
1648	uint32_t uParms, PVBOXHGCMSVCPARM paParms)
1649	{
1650	LogFlowThisFuncEnter();
1651
1652	#ifndef VBOX_GUESTCTRL_TEST_CASE
1653	ComObjPtr<Console> pConsole = mParent->getConsole();
1654	Assert(!pConsole.isNull());
1655
1656	/* Forward the information to the VMM device. */
1657	VMMDev *pVMMDev = pConsole->getVMMDev();
1658	AssertPtr(pVMMDev);
1659
1660	LogFlowThisFunc(("uFunction=%RU32, uParms=%RU32\n", uFunction, uParms));
1661	int vrc = pVMMDev->hgcmHostCall(HGCMSERVICE_NAME, uFunction, uParms, paParms);
1662	if (RT_FAILURE(vrc))
1663	{
1664	/** @todo What to do here? */
1665	}
1666	#else
1667	/* Not needed within testcases. */
1668	int vrc = VINF_SUCCESS;
1669	#endif
1670	LogFlowFuncLeaveRC(vrc);
1671	return vrc;
1672	}
1673
1674	/* static */
1675	HRESULT GuestSession::setErrorExternal(VirtualBoxBase *pInterface, int guestRc)
1676	{
1677	AssertPtr(pInterface);
1678	AssertMsg(RT_FAILURE(guestRc), ("Guest rc does not indicate a failure when setting error\n"));
1679
1680	return pInterface->setError(VBOX_E_IPRT_ERROR, GuestSession::guestErrorToString(guestRc).c_str());
1681	}
1682
1683	/* Does not do locking; caller is responsible for that! */
1684	int GuestSession::setSessionStatus(GuestSessionStatus_T sessionStatus, int sessionRc)
1685	{
1686	LogFlowThisFunc(("oldStatus=%ld, newStatus=%ld, sessionRc=%Rrc\n",
1687	mData.mStatus, sessionStatus, sessionRc));
1688
1689	if (sessionStatus == GuestSessionStatus_Error)
1690	{
1691	AssertMsg(RT_FAILURE(sessionRc), ("Guest rc must be an error (%Rrc)\n", sessionRc));
1692	/* Do not allow overwriting an already set error. If this happens
1693	* this means we forgot some error checking/locking somewhere. */
1694	AssertMsg(RT_SUCCESS(mData.mRC), ("Guest rc already set (to %Rrc)\n", mData.mRC));
1695	}
1696	else
1697	AssertMsg(RT_SUCCESS(sessionRc), ("Guest rc must not be an error (%Rrc)\n", sessionRc));
1698
1699	if (mData.mStatus != sessionStatus)
1700	{
1701	mData.mStatus = sessionStatus;
1702	mData.mRC = sessionRc;
1703
1704	ComObjPtr<VirtualBoxErrorInfo> errorInfo;
1705	HRESULT hr = errorInfo.createObject();
1706	ComAssertComRC(hr);
1707	int rc2 = errorInfo->initEx(VBOX_E_IPRT_ERROR, sessionRc,
1708	COM_IIDOF(IGuestSession), getComponentName(),
1709	guestErrorToString(sessionRc));
1710	AssertRC(rc2);
1711
1712	fireGuestSessionStateChangedEvent(mEventSource, this,
1713	mData.mSession.mID, sessionStatus, errorInfo);
1714	}
1715
1716	return VINF_SUCCESS;
1717	}
1718
1719	int GuestSession::signalWaiters(GuestSessionWaitResult_T enmWaitResult, int rc /= VINF_SUCCESS /)
1720	{
1721	/*LogFlowThisFunc(("enmWaitResult=%d, rc=%Rrc, mWaitCount=%RU32, mWaitEvent=%p\n",
1722	enmWaitResult, rc, mData.mWaitCount, mData.mWaitEvent));*/
1723
1724	/* Note: No write locking here -- already done in the caller. */
1725
1726	int vrc = VINF_SUCCESS;
1727	/*if (mData.mWaitEvent)
1728	vrc = mData.mWaitEvent->Signal(enmWaitResult, rc);*/
1729	LogFlowFuncLeaveRC(vrc);
1730	return vrc;
1731	}
1732
1733	int GuestSession::startTaskAsync(const Utf8Str &strTaskDesc,
1734	GuestSessionTask *pTask, ComObjPtr<Progress> &pProgress)
1735	{
1736	LogFlowThisFunc(("strTaskDesc=%s, pTask=%p\n", strTaskDesc.c_str(), pTask));
1737
1738	AssertPtrReturn(pTask, VERR_INVALID_POINTER);
1739
1740	/* Create the progress object. */
1741	HRESULT hr = pProgress.createObject();
1742	if (FAILED(hr))
1743	return VERR_COM_UNEXPECTED;
1744
1745	hr = pProgress->init(static_cast<IGuestSession*>(this),
1746	Bstr(strTaskDesc).raw(),
1747	TRUE /* aCancelable */);
1748	if (FAILED(hr))
1749	return VERR_COM_UNEXPECTED;
1750
1751	/* Initialize our worker task. */
1752	std::auto_ptr<GuestSessionTask> task(pTask);
1753
1754	int rc = task->RunAsync(strTaskDesc, pProgress);
1755	if (RT_FAILURE(rc))
1756	return rc;
1757
1758	/* Don't destruct on success. */
1759	task.release();
1760
1761	LogFlowFuncLeaveRC(rc);
1762	return rc;
1763	}
1764
1765	/**
1766	* Queries/collects information prior to establishing a guest session.
1767	* This is necessary to know which guest control protocol version to use,
1768	* among other things (later).
1769	*
1770	* @return IPRT status code.
1771	*/
1772	int GuestSession::queryInfo(void)
1773	{
1774	#ifndef DEBUG_andy
1775	/* Since the new functions are not fully implemented yet, force Main
1776	to use protocol ver 1 so far. */
1777	mData.mProtocolVersion = 1;
1778	#else
1779	#if 1
1780	/* For debugging only: Hardcode version. */
1781	mData.mProtocolVersion = 2;
1782	#else
1783	/*
1784	* Try querying the guest control protocol version running on the guest.
1785	* This is done using the Guest Additions version
1786	*/
1787	ComObjPtr<Guest> pGuest = mParent;
1788	Assert(!pGuest.isNull());
1789
1790	uint32_t uVerAdditions = pGuest->getAdditionsVersion();
1791	mData.mProtocolVersion = ( VBOX_FULL_VERSION_GET_MAJOR(uVerAdditions) >= 4
1792	&& VBOX_FULL_VERSION_GET_MINOR(uVerAdditions) >= 3) /** @todo What's about v5.0 ? */
1793	? 2 /* Guest control 2.0. */
1794	: 1; /* Legacy guest control (VBox < 4.3). */
1795	/* Build revision is ignored. */
1796
1797	/* Tell the user but don't bitch too often. */
1798	static short s_gctrlLegacyWarning = 0;
1799	if (s_gctrlLegacyWarning++ < 3) /** @todo Find a bit nicer text. */
1800	LogRel((tr("Warning: Guest Additions are older (%ld.%ld) than host capabilities for guest control, please upgrade them. Using protocol version %ld now\n"),
1801	VBOX_FULL_VERSION_GET_MAJOR(uVerAdditions), VBOX_FULL_VERSION_GET_MINOR(uVerAdditions), mData.mProtocolVersion));
1802	#endif
1803	#endif
1804	return VINF_SUCCESS;
1805	}
1806
1807	int GuestSession::waitFor(uint32_t fWaitFlags, ULONG uTimeoutMS, GuestSessionWaitResult_T &waitResult, int *pGuestRc)
1808	{
1809	LogFlowThisFuncEnter();
1810
1811	AssertReturn(fWaitFlags, VERR_INVALID_PARAMETER);
1812
1813	/*LogFlowThisFunc(("fWaitFlags=0x%x, uTimeoutMS=%RU32, mStatus=%RU32, mWaitCount=%RU32, mWaitEvent=%p, pGuestRc=%p\n",
1814	fWaitFlags, uTimeoutMS, mData.mStatus, mData.mWaitCount, mData.mWaitEvent, pGuestRc));*/
1815
1816	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1817
1818	/* Did some error occur before? Then skip waiting and return. */
1819	if (mData.mStatus == GuestSessionStatus_Error)
1820	{
1821	waitResult = GuestSessionWaitResult_Error;
1822	AssertMsg(RT_FAILURE(mData.mRC), ("No error rc (%Rrc) set when guest session indicated an error\n", mData.mRC));
1823	if (pGuestRc)
1824	pGuestRc = mData.mRC; / Return last set error. */
1825	return VERR_GSTCTL_GUEST_ERROR;
1826	}
1827
1828	waitResult = GuestSessionWaitResult_None;
1829	if (fWaitFlags & GuestSessionWaitForFlag_Terminate)
1830	{
1831	switch (mData.mStatus)
1832	{
1833	case GuestSessionStatus_Terminated:
1834	case GuestSessionStatus_Down:
1835	waitResult = GuestSessionWaitResult_Terminate;
1836	break;
1837
1838	case GuestSessionStatus_TimedOutKilled:
1839	case GuestSessionStatus_TimedOutAbnormally:
1840	waitResult = GuestSessionWaitResult_Timeout;
1841	break;
1842
1843	case GuestSessionStatus_Error:
1844	/* Handled above. */
1845	break;
1846
1847	case GuestSessionStatus_Started:
1848	waitResult = GuestSessionWaitResult_Start;
1849	break;
1850
1851	case GuestSessionStatus_Undefined:
1852	case GuestSessionStatus_Starting:
1853	/* Do the waiting below. */
1854	break;
1855
1856	default:
1857	AssertMsgFailed(("Unhandled session status %ld\n", mData.mStatus));
1858	return VERR_NOT_IMPLEMENTED;
1859	}
1860	}
1861	else if (fWaitFlags & GuestSessionWaitForFlag_Start)
1862	{
1863	switch (mData.mStatus)
1864	{
1865	case GuestSessionStatus_Started:
1866	case GuestSessionStatus_Terminating:
1867	case GuestSessionStatus_Terminated:
1868	case GuestSessionStatus_Down:
1869	waitResult = GuestSessionWaitResult_Start;
1870	break;
1871
1872	case GuestSessionStatus_Error:
1873	waitResult = GuestSessionWaitResult_Error;
1874	break;
1875
1876	case GuestSessionStatus_TimedOutKilled:
1877	case GuestSessionStatus_TimedOutAbnormally:
1878	waitResult = GuestSessionWaitResult_Timeout;
1879	break;
1880
1881	case GuestSessionStatus_Undefined:
1882	case GuestSessionStatus_Starting:
1883	/* Do the waiting below. */
1884	break;
1885
1886	default:
1887	AssertMsgFailed(("Unhandled session status %ld\n", mData.mStatus));
1888	return VERR_NOT_IMPLEMENTED;
1889	}
1890	}
1891
1892	LogFlowThisFunc(("sessionStatus=%ld, sessionRc=%Rrc, waitResult=%ld\n",
1893	mData.mStatus, mData.mRC, waitResult));
1894
1895	/* No waiting needed? Return immediately using the last set error. */
1896	if (waitResult != GuestSessionWaitResult_None)
1897	{
1898	if (pGuestRc)
1899	pGuestRc = mData.mRC; / Return last set error (if any). */
1900	return RT_SUCCESS(mData.mRC) ? VINF_SUCCESS : VERR_GSTCTL_GUEST_ERROR;
1901	}
1902
1903	alock.release(); /* Release lock before waiting. */
1904
1905	int vrc;
1906
1907	GuestWaitEvent *pEvent = NULL;
1908	std::list < VBoxEventType_T > eventTypes;
1909	try
1910	{
1911	eventTypes.push_back(VBoxEventType_OnGuestSessionStateChanged);
1912
1913	vrc = registerEvent(mData.mSession.mID, 0 /* Object ID */,
1914	eventTypes, &pEvent);
1915	}
1916	catch (std::bad_alloc)
1917	{
1918	vrc = VERR_NO_MEMORY;
1919	}
1920
1921	if (RT_FAILURE(vrc))
1922	return vrc;
1923
1924	GuestSessionStatus_T sessionStatus;
1925	vrc = waitForStatusChange(pEvent, fWaitFlags,
1926	uTimeoutMS, &sessionStatus, pGuestRc);
1927	if (RT_SUCCESS(vrc))
1928	{
1929	switch (sessionStatus)
1930	{
1931	case GuestSessionStatus_Started:
1932	waitResult = GuestSessionWaitResult_Start;
1933	break;
1934
1935	case GuestSessionStatus_Terminated:
1936	waitResult = GuestSessionWaitResult_Terminate;
1937	break;
1938
1939	case GuestSessionStatus_TimedOutKilled:
1940	case GuestSessionStatus_TimedOutAbnormally:
1941	waitResult = GuestSessionWaitResult_Timeout;
1942	break;
1943
1944	case GuestSessionStatus_Down:
1945	waitResult = GuestSessionWaitResult_Terminate;
1946	break;
1947
1948	case GuestSessionStatus_Error:
1949	waitResult = GuestSessionWaitResult_Error;
1950	break;
1951
1952	default:
1953	waitResult = GuestSessionWaitResult_Status;
1954	break;
1955	}
1956	}
1957
1958	unregisterEvent(pEvent);
1959
1960	LogFlowFuncLeaveRC(vrc);
1961	return vrc;
1962	}
1963
1964	int GuestSession::waitForStatusChange(GuestWaitEvent *pEvent, uint32_t fWaitFlags, uint32_t uTimeoutMS,
1965	GuestSessionStatus_T pSessionStatus, int pGuestRc)
1966	{
1967	AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
1968
1969	VBoxEventType_T evtType;
1970	ComPtr<IEvent> pIEvent;
1971	int vrc = waitForEvent(pEvent, uTimeoutMS,
1972	&evtType, pIEvent.asOutParam());
1973	if (RT_SUCCESS(vrc))
1974	{
1975	Assert(evtType == VBoxEventType_OnGuestSessionStateChanged);
1976
1977	ComPtr<IGuestSessionStateChangedEvent> pChangedEvent = pIEvent;
1978	Assert(!pChangedEvent.isNull());
1979
1980	GuestSessionStatus_T sessionStatus;
1981	pChangedEvent->COMGETTER(Status)(&sessionStatus);
1982	if (pSessionStatus)
1983	*pSessionStatus = sessionStatus;
1984
1985	ComPtr<IVirtualBoxErrorInfo> errorInfo;
1986	HRESULT hr = pChangedEvent->COMGETTER(Error)(errorInfo.asOutParam());
1987	ComAssertComRC(hr);
1988
1989	LONG lGuestRc;
1990	hr = errorInfo->COMGETTER(ResultDetail)(&lGuestRc);
1991	ComAssertComRC(hr);
1992	if (RT_FAILURE((int)lGuestRc))
1993	vrc = VERR_GSTCTL_GUEST_ERROR;
1994	if (pGuestRc)
1995	*pGuestRc = (int)lGuestRc;
1996
1997	LogFlowThisFunc(("Status changed event for session ID=%RU32: %ld (%Rrc)\n",
1998	mData.mSession.mID, sessionStatus,
1999	RT_SUCCESS((int)lGuestRc) ? VINF_SUCCESS : (int)lGuestRc));
2000	}
2001
2002	LogFlowFuncLeaveRC(vrc);
2003	return vrc;
2004	}
2005
2006	// implementation of public methods
2007	/////////////////////////////////////////////////////////////////////////////
2008
2009	STDMETHODIMP GuestSession::Close(void)
2010	{
2011	#ifndef VBOX_WITH_GUEST_CONTROL
2012	ReturnComNotImplemented();
2013	#else
2014	LogFlowThisFuncEnter();
2015
2016	AutoCaller autoCaller(this);
2017	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2018
2019	/* Close session on guest. */
2020	int guestRc;
2021	int rc = closeSession(0 /* Flags /, 30 1000 /* Timeout */,
2022	&guestRc);
2023	/* On failure don't return here, instead do all the cleanup
2024	* work first and then return an error. */
2025
2026	/* Remove ourselves from the session list. */
2027	int rc2 = mParent->sessionRemove(this);
2028	if (RT_SUCCESS(rc))
2029	rc = rc2;
2030
2031	/*
2032	* Release autocaller before calling uninit.
2033	*/
2034	autoCaller.release();
2035
2036	uninit();
2037
2038	LogFlowFuncLeaveRC(rc);
2039	if (RT_FAILURE(rc))
2040	{
2041	if (rc == VERR_GSTCTL_GUEST_ERROR)
2042	return GuestSession::setErrorExternal(this, guestRc);
2043
2044	return setError(VBOX_E_IPRT_ERROR,
2045	tr("Closing guest session failed with %Rrc"), rc);
2046	}
2047
2048	return S_OK;
2049	#endif /* VBOX_WITH_GUEST_CONTROL */
2050	}
2051
2052	STDMETHODIMP GuestSession::CopyFrom(IN_BSTR aSource, IN_BSTR aDest, ComSafeArrayIn(CopyFileFlag_T, aFlags), IProgress **aProgress)
2053	{
2054	#ifndef VBOX_WITH_GUEST_CONTROL
2055	ReturnComNotImplemented();
2056	#else
2057	CheckComArgStrNotEmptyOrNull(aSource);
2058	CheckComArgStrNotEmptyOrNull(aDest);
2059	CheckComArgOutPointerValid(aProgress);
2060
2061	LogFlowThisFuncEnter();
2062
2063	if (RT_UNLIKELY((aSource) == NULL \|\| *(aSource) == '\0'))
2064	return setError(E_INVALIDARG, tr("No source specified"));
2065	if (RT_UNLIKELY((aDest) == NULL \|\| *(aDest) == '\0'))
2066	return setError(E_INVALIDARG, tr("No destination specified"));
2067
2068	AutoCaller autoCaller(this);
2069	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2070
2071	uint32_t fFlags = CopyFileFlag_None;
2072	if (aFlags)
2073	{
2074	com::SafeArray<CopyFileFlag_T> flags(ComSafeArrayInArg(aFlags));
2075	for (size_t i = 0; i < flags.size(); i++)
2076	fFlags \|= flags[i];
2077	}
2078
2079	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2080
2081	HRESULT hr = S_OK;
2082
2083	try
2084	{
2085	ComObjPtr<Progress> pProgress;
2086	SessionTaskCopyFrom pTask = new SessionTaskCopyFrom(this / GuestSession */,
2087	Utf8Str(aSource), Utf8Str(aDest), fFlags);
2088	int rc = startTaskAsync(Utf8StrFmt(tr("Copying \"%ls\" from guest to \"%ls\" on the host"), aSource, aDest),
2089	pTask, pProgress);
2090	if (RT_SUCCESS(rc))
2091	{
2092	/* Return progress to the caller. */
2093	hr = pProgress.queryInterfaceTo(aProgress);
2094	}
2095	else
2096	hr = setError(VBOX_E_IPRT_ERROR,
2097	tr("Starting task for copying file \"%ls\" from guest to \"%ls\" on the host failed: %Rrc"), rc);
2098	}
2099	catch(std::bad_alloc &)
2100	{
2101	hr = E_OUTOFMEMORY;
2102	}
2103
2104	return hr;
2105	#endif /* VBOX_WITH_GUEST_CONTROL */
2106	}
2107
2108	STDMETHODIMP GuestSession::CopyTo(IN_BSTR aSource, IN_BSTR aDest, ComSafeArrayIn(CopyFileFlag_T, aFlags), IProgress **aProgress)
2109	{
2110	#ifndef VBOX_WITH_GUEST_CONTROL
2111	ReturnComNotImplemented();
2112	#else
2113	CheckComArgStrNotEmptyOrNull(aSource);
2114	CheckComArgStrNotEmptyOrNull(aDest);
2115	CheckComArgOutPointerValid(aProgress);
2116
2117	LogFlowThisFuncEnter();
2118
2119	if (RT_UNLIKELY((aSource) == NULL \|\| *(aSource) == '\0'))
2120	return setError(E_INVALIDARG, tr("No source specified"));
2121	if (RT_UNLIKELY((aDest) == NULL \|\| *(aDest) == '\0'))
2122	return setError(E_INVALIDARG, tr("No destination specified"));
2123
2124	AutoCaller autoCaller(this);
2125	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2126
2127	uint32_t fFlags = CopyFileFlag_None;
2128	if (aFlags)
2129	{
2130	com::SafeArray<CopyFileFlag_T> flags(ComSafeArrayInArg(aFlags));
2131	for (size_t i = 0; i < flags.size(); i++)
2132	fFlags \|= flags[i];
2133	}
2134
2135	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2136
2137	HRESULT hr = S_OK;
2138
2139	try
2140	{
2141	ComObjPtr<Progress> pProgress;
2142	SessionTaskCopyTo pTask = new SessionTaskCopyTo(this / GuestSession */,
2143	Utf8Str(aSource), Utf8Str(aDest), fFlags);
2144	AssertPtrReturn(pTask, E_OUTOFMEMORY);
2145	int rc = startTaskAsync(Utf8StrFmt(tr("Copying \"%ls\" from host to \"%ls\" on the guest"), aSource, aDest),
2146	pTask, pProgress);
2147	if (RT_SUCCESS(rc))
2148	{
2149	/* Return progress to the caller. */
2150	hr = pProgress.queryInterfaceTo(aProgress);
2151	}
2152	else
2153	hr = setError(VBOX_E_IPRT_ERROR,
2154	tr("Starting task for copying file \"%ls\" from host to \"%ls\" on the guest failed: %Rrc"), rc);
2155	}
2156	catch(std::bad_alloc &)
2157	{
2158	hr = E_OUTOFMEMORY;
2159	}
2160
2161	return hr;
2162	#endif /* VBOX_WITH_GUEST_CONTROL */
2163	}
2164
2165	STDMETHODIMP GuestSession::DirectoryCreate(IN_BSTR aPath, ULONG aMode,
2166	ComSafeArrayIn(DirectoryCreateFlag_T, aFlags))
2167	{
2168	#ifndef VBOX_WITH_GUEST_CONTROL
2169	ReturnComNotImplemented();
2170	#else
2171	LogFlowThisFuncEnter();
2172
2173	if (RT_UNLIKELY((aPath) == NULL \|\| *(aPath) == '\0'))
2174	return setError(E_INVALIDARG, tr("No directory to create specified"));
2175
2176	AutoCaller autoCaller(this);
2177	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2178
2179	uint32_t fFlags = DirectoryCreateFlag_None;
2180	if (aFlags)
2181	{
2182	com::SafeArray<DirectoryCreateFlag_T> flags(ComSafeArrayInArg(aFlags));
2183	for (size_t i = 0; i < flags.size(); i++)
2184	fFlags \|= flags[i];
2185
2186	if (fFlags)
2187	{
2188	if (!(fFlags & DirectoryCreateFlag_Parents))
2189	return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), fFlags);
2190	}
2191	}
2192
2193	HRESULT hr = S_OK;
2194
2195	ComObjPtr <GuestDirectory> pDirectory; int guestRc;
2196	int rc = directoryCreateInternal(Utf8Str(aPath), (uint32_t)aMode, fFlags, &guestRc);
2197	if (RT_FAILURE(rc))
2198	{
2199	switch (rc)
2200	{
2201	case VERR_GSTCTL_GUEST_ERROR:
2202	hr = GuestProcess::setErrorExternal(this, guestRc);
2203	break;
2204
2205	case VERR_INVALID_PARAMETER:
2206	hr = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: Invalid parameters given"));
2207	break;
2208
2209	case VERR_BROKEN_PIPE:
2210	hr = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: Unexpectedly aborted"));
2211	break;
2212
2213	case VERR_CANT_CREATE:
2214	hr = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: Could not create directory"));
2215	break;
2216
2217	default:
2218	hr = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: %Rrc"), rc);
2219	break;
2220	}
2221	}
2222
2223	return hr;
2224	#endif /* VBOX_WITH_GUEST_CONTROL */
2225	}
2226
2227	STDMETHODIMP GuestSession::DirectoryCreateTemp(IN_BSTR aTemplate, ULONG aMode, IN_BSTR aPath, BOOL aSecure, BSTR *aDirectory)
2228	{
2229	#ifndef VBOX_WITH_GUEST_CONTROL
2230	ReturnComNotImplemented();
2231	#else
2232	LogFlowThisFuncEnter();
2233
2234	if (RT_UNLIKELY((aTemplate) == NULL \|\| *(aTemplate) == '\0'))
2235	return setError(E_INVALIDARG, tr("No template specified"));
2236	if (RT_UNLIKELY((aPath) == NULL \|\| *(aPath) == '\0'))
2237	return setError(E_INVALIDARG, tr("No directory name specified"));
2238	CheckComArgOutPointerValid(aDirectory);
2239
2240	AutoCaller autoCaller(this);
2241	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2242
2243	HRESULT hr = S_OK;
2244
2245	Utf8Str strName; int guestRc;
2246	int rc = objectCreateTempInternal(Utf8Str(aTemplate),
2247	Utf8Str(aPath),
2248	true /* Directory */, strName, &guestRc);
2249	if (RT_SUCCESS(rc))
2250	{
2251	strName.cloneTo(aDirectory);
2252	}
2253	else
2254	{
2255	switch (rc)
2256	{
2257	case VERR_GSTCTL_GUEST_ERROR:
2258	hr = GuestProcess::setErrorExternal(this, guestRc);
2259	break;
2260
2261	default:
2262	hr = setError(VBOX_E_IPRT_ERROR, tr("Temporary directory creation \"%s\" with template \"%s\" failed: %Rrc"),
2263	Utf8Str(aPath).c_str(), Utf8Str(aTemplate).c_str(), rc);
2264	break;
2265	}
2266	}
2267
2268	return hr;
2269	#endif /* VBOX_WITH_GUEST_CONTROL */
2270	}
2271
2272	STDMETHODIMP GuestSession::DirectoryExists(IN_BSTR aPath, BOOL *aExists)
2273	{
2274	#ifndef VBOX_WITH_GUEST_CONTROL
2275	ReturnComNotImplemented();
2276	#else
2277	LogFlowThisFuncEnter();
2278
2279	if (RT_UNLIKELY((aPath) == NULL \|\| *(aPath) == '\0'))
2280	return setError(E_INVALIDARG, tr("No directory to check existence for specified"));
2281	CheckComArgOutPointerValid(aExists);
2282
2283	AutoCaller autoCaller(this);
2284	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2285
2286	HRESULT hr = S_OK;
2287
2288	GuestFsObjData objData; int guestRc;
2289	int rc = directoryQueryInfoInternal(Utf8Str(aPath), objData, &guestRc);
2290	if (RT_SUCCESS(rc))
2291	{
2292	*aExists = objData.mType == FsObjType_Directory;
2293	}
2294	else
2295	{
2296	switch (rc)
2297	{
2298	case VERR_GSTCTL_GUEST_ERROR:
2299	hr = GuestProcess::setErrorExternal(this, guestRc);
2300	break;
2301
2302	default:
2303	hr = setError(VBOX_E_IPRT_ERROR, tr("Querying directory existence \"%s\" failed: %Rrc"),
2304	Utf8Str(aPath).c_str(), rc);
2305	break;
2306	}
2307	}
2308
2309	return hr;
2310	#endif /* VBOX_WITH_GUEST_CONTROL */
2311	}
2312
2313	STDMETHODIMP GuestSession::DirectoryOpen(IN_BSTR aPath, IN_BSTR aFilter, ComSafeArrayIn(DirectoryOpenFlag_T, aFlags), IGuestDirectory **aDirectory)
2314	{
2315	#ifndef VBOX_WITH_GUEST_CONTROL
2316	ReturnComNotImplemented();
2317	#else
2318	LogFlowThisFuncEnter();
2319
2320	if (RT_UNLIKELY((aPath) == NULL \|\| *(aPath) == '\0'))
2321	return setError(E_INVALIDARG, tr("No directory to open specified"));
2322	if (RT_UNLIKELY((aFilter) != NULL && *(aFilter) != '\0'))
2323	return setError(E_INVALIDARG, tr("Directory filters are not implemented yet"));
2324	CheckComArgOutPointerValid(aDirectory);
2325
2326	AutoCaller autoCaller(this);
2327	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2328
2329	uint32_t fFlags = DirectoryOpenFlag_None;
2330	if (aFlags)
2331	{
2332	com::SafeArray<DirectoryOpenFlag_T> flags(ComSafeArrayInArg(aFlags));
2333	for (size_t i = 0; i < flags.size(); i++)
2334	fFlags \|= flags[i];
2335
2336	if (fFlags)
2337	return setError(E_INVALIDARG, tr("Open flags (%#x) not implemented yet"), fFlags);
2338	}
2339
2340	HRESULT hr = S_OK;
2341
2342	ComObjPtr <GuestDirectory> pDirectory;
2343	int rc = directoryOpenInternal(Utf8Str(aPath), Utf8Str(aFilter), fFlags, pDirectory);
2344	if (RT_SUCCESS(rc))
2345	{
2346	/* Return directory object to the caller. */
2347	hr = pDirectory.queryInterfaceTo(aDirectory);
2348	}
2349	else
2350	{
2351	switch (rc)
2352	{
2353	case VERR_INVALID_PARAMETER:
2354	hr = setError(VBOX_E_IPRT_ERROR, tr("Opening directory \"%s\" failed; invalid parameters given",
2355	Utf8Str(aPath).c_str()));
2356	break;
2357
2358	default:
2359	hr = setError(VBOX_E_IPRT_ERROR, tr("Opening directory \"%s\" failed: %Rrc"),
2360	Utf8Str(aPath).c_str(),rc);
2361	break;
2362	}
2363	}
2364
2365	return hr;
2366	#endif /* VBOX_WITH_GUEST_CONTROL */
2367	}
2368
2369	STDMETHODIMP GuestSession::DirectoryQueryInfo(IN_BSTR aPath, IGuestFsObjInfo **aInfo)
2370	{
2371	#ifndef VBOX_WITH_GUEST_CONTROL
2372	ReturnComNotImplemented();
2373	#else
2374	LogFlowThisFuncEnter();
2375
2376	if (RT_UNLIKELY((aPath) == NULL \|\| *(aPath) == '\0'))
2377	return setError(E_INVALIDARG, tr("No directory to query information for specified"));
2378	CheckComArgOutPointerValid(aInfo);
2379
2380	AutoCaller autoCaller(this);
2381	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2382
2383	HRESULT hr = S_OK;
2384
2385	GuestFsObjData objData; int guestRc;
2386	int vrc = directoryQueryInfoInternal(Utf8Str(aPath), objData, &guestRc);
2387	if (RT_SUCCESS(vrc))
2388	{
2389	if (objData.mType == FsObjType_Directory)
2390	{
2391	ComObjPtr<GuestFsObjInfo> pFsObjInfo;
2392	hr = pFsObjInfo.createObject();
2393	if (FAILED(hr)) return hr;
2394
2395	vrc = pFsObjInfo->init(objData);
2396	if (RT_SUCCESS(vrc))
2397	{
2398	hr = pFsObjInfo.queryInterfaceTo(aInfo);
2399	if (FAILED(hr)) return hr;
2400	}
2401	}
2402	}
2403
2404	if (RT_FAILURE(vrc))
2405	{
2406	switch (vrc)
2407	{
2408	case VERR_GSTCTL_GUEST_ERROR:
2409	hr = GuestProcess::setErrorExternal(this, guestRc);
2410	break;
2411
2412	case VERR_NOT_A_DIRECTORY:
2413	hr = setError(VBOX_E_IPRT_ERROR, tr("Element \"%s\" exists but is not a directory",
2414	Utf8Str(aPath).c_str()));
2415	break;
2416
2417	default:
2418	hr = setError(VBOX_E_IPRT_ERROR, tr("Querying directory information for \"%s\" failed: %Rrc"),
2419	Utf8Str(aPath).c_str(), vrc);
2420	break;
2421	}
2422	}
2423
2424	return hr;
2425	#endif /* VBOX_WITH_GUEST_CONTROL */
2426	}
2427
2428	STDMETHODIMP GuestSession::DirectoryRemove(IN_BSTR aPath)
2429	{
2430	#ifndef VBOX_WITH_GUEST_CONTROL
2431	ReturnComNotImplemented();
2432	#else
2433	LogFlowThisFuncEnter();
2434
2435	AutoCaller autoCaller(this);
2436	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2437
2438	ReturnComNotImplemented();
2439	#endif /* VBOX_WITH_GUEST_CONTROL */
2440	}
2441
2442	STDMETHODIMP GuestSession::DirectoryRemoveRecursive(IN_BSTR aPath, ComSafeArrayIn(DirectoryRemoveRecFlag_T, aFlags), IProgress **aProgress)
2443	{
2444	#ifndef VBOX_WITH_GUEST_CONTROL
2445	ReturnComNotImplemented();
2446	#else
2447	LogFlowThisFuncEnter();
2448
2449	AutoCaller autoCaller(this);
2450	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2451
2452	ReturnComNotImplemented();
2453	#endif /* VBOX_WITH_GUEST_CONTROL */
2454	}
2455
2456	STDMETHODIMP GuestSession::DirectoryRename(IN_BSTR aSource, IN_BSTR aDest, ComSafeArrayIn(PathRenameFlag_T, aFlags))
2457	{
2458	#ifndef VBOX_WITH_GUEST_CONTROL
2459	ReturnComNotImplemented();
2460	#else
2461	LogFlowThisFuncEnter();
2462
2463	AutoCaller autoCaller(this);
2464	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2465
2466	ReturnComNotImplemented();
2467	#endif /* VBOX_WITH_GUEST_CONTROL */
2468	}
2469
2470	STDMETHODIMP GuestSession::DirectorySetACL(IN_BSTR aPath, IN_BSTR aACL)
2471	{
2472	#ifndef VBOX_WITH_GUEST_CONTROL
2473	ReturnComNotImplemented();
2474	#else
2475	LogFlowThisFuncEnter();
2476
2477	AutoCaller autoCaller(this);
2478	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2479
2480	ReturnComNotImplemented();
2481	#endif /* VBOX_WITH_GUEST_CONTROL */
2482	}
2483
2484	STDMETHODIMP GuestSession::EnvironmentClear(void)
2485	{
2486	#ifndef VBOX_WITH_GUEST_CONTROL
2487	ReturnComNotImplemented();
2488	#else
2489	LogFlowThisFuncEnter();
2490
2491	AutoCaller autoCaller(this);
2492	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2493
2494	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2495
2496	mData.mEnvironment.Clear();
2497
2498	LogFlowFuncLeaveRC(S_OK);
2499	return S_OK;
2500	#endif /* VBOX_WITH_GUEST_CONTROL */
2501	}
2502
2503	STDMETHODIMP GuestSession::EnvironmentGet(IN_BSTR aName, BSTR *aValue)
2504	{
2505	#ifndef VBOX_WITH_GUEST_CONTROL
2506	ReturnComNotImplemented();
2507	#else
2508	LogFlowThisFuncEnter();
2509
2510	if (RT_UNLIKELY((aName) == NULL \|\| *(aName) == '\0'))
2511	return setError(E_INVALIDARG, tr("No value name specified"));
2512
2513	CheckComArgOutPointerValid(aValue);
2514
2515	AutoCaller autoCaller(this);
2516	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2517
2518	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2519
2520	Bstr strValue(mData.mEnvironment.Get(Utf8Str(aName)));
2521	strValue.cloneTo(aValue);
2522
2523	LogFlowFuncLeaveRC(S_OK);
2524	return S_OK;
2525	#endif /* VBOX_WITH_GUEST_CONTROL */
2526	}
2527
2528	STDMETHODIMP GuestSession::EnvironmentSet(IN_BSTR aName, IN_BSTR aValue)
2529	{
2530	#ifndef VBOX_WITH_GUEST_CONTROL
2531	ReturnComNotImplemented();
2532	#else
2533	LogFlowThisFuncEnter();
2534
2535	if (RT_UNLIKELY((aName) == NULL \|\| *(aName) == '\0'))
2536	return setError(E_INVALIDARG, tr("No value name specified"));
2537
2538	AutoCaller autoCaller(this);
2539	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2540
2541	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2542
2543	int rc = mData.mEnvironment.Set(Utf8Str(aName), Utf8Str(aValue));
2544
2545	HRESULT hr = RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
2546	LogFlowFuncLeaveRC(hr);
2547	return hr;
2548	#endif /* VBOX_WITH_GUEST_CONTROL */
2549	}
2550
2551	STDMETHODIMP GuestSession::EnvironmentUnset(IN_BSTR aName)
2552	{
2553	#ifndef VBOX_WITH_GUEST_CONTROL
2554	ReturnComNotImplemented();
2555	#else
2556	LogFlowThisFuncEnter();
2557
2558	AutoCaller autoCaller(this);
2559	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2560
2561	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2562
2563	mData.mEnvironment.Unset(Utf8Str(aName));
2564
2565	LogFlowFuncLeaveRC(S_OK);
2566	return S_OK;
2567	#endif /* VBOX_WITH_GUEST_CONTROL */
2568	}
2569
2570	STDMETHODIMP GuestSession::FileCreateTemp(IN_BSTR aTemplate, ULONG aMode, IN_BSTR aPath, BOOL aSecure, IGuestFile **aFile)
2571	{
2572	#ifndef VBOX_WITH_GUEST_CONTROL
2573	ReturnComNotImplemented();
2574	#else
2575	LogFlowThisFuncEnter();
2576
2577	AutoCaller autoCaller(this);
2578	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2579
2580	ReturnComNotImplemented();
2581	#endif /* VBOX_WITH_GUEST_CONTROL */
2582	}
2583
2584	STDMETHODIMP GuestSession::FileExists(IN_BSTR aPath, BOOL *aExists)
2585	{
2586	#ifndef VBOX_WITH_GUEST_CONTROL
2587	ReturnComNotImplemented();
2588	#else
2589	LogFlowThisFuncEnter();
2590
2591	if (RT_UNLIKELY((aPath) == NULL \|\| *(aPath) == '\0'))
2592	return setError(E_INVALIDARG, tr("No file to check existence for specified"));
2593	CheckComArgOutPointerValid(aExists);
2594
2595	AutoCaller autoCaller(this);
2596	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2597
2598	GuestFsObjData objData; int guestRc;
2599	int vrc = fileQueryInfoInternal(Utf8Str(aPath), objData, &guestRc);
2600	if (RT_SUCCESS(vrc))
2601	{
2602	*aExists = TRUE;
2603	return S_OK;
2604	}
2605
2606	HRESULT hr = S_OK;
2607
2608	switch (vrc)
2609	{
2610	case VERR_GSTCTL_GUEST_ERROR:
2611	hr = GuestProcess::setErrorExternal(this, guestRc);
2612	break;
2613
2614	case VERR_NOT_A_FILE:
2615	*aExists = FALSE;
2616	break;
2617
2618	default:
2619	hr = setError(VBOX_E_IPRT_ERROR, tr("Querying file information for \"%s\" failed: %Rrc"),
2620	Utf8Str(aPath).c_str(), vrc);
2621	break;
2622	}
2623
2624	return hr;
2625	#endif /* VBOX_WITH_GUEST_CONTROL */
2626	}
2627
2628	STDMETHODIMP GuestSession::FileRemove(IN_BSTR aPath)
2629	{
2630	#ifndef VBOX_WITH_GUEST_CONTROL
2631	ReturnComNotImplemented();
2632	#else
2633	LogFlowThisFuncEnter();
2634
2635	if (RT_UNLIKELY((aPath) == NULL \|\| *(aPath) == '\0'))
2636	return setError(E_INVALIDARG, tr("No file to remove specified"));
2637
2638	AutoCaller autoCaller(this);
2639	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2640
2641	HRESULT hr = S_OK;
2642
2643	int guestRc;
2644	int vrc = fileRemoveInternal(Utf8Str(aPath), &guestRc);
2645	if (RT_FAILURE(vrc))
2646	{
2647	switch (vrc)
2648	{
2649	case VERR_GSTCTL_GUEST_ERROR:
2650	hr = GuestProcess::setErrorExternal(this, guestRc);
2651	break;
2652
2653	default:
2654	hr = setError(VBOX_E_IPRT_ERROR, tr("Removing file \"%s\" failed: %Rrc"),
2655	Utf8Str(aPath).c_str(), vrc);
2656	break;
2657	}
2658	}
2659
2660	return hr;
2661	#endif /* VBOX_WITH_GUEST_CONTROL */
2662	}
2663
2664	STDMETHODIMP GuestSession::FileOpen(IN_BSTR aPath, IN_BSTR aOpenMode, IN_BSTR aDisposition, ULONG aCreationMode, LONG64 aOffset, IGuestFile **aFile)
2665	{
2666	#ifndef VBOX_WITH_GUEST_CONTROL
2667	ReturnComNotImplemented();
2668	#else
2669	LogFlowThisFuncEnter();
2670
2671	if (RT_UNLIKELY((aPath) == NULL \|\| *(aPath) == '\0'))
2672	return setError(E_INVALIDARG, tr("No file to open specified"));
2673	if (RT_UNLIKELY((aOpenMode) == NULL \|\| *(aOpenMode) == '\0'))
2674	return setError(E_INVALIDARG, tr("No open mode specified"));
2675	if (RT_UNLIKELY((aDisposition) == NULL \|\| *(aDisposition) == '\0'))
2676	return setError(E_INVALIDARG, tr("No disposition mode specified"));
2677
2678	CheckComArgOutPointerValid(aFile);
2679
2680	AutoCaller autoCaller(this);
2681	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2682
2683	HRESULT hr = isReadyExternal();
2684	if (FAILED(hr))
2685	return hr;
2686
2687	/** @todo Validate open mode. */
2688	/** @todo Validate disposition mode. */
2689
2690	/** @todo Validate creation mode. */
2691	uint32_t uCreationMode = 0;
2692
2693	GuestFileOpenInfo openInfo;
2694	openInfo.mFileName = Utf8Str(aPath);
2695	openInfo.mOpenMode = Utf8Str(aOpenMode);
2696	openInfo.mDisposition = Utf8Str(aDisposition);
2697	openInfo.mCreationMode = aCreationMode;
2698	openInfo.mInitialOffset = aOffset;
2699
2700	ComObjPtr <GuestFile> pFile; int guestRc;
2701	int vrc = fileOpenInternal(openInfo, pFile, &guestRc);
2702	if (RT_SUCCESS(vrc))
2703	{
2704	/* Return directory object to the caller. */
2705	hr = pFile.queryInterfaceTo(aFile);
2706	}
2707	else
2708	{
2709	switch (vrc)
2710	{
2711	case VERR_GSTCTL_GUEST_ERROR:
2712	hr = GuestFile::setErrorExternal(this, guestRc);
2713	break;
2714
2715	default:
2716	hr = setError(VBOX_E_IPRT_ERROR, tr("Opening guest file \"%s\" failed: %Rrc"),
2717	Utf8Str(aPath).c_str(), vrc);
2718	break;
2719	}
2720	}
2721
2722	return hr;
2723	#endif /* VBOX_WITH_GUEST_CONTROL */
2724	}
2725
2726	STDMETHODIMP GuestSession::FileQueryInfo(IN_BSTR aPath, IGuestFsObjInfo **aInfo)
2727	{
2728	#ifndef VBOX_WITH_GUEST_CONTROL
2729	ReturnComNotImplemented();
2730	#else
2731	LogFlowThisFuncEnter();
2732
2733	if (RT_UNLIKELY((aPath) == NULL \|\| *(aPath) == '\0'))
2734	return setError(E_INVALIDARG, tr("No file to query information for specified"));
2735	CheckComArgOutPointerValid(aInfo);
2736
2737	AutoCaller autoCaller(this);
2738	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2739
2740	HRESULT hr = S_OK;
2741
2742	GuestFsObjData objData; int guestRc;
2743	int vrc = fileQueryInfoInternal(Utf8Str(aPath), objData, &guestRc);
2744	if (RT_SUCCESS(vrc))
2745	{
2746	ComObjPtr<GuestFsObjInfo> pFsObjInfo;
2747	hr = pFsObjInfo.createObject();
2748	if (FAILED(hr)) return hr;
2749
2750	vrc = pFsObjInfo->init(objData);
2751	if (RT_SUCCESS(vrc))
2752	{
2753	hr = pFsObjInfo.queryInterfaceTo(aInfo);
2754	if (FAILED(hr)) return hr;
2755	}
2756	}
2757
2758	if (RT_FAILURE(vrc))
2759	{
2760	switch (vrc)
2761	{
2762	case VERR_GSTCTL_GUEST_ERROR:
2763	hr = GuestProcess::setErrorExternal(this, guestRc);
2764	break;
2765
2766	case VERR_NOT_A_FILE:
2767	hr = setError(VBOX_E_IPRT_ERROR, tr("Element exists but is not a file"));
2768	break;
2769
2770	default:
2771	hr = setError(VBOX_E_IPRT_ERROR, tr("Querying file information failed: %Rrc"), vrc);
2772	break;
2773	}
2774	}
2775
2776	return hr;
2777	#endif /* VBOX_WITH_GUEST_CONTROL */
2778	}
2779
2780	STDMETHODIMP GuestSession::FileQuerySize(IN_BSTR aPath, LONG64 *aSize)
2781	{
2782	#ifndef VBOX_WITH_GUEST_CONTROL
2783	ReturnComNotImplemented();
2784	#else
2785	LogFlowThisFuncEnter();
2786
2787	if (RT_UNLIKELY((aPath) == NULL \|\| *(aPath) == '\0'))
2788	return setError(E_INVALIDARG, tr("No file to query size for specified"));
2789	CheckComArgOutPointerValid(aSize);
2790
2791	AutoCaller autoCaller(this);
2792	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2793
2794	HRESULT hr = S_OK;
2795
2796	int64_t llSize; int guestRc;
2797	int vrc = fileQuerySizeInternal(Utf8Str(aPath), &llSize, &guestRc);
2798	if (RT_SUCCESS(vrc))
2799	{
2800	*aSize = llSize;
2801	}
2802	else
2803	{
2804	switch (vrc)
2805	{
2806	case VERR_GSTCTL_GUEST_ERROR:
2807	hr = GuestProcess::setErrorExternal(this, guestRc);
2808	break;
2809
2810	default:
2811	hr = setError(VBOX_E_IPRT_ERROR, tr("Querying file size failed: %Rrc"), vrc);
2812	break;
2813	}
2814	}
2815
2816	return hr;
2817	#endif /* VBOX_WITH_GUEST_CONTROL */
2818	}
2819
2820	STDMETHODIMP GuestSession::FileRename(IN_BSTR aSource, IN_BSTR aDest, ComSafeArrayIn(PathRenameFlag_T, aFlags))
2821	{
2822	#ifndef VBOX_WITH_GUEST_CONTROL
2823	ReturnComNotImplemented();
2824	#else
2825	LogFlowThisFuncEnter();
2826
2827	AutoCaller autoCaller(this);
2828	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2829
2830	ReturnComNotImplemented();
2831	#endif /* VBOX_WITH_GUEST_CONTROL */
2832	}
2833
2834	STDMETHODIMP GuestSession::FileSetACL(IN_BSTR aPath, IN_BSTR aACL)
2835	{
2836	#ifndef VBOX_WITH_GUEST_CONTROL
2837	ReturnComNotImplemented();
2838	#else
2839	LogFlowThisFuncEnter();
2840
2841	AutoCaller autoCaller(this);
2842	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2843
2844	ReturnComNotImplemented();
2845	#endif /* VBOX_WITH_GUEST_CONTROL */
2846	}
2847
2848	STDMETHODIMP GuestSession::ProcessCreate(IN_BSTR aCommand, ComSafeArrayIn(IN_BSTR, aArguments), ComSafeArrayIn(IN_BSTR, aEnvironment),
2849	ComSafeArrayIn(ProcessCreateFlag_T, aFlags), ULONG aTimeoutMS, IGuestProcess **aProcess)
2850	{
2851	#ifndef VBOX_WITH_GUEST_CONTROL
2852	ReturnComNotImplemented();
2853	#else
2854	LogFlowThisFuncEnter();
2855
2856	com::SafeArray<LONG> affinity;
2857
2858	return ProcessCreateEx(aCommand, ComSafeArrayInArg(aArguments), ComSafeArrayInArg(aEnvironment),
2859	ComSafeArrayInArg(aFlags), aTimeoutMS, ProcessPriority_Default, ComSafeArrayAsInParam(affinity), aProcess);
2860	#endif /* VBOX_WITH_GUEST_CONTROL */
2861	}
2862
2863	STDMETHODIMP GuestSession::ProcessCreateEx(IN_BSTR aCommand, ComSafeArrayIn(IN_BSTR, aArguments), ComSafeArrayIn(IN_BSTR, aEnvironment),
2864	ComSafeArrayIn(ProcessCreateFlag_T, aFlags), ULONG aTimeoutMS,
2865	ProcessPriority_T aPriority, ComSafeArrayIn(LONG, aAffinity),
2866	IGuestProcess **aProcess)
2867	{
2868	#ifndef VBOX_WITH_GUEST_CONTROL
2869	ReturnComNotImplemented();
2870	#else
2871	LogFlowThisFuncEnter();
2872
2873	if (RT_UNLIKELY((aCommand) == NULL \|\| *(aCommand) == '\0'))
2874	return setError(E_INVALIDARG, tr("No command to execute specified"));
2875	CheckComArgOutPointerValid(aProcess);
2876
2877	AutoCaller autoCaller(this);
2878	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2879
2880	HRESULT hr = isReadyExternal();
2881	if (FAILED(hr))
2882	return hr;
2883
2884	GuestProcessStartupInfo procInfo;
2885	procInfo.mCommand = Utf8Str(aCommand);
2886
2887	if (aArguments)
2888	{
2889	com::SafeArray<IN_BSTR> arguments(ComSafeArrayInArg(aArguments));
2890	for (size_t i = 0; i < arguments.size(); i++)
2891	procInfo.mArguments.push_back(Utf8Str(arguments[i]));
2892	}
2893
2894	int rc = VINF_SUCCESS;
2895
2896	/*
2897	* Create the process environment:
2898	* - Apply the session environment in a first step, and
2899	* - Apply environment variables specified by this call to
2900	* have the chance of overwriting/deleting session entries.
2901	*/
2902	procInfo.mEnvironment = mData.mEnvironment; /* Apply original session environment. */
2903
2904	if (aEnvironment)
2905	{
2906	com::SafeArray<IN_BSTR> environment(ComSafeArrayInArg(aEnvironment));
2907	for (size_t i = 0; i < environment.size() && RT_SUCCESS(rc); i++)
2908	rc = procInfo.mEnvironment.Set(Utf8Str(environment[i]));
2909	}
2910
2911	if (RT_SUCCESS(rc))
2912	{
2913	if (aFlags)
2914	{
2915	com::SafeArray<ProcessCreateFlag_T> flags(ComSafeArrayInArg(aFlags));
2916	for (size_t i = 0; i < flags.size(); i++)
2917	procInfo.mFlags \|= flags[i];
2918	}
2919
2920	procInfo.mTimeoutMS = aTimeoutMS;
2921
2922	if (aAffinity)
2923	{
2924	com::SafeArray<LONG> affinity(ComSafeArrayInArg(aAffinity));
2925	for (size_t i = 0; i < affinity.size(); i++)
2926	{
2927	if (affinity[i])
2928	procInfo.mAffinity \|= (uint64_t)1 << i;
2929	}
2930	}
2931
2932	procInfo.mPriority = aPriority;
2933
2934	ComObjPtr<GuestProcess> pProcess;
2935	rc = processCreateExInteral(procInfo, pProcess);
2936	if (RT_SUCCESS(rc))
2937	{
2938	/* Return guest session to the caller. */
2939	HRESULT hr2 = pProcess.queryInterfaceTo(aProcess);
2940	if (FAILED(hr2))
2941	rc = VERR_COM_OBJECT_NOT_FOUND;
2942
2943	if (RT_SUCCESS(rc))
2944	rc = pProcess->startProcessAsync();
2945	}
2946	}
2947
2948	if (RT_FAILURE(rc))
2949	{
2950	switch (rc)
2951	{
2952	case VERR_MAX_PROCS_REACHED:
2953	hr = setError(VBOX_E_IPRT_ERROR, tr("Maximum number of concurrent guest processes per session (%ld) reached"),
2954	VBOX_GUESTCTRL_MAX_OBJECTS);
2955	break;
2956
2957	/** @todo Add more errors here. */
2958
2959	default:
2960	hr = setError(VBOX_E_IPRT_ERROR, tr("Could not create guest process, rc=%Rrc"), rc);
2961	break;
2962	}
2963	}
2964
2965	LogFlowFuncLeaveRC(rc);
2966	return hr;
2967	#endif /* VBOX_WITH_GUEST_CONTROL */
2968	}
2969
2970	STDMETHODIMP GuestSession::ProcessGet(ULONG aPID, IGuestProcess **aProcess)
2971	{
2972	#ifndef VBOX_WITH_GUEST_CONTROL
2973	ReturnComNotImplemented();
2974	#else
2975	LogFlowThisFunc(("aPID=%RU32\n", aPID));
2976
2977	CheckComArgOutPointerValid(aProcess);
2978	if (aPID == 0)
2979	return setError(E_INVALIDARG, tr("No valid process ID (PID) specified"));
2980
2981	AutoCaller autoCaller(this);
2982	if (FAILED(autoCaller.rc())) return autoCaller.rc();
2983
2984	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2985
2986	HRESULT hr = S_OK;
2987
2988	ComObjPtr<GuestProcess> pProcess;
2989	int rc = processGetByPID(aPID, &pProcess);
2990	if (RT_FAILURE(rc))
2991	hr = setError(E_INVALIDARG, tr("No process with PID %RU32 found"), aPID);
2992
2993	/* This will set (aProcess) to NULL if pProgress is NULL. /
2994	HRESULT hr2 = pProcess.queryInterfaceTo(aProcess);
2995	if (SUCCEEDED(hr))
2996	hr = hr2;
2997
2998	LogFlowThisFunc(("aProcess=%p, hr=%Rhrc\n", *aProcess, hr));
2999	return hr;
3000	#endif /* VBOX_WITH_GUEST_CONTROL */
3001	}
3002
3003	STDMETHODIMP GuestSession::SymlinkCreate(IN_BSTR aSource, IN_BSTR aTarget, SymlinkType_T aType)
3004	{
3005	#ifndef VBOX_WITH_GUEST_CONTROL
3006	ReturnComNotImplemented();
3007	#else
3008	LogFlowThisFuncEnter();
3009
3010	AutoCaller autoCaller(this);
3011	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3012
3013	ReturnComNotImplemented();
3014	#endif /* VBOX_WITH_GUEST_CONTROL */
3015	}
3016
3017	STDMETHODIMP GuestSession::SymlinkExists(IN_BSTR aSymlink, BOOL *aExists)
3018	{
3019	#ifndef VBOX_WITH_GUEST_CONTROL
3020	ReturnComNotImplemented();
3021	#else
3022	LogFlowThisFuncEnter();
3023
3024	AutoCaller autoCaller(this);
3025	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3026
3027	ReturnComNotImplemented();
3028	#endif /* VBOX_WITH_GUEST_CONTROL */
3029	}
3030
3031	STDMETHODIMP GuestSession::SymlinkRead(IN_BSTR aSymlink, ComSafeArrayIn(SymlinkReadFlag_T, aFlags), BSTR *aTarget)
3032	{
3033	#ifndef VBOX_WITH_GUEST_CONTROL
3034	ReturnComNotImplemented();
3035	#else
3036	LogFlowThisFuncEnter();
3037
3038	AutoCaller autoCaller(this);
3039	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3040
3041	ReturnComNotImplemented();
3042	#endif /* VBOX_WITH_GUEST_CONTROL */
3043	}
3044
3045	STDMETHODIMP GuestSession::SymlinkRemoveDirectory(IN_BSTR aPath)
3046	{
3047	#ifndef VBOX_WITH_GUEST_CONTROL
3048	ReturnComNotImplemented();
3049	#else
3050	LogFlowThisFuncEnter();
3051
3052	AutoCaller autoCaller(this);
3053	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3054
3055	ReturnComNotImplemented();
3056	#endif /* VBOX_WITH_GUEST_CONTROL */
3057	}
3058
3059	STDMETHODIMP GuestSession::SymlinkRemoveFile(IN_BSTR aFile)
3060	{
3061	#ifndef VBOX_WITH_GUEST_CONTROL
3062	ReturnComNotImplemented();
3063	#else
3064	LogFlowThisFuncEnter();
3065
3066	AutoCaller autoCaller(this);
3067	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3068
3069	ReturnComNotImplemented();
3070	#endif /* VBOX_WITH_GUEST_CONTROL */
3071	}
3072
3073	STDMETHODIMP GuestSession::WaitFor(ULONG aWaitFlags, ULONG aTimeoutMS, GuestSessionWaitResult_T *aReason)
3074	{
3075	#ifndef VBOX_WITH_GUEST_CONTROL
3076	ReturnComNotImplemented();
3077	#else
3078	LogFlowThisFuncEnter();
3079
3080	CheckComArgOutPointerValid(aReason);
3081
3082	AutoCaller autoCaller(this);
3083	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3084
3085	/*
3086	* Note: Do not hold any locks here while waiting!
3087	*/
3088	HRESULT hr = S_OK;
3089
3090	int guestRc; GuestSessionWaitResult_T waitResult;
3091	int vrc = waitFor(aWaitFlags, aTimeoutMS, waitResult, &guestRc);
3092	if (RT_SUCCESS(vrc))
3093	{
3094	*aReason = waitResult;
3095	}
3096	else
3097	{
3098	switch (vrc)
3099	{
3100	case VERR_GSTCTL_GUEST_ERROR:
3101	hr = GuestSession::setErrorExternal(this, guestRc);
3102	break;
3103
3104	case VERR_TIMEOUT:
3105	*aReason = GuestSessionWaitResult_Timeout;
3106	break;
3107
3108	default:
3109	{
3110	const char *pszSessionName = mData.mSession.mName.c_str();
3111	hr = setError(VBOX_E_IPRT_ERROR,
3112	tr("Waiting for guest session \"%s\" failed: %Rrc"),
3113	pszSessionName ? pszSessionName : tr("Unnamed"), vrc);
3114	break;
3115	}
3116	}
3117	}
3118
3119	LogFlowFuncLeaveRC(vrc);
3120	return hr;
3121	#endif /* VBOX_WITH_GUEST_CONTROL */
3122	}
3123
3124	STDMETHODIMP GuestSession::WaitForArray(ComSafeArrayIn(GuestSessionWaitForFlag_T, aFlags), ULONG aTimeoutMS, GuestSessionWaitResult_T *aReason)
3125	{
3126	#ifndef VBOX_WITH_GUEST_CONTROL
3127	ReturnComNotImplemented();
3128	#else
3129	LogFlowThisFuncEnter();
3130
3131	CheckComArgOutPointerValid(aReason);
3132
3133	AutoCaller autoCaller(this);
3134	if (FAILED(autoCaller.rc())) return autoCaller.rc();
3135
3136	/*
3137	* Note: Do not hold any locks here while waiting!
3138	*/
3139	uint32_t fWaitFor = GuestSessionWaitForFlag_None;
3140	com::SafeArray<GuestSessionWaitForFlag_T> flags(ComSafeArrayInArg(aFlags));
3141	for (size_t i = 0; i < flags.size(); i++)
3142	fWaitFor \|= flags[i];
3143
3144	return WaitFor(fWaitFor, aTimeoutMS, aReason);
3145	#endif /* VBOX_WITH_GUEST_CONTROL */
3146	}
3147

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

source: vbox/trunk/src/VBox/Main/src-client/GuestSessionImpl.cpp@ 47167

Download in other formats: