GuestSessionImpl.cpp@ 99425

Last change on this file since 99425 was 99416, checked in by vboxsync, 20 months ago
Guest Control/Main: Treat reported Guest Additions versions of "0.0.0" (or 0) through VMMDev as Guest Additions not being found or not ready (yet) within GuestSession::i_determineProtocolVersion() (via vmmdevUpdateGuestInfo[2]).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 178.3 KB

Line
1	/* $Id: GuestSessionImpl.cpp 99416 2023-04-17 09:14:22Z vboxsync $ */
2	/** @file
3	* VirtualBox Main - Guest session handling.
4	*/
5
6	/*
7	* Copyright (C) 2012-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_MAIN_GUESTSESSION
33	#include "LoggingNew.h"
34
35	#include "GuestImpl.h"
36	#ifndef VBOX_WITH_GUEST_CONTROL
37	# error "VBOX_WITH_GUEST_CONTROL must defined in this file"
38	#endif
39	#include "GuestSessionImpl.h"
40	#include "GuestSessionImplTasks.h"
41	#include "GuestFsInfoImpl.h"
42	#include "GuestCtrlImplPrivate.h"
43	#include "VirtualBoxErrorInfoImpl.h"
44
45	#include "Global.h"
46	#include "AutoCaller.h"
47	#include "ProgressImpl.h"
48	#include "VBoxEvents.h"
49	#include "VMMDev.h"
50	#include "ThreadTask.h"
51
52	#include <memory> /* For auto_ptr. */
53
54	#include <iprt/cpp/utils.h> /* For unconst(). */
55	#include <iprt/ctype.h>
56	#include <iprt/env.h>
57	#include <iprt/file.h> /* For CopyTo/From. */
58	#include <iprt/path.h>
59	#include <iprt/rand.h>
60
61	#include <VBox/com/array.h>
62	#include <VBox/com/listeners.h>
63	#include <VBox/version.h>
64
65
66	/**
67	* Base class representing an internal
68	* asynchronous session task.
69	*/
70	class GuestSessionTaskInternal : public ThreadTask
71	{
72	public:
73
74	GuestSessionTaskInternal(GuestSession *pSession)
75	: ThreadTask("GenericGuestSessionTaskInternal")
76	, mSession(pSession)
77	, mVrc(VINF_SUCCESS) { }
78
79	virtual ~GuestSessionTaskInternal(void) { }
80
81	/** Returns the last set result code. */
82	int vrc(void) const { return mVrc; }
83	/** Returns whether the last set result code indicates success or not. */
84	bool isOk(void) const { return RT_SUCCESS(mVrc); }
85	/** Returns the task's guest session object. */
86	const ComObjPtr<GuestSession> &Session(void) const { return mSession; }
87
88	protected:
89
90	/** Guest session the task belongs to. */
91	const ComObjPtr<GuestSession> mSession;
92	/** The last set VBox status code. */
93	int mVrc;
94	};
95
96	/**
97	* Class for asynchronously starting a guest session.
98	*/
99	class GuestSessionTaskInternalStart : public GuestSessionTaskInternal
100	{
101	public:
102
103	GuestSessionTaskInternalStart(GuestSession *pSession)
104	: GuestSessionTaskInternal(pSession)
105	{
106	m_strTaskName = "gctlSesStart";
107	}
108
109	void handler()
110	{
111	/* Ignore return code */
112	GuestSession::i_startSessionThreadTask(this);
113	}
114	};
115
116	/**
117	* Internal listener class to serve events in an
118	* active manner, e.g. without polling delays.
119	*/
120	class GuestSessionListener
121	{
122	public:
123
124	GuestSessionListener(void)
125	{
126	}
127
128	virtual ~GuestSessionListener(void)
129	{
130	}
131
132	HRESULT init(GuestSession *pSession)
133	{
134	AssertPtrReturn(pSession, E_POINTER);
135	mSession = pSession;
136	return S_OK;
137	}
138
139	void uninit(void)
140	{
141	mSession = NULL;
142	}
143
144	STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent *aEvent)
145	{
146	switch (aType)
147	{
148	case VBoxEventType_OnGuestSessionStateChanged:
149	{
150	AssertPtrReturn(mSession, E_POINTER);
151	int vrc2 = mSession->signalWaitEvent(aType, aEvent);
152	RT_NOREF(vrc2);
153	#ifdef DEBUG_andy
154	LogFlowFunc(("Signalling events of type=%RU32, session=%p resulted in vrc2=%Rrc\n", aType, mSession, vrc2));
155	#endif
156	break;
157	}
158
159	default:
160	AssertMsgFailed(("Unhandled event %RU32\n", aType));
161	break;
162	}
163
164	return S_OK;
165	}
166
167	private:
168
169	GuestSession *mSession;
170	};
171	typedef ListenerImpl<GuestSessionListener, GuestSession*> GuestSessionListenerImpl;
172
173	VBOX_LISTENER_DECLARE(GuestSessionListenerImpl)
174
175	// constructor / destructor
176	/////////////////////////////////////////////////////////////////////////////
177
178	DEFINE_EMPTY_CTOR_DTOR(GuestSession)
179
180	HRESULT GuestSession::FinalConstruct(void)
181	{
182	LogFlowThisFuncEnter();
183	return BaseFinalConstruct();
184	}
185
186	void GuestSession::FinalRelease(void)
187	{
188	LogFlowThisFuncEnter();
189	uninit();
190	BaseFinalRelease();
191	LogFlowThisFuncLeave();
192	}
193
194	// public initializer/uninitializer for internal purposes only
195	/////////////////////////////////////////////////////////////////////////////
196
197	/**
198	* Initializes a guest session but does not open in on the guest side
199	* yet. This needs to be done via the openSession() / openSessionAsync calls.
200	*
201	* @returns VBox status code.
202	* @retval VERR_NOT_FOUND if the Guest Additions were not found (or were not reported yet).
203	* @param pGuest Guest object the guest session belongs to.
204	* @param ssInfo Guest session startup info to use.
205	* @param guestCreds Guest credentials to use for starting a guest session
206	* with a specific guest account.
207	*/
208	int GuestSession::init(Guest *pGuest, const GuestSessionStartupInfo &ssInfo,
209	const GuestCredentials &guestCreds)
210	{
211	LogFlowThisFunc(("pGuest=%p, ssInfo=%p, guestCreds=%p\n",
212	pGuest, &ssInfo, &guestCreds));
213
214	/* Enclose the state transition NotReady->InInit->Ready. */
215	AutoInitSpan autoInitSpan(this);
216	AssertReturn(autoInitSpan.isOk(), VERR_OBJECT_DESTROYED);
217
218	AssertPtrReturn(pGuest, VERR_INVALID_POINTER);
219
220	/*
221	* Initialize our data members from the input.
222	*/
223	mParent = pGuest;
224
225	/* Copy over startup info. */
226	/** @todo Use an overloaded copy operator. Later. */
227	mData.mSession.mID = ssInfo.mID;
228	mData.mSession.mIsInternal = ssInfo.mIsInternal;
229	mData.mSession.mName = ssInfo.mName;
230	mData.mSession.mOpenFlags = ssInfo.mOpenFlags;
231	mData.mSession.mOpenTimeoutMS = ssInfo.mOpenTimeoutMS;
232
233	/* Copy over session credentials. */
234	/** @todo Use an overloaded copy operator. Later. */
235	mData.mCredentials.mUser = guestCreds.mUser;
236	mData.mCredentials.mPassword = guestCreds.mPassword;
237	mData.mCredentials.mDomain = guestCreds.mDomain;
238
239	/* Initialize the remainder of the data. */
240	mData.mVrc = VINF_SUCCESS;
241	mData.mStatus = GuestSessionStatus_Undefined;
242	mData.mpBaseEnvironment = NULL;
243
244	/*
245	* Register an object for the session itself to clearly
246	* distinguish callbacks which are for this session directly, or for
247	* objects (like files, directories, ...) which are bound to this session.
248	*/
249	int vrc = i_objectRegister(NULL /* pObject */, SESSIONOBJECTTYPE_SESSION, &mData.mObjectID);
250	if (RT_SUCCESS(vrc))
251	{
252	vrc = mData.mEnvironmentChanges.initChangeRecord(pGuest->i_isGuestInWindowsNtFamily()
253	? RTENV_CREATE_F_ALLOW_EQUAL_FIRST_IN_VAR : 0);
254	if (RT_SUCCESS(vrc))
255	{
256	vrc = RTCritSectInit(&mWaitEventCritSect);
257	AssertRC(vrc);
258	}
259	}
260
261	if (RT_SUCCESS(vrc))
262	vrc = i_determineProtocolVersion();
263
264	if (RT_SUCCESS(vrc))
265	{
266	/*
267	* <Replace this if you figure out what the code is doing.>
268	*/
269	HRESULT hrc = unconst(mEventSource).createObject();
270	if (SUCCEEDED(hrc))
271	hrc = mEventSource->init();
272	if (SUCCEEDED(hrc))
273	{
274	try
275	{
276	GuestSessionListener *pListener = new GuestSessionListener();
277	ComObjPtr<GuestSessionListenerImpl> thisListener;
278	hrc = thisListener.createObject();
279	if (SUCCEEDED(hrc))
280	hrc = thisListener->init(pListener, this); /* thisListener takes ownership of pListener. */
281	if (SUCCEEDED(hrc))
282	{
283	com::SafeArray <VBoxEventType_T> eventTypes;
284	eventTypes.push_back(VBoxEventType_OnGuestSessionStateChanged);
285	hrc = mEventSource->RegisterListener(thisListener,
286	ComSafeArrayAsInParam(eventTypes),
287	TRUE /* Active listener */);
288	if (SUCCEEDED(hrc))
289	{
290	mLocalListener = thisListener;
291
292	/*
293	* Mark this object as operational and return success.
294	*/
295	autoInitSpan.setSucceeded();
296	LogFlowThisFunc(("mName=%s mID=%RU32 mIsInternal=%RTbool vrc=VINF_SUCCESS\n",
297	mData.mSession.mName.c_str(), mData.mSession.mID, mData.mSession.mIsInternal));
298	return VINF_SUCCESS;
299	}
300	}
301	}
302	catch (std::bad_alloc &)
303	{
304	hrc = E_OUTOFMEMORY;
305	}
306	}
307	vrc = Global::vboxStatusCodeFromCOM(hrc);
308	}
309
310	autoInitSpan.setFailed();
311	LogThisFunc(("Failed! mName=%s mID=%RU32 mIsInternal=%RTbool => vrc=%Rrc\n",
312	mData.mSession.mName.c_str(), mData.mSession.mID, mData.mSession.mIsInternal, vrc));
313	return vrc;
314	}
315
316	/**
317	* Uninitializes the instance.
318	* Called from FinalRelease().
319	*/
320	void GuestSession::uninit(void)
321	{
322	/* Enclose the state transition Ready->InUninit->NotReady. */
323	AutoUninitSpan autoUninitSpan(this);
324	if (autoUninitSpan.uninitDone())
325	return;
326
327	LogFlowThisFuncEnter();
328
329	/* Call i_onRemove to take care of the object cleanups. */
330	i_onRemove();
331
332	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
333
334	/* Unregister the session's object ID. */
335	i_objectUnregister(mData.mObjectID);
336
337	Assert(mData.mObjects.size () == 0);
338	mData.mObjects.clear();
339
340	mData.mEnvironmentChanges.reset();
341
342	if (mData.mpBaseEnvironment)
343	{
344	mData.mpBaseEnvironment->releaseConst();
345	mData.mpBaseEnvironment = NULL;
346	}
347
348	/* Unitialize our local listener. */
349	mLocalListener.setNull();
350
351	baseUninit();
352
353	LogFlowFuncLeave();
354	}
355
356	// implementation of public getters/setters for attributes
357	/////////////////////////////////////////////////////////////////////////////
358
359	HRESULT GuestSession::getUser(com::Utf8Str &aUser)
360	{
361	LogFlowThisFuncEnter();
362
363	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
364
365	aUser = mData.mCredentials.mUser;
366
367	LogFlowThisFuncLeave();
368	return S_OK;
369	}
370
371	HRESULT GuestSession::getDomain(com::Utf8Str &aDomain)
372	{
373	LogFlowThisFuncEnter();
374
375	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
376
377	aDomain = mData.mCredentials.mDomain;
378
379	LogFlowThisFuncLeave();
380	return S_OK;
381	}
382
383	HRESULT GuestSession::getName(com::Utf8Str &aName)
384	{
385	LogFlowThisFuncEnter();
386
387	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
388
389	aName = mData.mSession.mName;
390
391	LogFlowThisFuncLeave();
392	return S_OK;
393	}
394
395	HRESULT GuestSession::getId(ULONG *aId)
396	{
397	LogFlowThisFuncEnter();
398
399	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
400
401	*aId = mData.mSession.mID;
402
403	LogFlowThisFuncLeave();
404	return S_OK;
405	}
406
407	HRESULT GuestSession::getStatus(GuestSessionStatus_T *aStatus)
408	{
409	LogFlowThisFuncEnter();
410
411	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
412
413	*aStatus = mData.mStatus;
414
415	LogFlowThisFuncLeave();
416	return S_OK;
417	}
418
419	HRESULT GuestSession::getTimeout(ULONG *aTimeout)
420	{
421	LogFlowThisFuncEnter();
422
423	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
424
425	*aTimeout = mData.mTimeout;
426
427	LogFlowThisFuncLeave();
428	return S_OK;
429	}
430
431	HRESULT GuestSession::setTimeout(ULONG aTimeout)
432	{
433	LogFlowThisFuncEnter();
434
435	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
436
437	mData.mTimeout = aTimeout;
438
439	LogFlowThisFuncLeave();
440	return S_OK;
441	}
442
443	HRESULT GuestSession::getProtocolVersion(ULONG *aProtocolVersion)
444	{
445	LogFlowThisFuncEnter();
446
447	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
448
449	*aProtocolVersion = mData.mProtocolVersion;
450
451	LogFlowThisFuncLeave();
452	return S_OK;
453	}
454
455	HRESULT GuestSession::getEnvironmentChanges(std::vector<com::Utf8Str> &aEnvironmentChanges)
456	{
457	LogFlowThisFuncEnter();
458
459	int vrc;
460	{
461	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
462	vrc = mData.mEnvironmentChanges.queryPutEnvArray(&aEnvironmentChanges);
463	}
464
465	LogFlowFuncLeaveRC(vrc);
466	return Global::vboxStatusCodeToCOM(vrc);
467	}
468
469	HRESULT GuestSession::setEnvironmentChanges(const std::vector<com::Utf8Str> &aEnvironmentChanges)
470	{
471	LogFlowThisFuncEnter();
472
473	int vrc;
474	size_t idxError = ~(size_t)0;
475	{
476	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
477	mData.mEnvironmentChanges.reset();
478	vrc = mData.mEnvironmentChanges.applyPutEnvArray(aEnvironmentChanges, &idxError);
479	}
480
481	LogFlowFuncLeaveRC(vrc);
482	if (RT_SUCCESS(vrc))
483	return S_OK;
484	if (vrc == VERR_ENV_INVALID_VAR_NAME)
485	return setError(E_INVALIDARG, tr("Invalid environment variable name '%s', index %zu"),
486	aEnvironmentChanges[idxError].c_str(), idxError);
487	return setErrorBoth(Global::vboxStatusCodeToCOM(vrc), vrc, tr("Failed to apply '%s', index %zu (%Rrc)"),
488	aEnvironmentChanges[idxError].c_str(), idxError, vrc);
489	}
490
491	HRESULT GuestSession::getEnvironmentBase(std::vector<com::Utf8Str> &aEnvironmentBase)
492	{
493	LogFlowThisFuncEnter();
494
495	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
496	HRESULT hrc;
497	if (mData.mpBaseEnvironment)
498	{
499	int vrc = mData.mpBaseEnvironment->queryPutEnvArray(&aEnvironmentBase);
500	hrc = Global::vboxStatusCodeToCOM(vrc);
501	}
502	else if (mData.mProtocolVersion < 99999)
503	hrc = setError(VBOX_E_NOT_SUPPORTED, tr("The base environment feature is not supported by the Guest Additions"));
504	else
505	hrc = setError(VBOX_E_INVALID_OBJECT_STATE, tr("The base environment has not yet been reported by the guest"));
506
507	LogFlowFuncLeave();
508	return hrc;
509	}
510
511	HRESULT GuestSession::getProcesses(std::vector<ComPtr<IGuestProcess> > &aProcesses)
512	{
513	LogFlowThisFuncEnter();
514
515	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
516
517	aProcesses.resize(mData.mProcesses.size());
518	size_t i = 0;
519	for (SessionProcesses::iterator it = mData.mProcesses.begin();
520	it != mData.mProcesses.end();
521	++it, ++i)
522	{
523	it->second.queryInterfaceTo(aProcesses[i].asOutParam());
524	}
525
526	LogFlowFunc(("mProcesses=%zu\n", aProcesses.size()));
527	return S_OK;
528	}
529
530	HRESULT GuestSession::getPathStyle(PathStyle_T *aPathStyle)
531	{
532	*aPathStyle = i_getGuestPathStyle();
533	return S_OK;
534	}
535
536	HRESULT GuestSession::getCurrentDirectory(com::Utf8Str &aCurrentDirectory)
537	{
538	RT_NOREF(aCurrentDirectory);
539	ReturnComNotImplemented();
540	}
541
542	HRESULT GuestSession::setCurrentDirectory(const com::Utf8Str &aCurrentDirectory)
543	{
544	RT_NOREF(aCurrentDirectory);
545	ReturnComNotImplemented();
546	}
547
548	HRESULT GuestSession::getUserHome(com::Utf8Str &aUserHome)
549	{
550	HRESULT hrc = i_isStartedExternal();
551	if (FAILED(hrc))
552	return hrc;
553
554	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
555	int vrc = i_pathUserHome(aUserHome, &vrcGuest);
556	if (RT_FAILURE(vrc))
557	{
558	switch (vrc)
559	{
560	case VERR_GSTCTL_GUEST_ERROR:
561	{
562	switch (vrcGuest)
563	{
564	case VERR_NOT_SUPPORTED:
565	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest,
566	tr("Getting the user's home path is not supported by installed Guest Additions"));
567	break;
568
569	default:
570	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest,
571	tr("Getting the user's home path failed on the guest: %Rrc"), vrcGuest);
572	break;
573	}
574	break;
575	}
576
577	default:
578	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Getting the user's home path failed: %Rrc"), vrc);
579	break;
580	}
581	}
582
583	return hrc;
584	}
585
586	HRESULT GuestSession::getUserDocuments(com::Utf8Str &aUserDocuments)
587	{
588	HRESULT hrc = i_isStartedExternal();
589	if (FAILED(hrc))
590	return hrc;
591
592	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
593	int vrc = i_pathUserDocuments(aUserDocuments, &vrcGuest);
594	if (RT_FAILURE(vrc))
595	{
596	switch (vrc)
597	{
598	case VERR_GSTCTL_GUEST_ERROR:
599	{
600	switch (vrcGuest)
601	{
602	case VERR_NOT_SUPPORTED:
603	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest,
604	tr("Getting the user's documents path is not supported by installed Guest Additions"));
605	break;
606
607	default:
608	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest,
609	tr("Getting the user's documents path failed on the guest: %Rrc"), vrcGuest);
610	break;
611	}
612	break;
613	}
614
615	default:
616	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Getting the user's documents path failed: %Rrc"), vrc);
617	break;
618	}
619	}
620
621	return hrc;
622	}
623
624	HRESULT GuestSession::getDirectories(std::vector<ComPtr<IGuestDirectory> > &aDirectories)
625	{
626	LogFlowThisFuncEnter();
627
628	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
629
630	aDirectories.resize(mData.mDirectories.size());
631	size_t i = 0;
632	for (SessionDirectories::iterator it = mData.mDirectories.begin(); it != mData.mDirectories.end(); ++it, ++i)
633	{
634	it->second.queryInterfaceTo(aDirectories[i].asOutParam());
635	}
636
637	LogFlowFunc(("mDirectories=%zu\n", aDirectories.size()));
638	return S_OK;
639	}
640
641	HRESULT GuestSession::getFiles(std::vector<ComPtr<IGuestFile> > &aFiles)
642	{
643	LogFlowThisFuncEnter();
644
645	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
646
647	aFiles.resize(mData.mFiles.size());
648	size_t i = 0;
649	for(SessionFiles::iterator it = mData.mFiles.begin(); it != mData.mFiles.end(); ++it, ++i)
650	it->second.queryInterfaceTo(aFiles[i].asOutParam());
651
652	LogFlowFunc(("mDirectories=%zu\n", aFiles.size()));
653
654	return S_OK;
655	}
656
657	HRESULT GuestSession::getEventSource(ComPtr<IEventSource> &aEventSource)
658	{
659	LogFlowThisFuncEnter();
660
661	// no need to lock - lifetime constant
662	mEventSource.queryInterfaceTo(aEventSource.asOutParam());
663
664	LogFlowThisFuncLeave();
665	return S_OK;
666	}
667
668	// private methods
669	///////////////////////////////////////////////////////////////////////////////
670
671	/**
672	* Closes a guest session on the guest.
673	*
674	* @returns VBox status code.
675	* @param uFlags Guest session close flags.
676	* @param uTimeoutMS Timeout (in ms) to wait.
677	* @param pvrcGuest Where to return the guest error when
678	* VERR_GSTCTL_GUEST_ERROR was returned. Optional.
679	*
680	* @note Takes the read lock.
681	*/
682	int GuestSession::i_closeSession(uint32_t uFlags, uint32_t uTimeoutMS, int *pvrcGuest)
683	{
684	AssertPtrReturn(pvrcGuest, VERR_INVALID_POINTER);
685
686	LogFlowThisFunc(("uFlags=%x, uTimeoutMS=%RU32\n", uFlags, uTimeoutMS));
687
688	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
689
690	/* Guest Additions < 4.3 don't support closing dedicated
691	guest sessions, skip. */
692	if (mData.mProtocolVersion < 2)
693	{
694	LogFlowThisFunc(("Installed Guest Additions don't support closing dedicated sessions, skipping\n"));
695	return VINF_SUCCESS;
696	}
697
698	/** @todo uFlags validation. */
699
700	if (mData.mStatus != GuestSessionStatus_Started)
701	{
702	LogFlowThisFunc(("Session ID=%RU32 not started (anymore), status now is: %RU32\n",
703	mData.mSession.mID, mData.mStatus));
704	return VINF_SUCCESS;
705	}
706
707	int vrc;
708
709	GuestWaitEvent *pEvent = NULL;
710	GuestEventTypes eventTypes;
711	try
712	{
713	eventTypes.push_back(VBoxEventType_OnGuestSessionStateChanged);
714
715	vrc = registerWaitEventEx(mData.mSession.mID, mData.mObjectID, eventTypes, &pEvent);
716	}
717	catch (std::bad_alloc &)
718	{
719	vrc = VERR_NO_MEMORY;
720	}
721
722	if (RT_FAILURE(vrc))
723	return vrc;
724
725	LogFlowThisFunc(("Sending closing request to guest session ID=%RU32, uFlags=%x\n",
726	mData.mSession.mID, uFlags));
727
728	alock.release();
729
730	VBOXHGCMSVCPARM paParms[4];
731	int i = 0;
732	HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
733	HGCMSvcSetU32(&paParms[i++], uFlags);
734
735	vrc = i_sendMessage(HOST_MSG_SESSION_CLOSE, i, paParms, VBOX_GUESTCTRL_DST_BOTH);
736	if (RT_SUCCESS(vrc))
737	vrc = i_waitForStatusChange(pEvent, GuestSessionWaitForFlag_Terminate, uTimeoutMS,
738	NULL /* Session status */, pvrcGuest);
739
740	unregisterWaitEvent(pEvent);
741
742	LogFlowFuncLeaveRC(vrc);
743	return vrc;
744	}
745
746	/**
747	* Internal worker function for public APIs that handle copying elements from
748	* guest to the host.
749	*
750	* @return HRESULT
751	* @param SourceSet Source set specifying what to copy.
752	* @param strDestination Destination path on the host. Host path style.
753	* @param pProgress Progress object returned to the caller.
754	*/
755	HRESULT GuestSession::i_copyFromGuest(const GuestSessionFsSourceSet &SourceSet,
756	const com::Utf8Str &strDestination, ComPtr<IProgress> &pProgress)
757	{
758	HRESULT hrc = i_isStartedExternal();
759	if (FAILED(hrc))
760	return hrc;
761
762	LogFlowThisFuncEnter();
763
764	/* Validate stuff. */
765	if (RT_UNLIKELY(SourceSet.size() == 0 \|\| (SourceSet[0].strSource.c_str()) == '\0')) / At least one source must be present. */
766	return setError(E_INVALIDARG, tr("No source(s) specified"));
767	if (RT_UNLIKELY((strDestination.c_str()) == NULL \|\| *(strDestination.c_str()) == '\0'))
768	return setError(E_INVALIDARG, tr("No destination specified"));
769
770	GuestSessionFsSourceSet::const_iterator itSrc = SourceSet.begin();
771	while (itSrc != SourceSet.end())
772	{
773	LogRel2(("Guest Control: Copying '%s' from guest to '%s' on the host (type: %s, filter: %s)\n",
774	itSrc->strSource.c_str(), strDestination.c_str(), GuestBase::fsObjTypeToStr(itSrc->enmType), itSrc->strFilter.c_str()));
775	++itSrc;
776	}
777
778	/* Create a task and return the progress obejct for it. */
779	GuestSessionTaskCopyFrom *pTask = NULL;
780	try
781	{
782	pTask = new GuestSessionTaskCopyFrom(this /* GuestSession */, SourceSet, strDestination);
783	}
784	catch (std::bad_alloc &)
785	{
786	return setError(E_OUTOFMEMORY, tr("Failed to create GuestSessionTaskCopyFrom object"));
787	}
788
789	try
790	{
791	hrc = pTask->Init(Utf8StrFmt(tr("Copying to \"%s\" on the host"), strDestination.c_str()));
792	}
793	catch (std::bad_alloc &)
794	{
795	hrc = E_OUTOFMEMORY;
796	}
797	if (SUCCEEDED(hrc))
798	{
799	ComObjPtr<Progress> ptrProgressObj = pTask->GetProgressObject();
800
801	/* Kick off the worker thread. Note! Consumes pTask. */
802	hrc = pTask->createThreadWithType(RTTHREADTYPE_MAIN_HEAVY_WORKER);
803	pTask = NULL;
804	if (SUCCEEDED(hrc))
805	hrc = ptrProgressObj.queryInterfaceTo(pProgress.asOutParam());
806	else
807	hrc = setError(hrc, tr("Starting thread for copying from guest to the host failed"));
808	}
809	else
810	{
811	hrc = setError(hrc, tr("Initializing GuestSessionTaskCopyFrom object failed"));
812	delete pTask;
813	}
814
815	LogFlowFunc(("Returning %Rhrc\n", hrc));
816	return hrc;
817	}
818
819	/**
820	* Internal worker function for public APIs that handle copying elements from
821	* host to the guest.
822	*
823	* @return HRESULT
824	* @param SourceSet Source set specifying what to copy.
825	* @param strDestination Destination path on the guest. Guest path style.
826	* @param pProgress Progress object returned to the caller.
827	*/
828	HRESULT GuestSession::i_copyToGuest(const GuestSessionFsSourceSet &SourceSet,
829	const com::Utf8Str &strDestination, ComPtr<IProgress> &pProgress)
830	{
831	HRESULT hrc = i_isStartedExternal();
832	if (FAILED(hrc))
833	return hrc;
834
835	LogFlowThisFuncEnter();
836
837	GuestSessionFsSourceSet::const_iterator itSrc = SourceSet.begin();
838	while (itSrc != SourceSet.end())
839	{
840	LogRel2(("Guest Control: Copying '%s' from host to '%s' on the guest (type: %s, filter: %s)\n",
841	itSrc->strSource.c_str(), strDestination.c_str(), GuestBase::fsObjTypeToStr(itSrc->enmType), itSrc->strFilter.c_str()));
842	++itSrc;
843	}
844
845	/* Create a task and return the progress object for it. */
846	GuestSessionTaskCopyTo *pTask = NULL;
847	try
848	{
849	pTask = new GuestSessionTaskCopyTo(this /* GuestSession */, SourceSet, strDestination);
850	}
851	catch (std::bad_alloc &)
852	{
853	return setError(E_OUTOFMEMORY, tr("Failed to create GuestSessionTaskCopyTo object"));
854	}
855
856	try
857	{
858	hrc = pTask->Init(Utf8StrFmt(tr("Copying to \"%s\" on the guest"), strDestination.c_str()));
859	}
860	catch (std::bad_alloc &)
861	{
862	hrc = E_OUTOFMEMORY;
863	}
864	if (SUCCEEDED(hrc))
865	{
866	ComObjPtr<Progress> ptrProgressObj = pTask->GetProgressObject();
867
868	/* Kick off the worker thread. Note! Consumes pTask. */
869	hrc = pTask->createThreadWithType(RTTHREADTYPE_MAIN_HEAVY_WORKER);
870	pTask = NULL;
871	if (SUCCEEDED(hrc))
872	hrc = ptrProgressObj.queryInterfaceTo(pProgress.asOutParam());
873	else
874	hrc = setError(hrc, tr("Starting thread for copying from host to the guest failed"));
875	}
876	else
877	{
878	hrc = setError(hrc, tr("Initializing GuestSessionTaskCopyTo object failed"));
879	delete pTask;
880	}
881
882	LogFlowFunc(("Returning %Rhrc\n", hrc));
883	return hrc;
884	}
885
886	/**
887	* Validates and extracts directory copy flags from a comma-separated string.
888	*
889	* @return COM status, error set on failure
890	* @param strFlags String to extract flags from.
891	* @param fStrict Whether to set an error when an unknown / invalid flag is detected.
892	* @param pfFlags Where to store the extracted (and validated) flags.
893	*/
894	HRESULT GuestSession::i_directoryCopyFlagFromStr(const com::Utf8Str &strFlags, bool fStrict, DirectoryCopyFlag_T *pfFlags)
895	{
896	unsigned fFlags = DirectoryCopyFlag_None;
897
898	/* Validate and set flags. */
899	if (strFlags.isNotEmpty())
900	{
901	const char *pszNext = strFlags.c_str();
902	for (;;)
903	{
904	/* Find the next keyword, ignoring all whitespace. */
905	pszNext = RTStrStripL(pszNext);
906
907	const char * const pszComma = strchr(pszNext, ',');
908	size_t cchKeyword = pszComma ? pszComma - pszNext : strlen(pszNext);
909	while (cchKeyword > 0 && RT_C_IS_SPACE(pszNext[cchKeyword - 1]))
910	cchKeyword--;
911
912	if (cchKeyword > 0)
913	{
914	/* Convert keyword to flag. */
915	#define MATCH_KEYWORD(a_szKeyword) ( cchKeyword == sizeof(a_szKeyword) - 1U \
916	&& memcmp(pszNext, a_szKeyword, sizeof(a_szKeyword) - 1U) == 0)
917	if (MATCH_KEYWORD("CopyIntoExisting"))
918	fFlags \|= (unsigned)DirectoryCopyFlag_CopyIntoExisting;
919	else if (MATCH_KEYWORD("Recursive"))
920	fFlags \|= (unsigned)DirectoryCopyFlag_Recursive;
921	else if (MATCH_KEYWORD("FollowLinks"))
922	fFlags \|= (unsigned)DirectoryCopyFlag_FollowLinks;
923	else if (fStrict)
924	return setError(E_INVALIDARG, tr("Invalid directory copy flag: %.*s"), (int)cchKeyword, pszNext);
925	#undef MATCH_KEYWORD
926	}
927	if (!pszComma)
928	break;
929	pszNext = pszComma + 1;
930	}
931	}
932
933	if (pfFlags)
934	*pfFlags = (DirectoryCopyFlag_T)fFlags;
935	return S_OK;
936	}
937
938	#ifdef VBOX_WITH_GSTCTL_TOOLBOX_SUPPORT
939	/**
940	* Creates a directory on the guest.
941	*
942	* @returns VBox status code.
943	* @param strPath Path on guest to directory to create.
944	* @param uMode Creation mode to use (octal, 0777 max).
945	* @param uFlags Directory creation flags to use.
946	* @param pvrcGuest Where to return the guest error when
947	* VERR_GSTCTL_GUEST_ERROR was returned.
948	*/
949	int GuestSession::i_directoryCreateViaToolbox(const Utf8Str &strPath, uint32_t uMode, uint32_t uFlags, int *pvrcGuest)
950	{
951	int vrc = VINF_SUCCESS;
952
953	GuestProcessStartupInfo procInfo;
954	procInfo.mFlags = ProcessCreateFlag_Hidden;
955	procInfo.mExecutable = VBOXSERVICE_TOOL_MKDIR;
956
957	try
958	{
959	procInfo.mArguments.push_back(procInfo.mExecutable); /* Set argv0. */
960
961	/* Construct arguments. */
962	if (uFlags)
963	{
964	if (uFlags & DirectoryCreateFlag_Parents)
965	procInfo.mArguments.push_back(Utf8Str("--parents")); /* We also want to create the parent directories. */
966	else
967	vrc = VERR_INVALID_PARAMETER;
968	}
969
970	if ( RT_SUCCESS(vrc)
971	&& uMode)
972	{
973	procInfo.mArguments.push_back(Utf8Str("--mode")); /* Set the creation mode. */
974
975	char szMode[16];
976	if (RTStrPrintf(szMode, sizeof(szMode), "%o", uMode))
977	procInfo.mArguments.push_back(Utf8Str(szMode));
978	else
979	vrc = VERR_BUFFER_OVERFLOW;
980	}
981
982	procInfo.mArguments.push_back("--"); /* '--version' is a valid directory name. */
983	procInfo.mArguments.push_back(strPath); /* The directory we want to create. */
984	}
985	catch (std::bad_alloc &)
986	{
987	vrc = VERR_NO_MEMORY;
988	}
989
990	if (RT_SUCCESS(vrc))
991	vrc = GuestProcessToolbox::runTool(this, procInfo, pvrcGuest);
992
993	return vrc;
994	}
995	#endif /* VBOX_WITH_GSTCTL_TOOLBOX_SUPPORT */
996
997	/**
998	* Creates a directory on the guest.
999	*
1000	* @returns VBox status code.
1001	* @param strPath Path on guest to directory to create.
1002	* @param uMode Creation mode to use (octal, 0777 max).
1003	* @param uFlags Directory creation flags to use.
1004	* @param pvrcGuest Where to return the guest error when
1005	* VERR_GSTCTL_GUEST_ERROR was returned.
1006	*/
1007	int GuestSession::i_directoryCreate(const Utf8Str &strPath, uint32_t uMode, uint32_t uFlags, int *pvrcGuest)
1008	{
1009	AssertPtrReturn(pvrcGuest, VERR_INVALID_POINTER);
1010	LogFlowThisFunc(("strPath=%s, uMode=%x, uFlags=%x\n", strPath.c_str(), uMode, uFlags));
1011	*pvrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
1012
1013	int vrc = VINF_SUCCESS;
1014
1015	#ifdef VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS
1016	if (mParent->i_getGuestControlFeatures0() & VBOX_GUESTCTRL_GF_0_TOOLBOX_AS_CMDS)
1017	{
1018	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1019
1020	GuestWaitEvent *pEvent = NULL;
1021	vrc = registerWaitEvent(mData.mSession.mID, mData.mObjectID, &pEvent);
1022	if (RT_FAILURE(vrc))
1023	return vrc;
1024
1025	uint32_t fFlags = GSTCTL_CREATEDIRECTORY_F_NONE;
1026	if (uFlags & DirectoryCreateFlag_Parents)
1027	fFlags \|= GSTCTL_CREATEDIRECTORY_F_PARENTS;
1028	Assert(!(fFlags & ~GSTCTL_CREATEDIRECTORY_F_VALID_MASK));
1029
1030	/* Prepare HGCM call. */
1031	VBOXHGCMSVCPARM paParms[4];
1032	int i = 0;
1033	HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
1034	HGCMSvcSetPv (&paParms[i++], (void*)strPath.c_str(), (ULONG)strPath.length() + 1);
1035	HGCMSvcSetU32(&paParms[i++], uMode);
1036	HGCMSvcSetU32(&paParms[i++], fFlags);
1037	alock.release(); /* Drop lock before sending. */
1038
1039	vrc = i_sendMessage(HOST_MSG_DIR_CREATE, i, paParms);
1040	if (RT_SUCCESS(vrc))
1041	{
1042	vrc = pEvent->Wait(30 * 1000);
1043	if (RT_SUCCESS(vrc))
1044	{
1045	// Nothing to do here.
1046	}
1047	else if (pEvent->HasGuestError() && pvrcGuest)
1048	*pvrcGuest = pEvent->GuestResult();
1049	}
1050	}
1051	else
1052	#endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */
1053	{
1054	vrc = i_directoryCreateViaToolbox(strPath, uMode, uFlags, pvrcGuest);
1055	}
1056
1057	LogFlowFunc(("LEAVE: %Rrc pvrcGuest=%Rrc\n", vrc, pvrcGuest ? pvrcGuest : -VERR_IPE_UNINITIALIZED_STATUS));
1058	return vrc;
1059	}
1060
1061	/**
1062	* Checks if a directory on the guest exists.
1063	*
1064	* @returns \c true if directory exists on the guest, \c false if not.
1065	* @param strPath Path of directory to check.
1066	*/
1067	bool GuestSession::i_directoryExists(const Utf8Str &strPath)
1068	{
1069	GuestFsObjData objDataIgnored;
1070	int vrcGuestIgnored;
1071	int const vrc = i_directoryQueryInfo(strPath, true /* fFollowSymlinks */, objDataIgnored, &vrcGuestIgnored);
1072	return RT_SUCCESS(vrc);
1073	}
1074
1075	/**
1076	* Checks if a directory object exists and optionally returns its object.
1077	*
1078	* @returns \c true if directory object exists, or \c false if not.
1079	* @param uDirID ID of directory object to check.
1080	* @param pDir Where to return the found directory object on success.
1081	*/
1082	inline bool GuestSession::i_directoryExists(uint32_t uDirID, ComObjPtr<GuestDirectory> *pDir)
1083	{
1084	SessionDirectories::const_iterator it = mData.mDirectories.find(uDirID);
1085	if (it != mData.mDirectories.end())
1086	{
1087	if (pDir)
1088	*pDir = it->second;
1089	return true;
1090	}
1091	return false;
1092	}
1093
1094	/**
1095	* Queries information about a directory on the guest.
1096	*
1097	* @returns VBox status code, or VERR_NOT_A_DIRECTORY if the file system object exists but is not a directory.
1098	* @param strPath Path to directory to query information for.
1099	* @param fFollowSymlinks Whether to follow symlinks or not.
1100	* @param objData Where to store the information returned on success.
1101	* @param pvrcGuest Guest VBox status code, when returning
1102	* VERR_GSTCTL_GUEST_ERROR.
1103	*/
1104	int GuestSession::i_directoryQueryInfo(const Utf8Str &strPath, bool fFollowSymlinks, GuestFsObjData &objData, int *pvrcGuest)
1105	{
1106	AssertPtrReturn(pvrcGuest, VERR_INVALID_POINTER);
1107
1108	LogFlowThisFunc(("strPath=%s, fFollowSymlinks=%RTbool\n", strPath.c_str(), fFollowSymlinks));
1109
1110	int vrc = i_fsObjQueryInfo(strPath, fFollowSymlinks, objData, pvrcGuest);
1111	if (RT_SUCCESS(vrc))
1112	{
1113	vrc = objData.mType == FsObjType_Directory
1114	? VINF_SUCCESS : VERR_NOT_A_DIRECTORY;
1115	}
1116
1117	LogFlowFuncLeaveRC(vrc);
1118	return vrc;
1119	}
1120
1121	/**
1122	* Unregisters a directory object from a guest session.
1123	*
1124	* @returns VBox status code. VERR_NOT_FOUND if the directory is not registered (anymore).
1125	* @param pDirectory Directory object to unregister from session.
1126	*
1127	* @note Takes the write lock.
1128	*/
1129	int GuestSession::i_directoryUnregister(GuestDirectory *pDirectory)
1130	{
1131	AssertPtrReturn(pDirectory, VERR_INVALID_POINTER);
1132
1133	LogFlowThisFunc(("pDirectory=%p\n", pDirectory));
1134
1135	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1136
1137	const uint32_t idObject = pDirectory->getObjectID();
1138
1139	LogFlowFunc(("Removing directory (objectID=%RU32) ...\n", idObject));
1140
1141	int vrc = i_objectUnregister(idObject);
1142	if (RT_FAILURE(vrc))
1143	return vrc;
1144
1145	SessionDirectories::iterator itDirs = mData.mDirectories.find(idObject);
1146	AssertReturn(itDirs != mData.mDirectories.end(), VERR_NOT_FOUND);
1147
1148	/* Make sure to consume the pointer before the one of the iterator gets released. */
1149	ComObjPtr<GuestDirectory> pDirConsumed = pDirectory;
1150
1151	LogFlowFunc(("Removing directory ID=%RU32 (session %RU32, now total %zu directories)\n",
1152	idObject, mData.mSession.mID, mData.mDirectories.size()));
1153
1154	vrc = pDirConsumed->i_onUnregister();
1155	AssertRCReturn(vrc, vrc);
1156
1157	mData.mDirectories.erase(itDirs);
1158
1159	alock.release(); /* Release lock before firing off event. */
1160
1161	// ::FireGuestDirectoryRegisteredEvent(mEventSource, this /* Session /, pDirConsumed, false / Process unregistered */);
1162
1163	pDirConsumed.setNull();
1164
1165	LogFlowFuncLeaveRC(vrc);
1166	return vrc;
1167	}
1168
1169	/**
1170	* Removes a directory on the guest.
1171	*
1172	* @returns VBox status code.
1173	* @param strPath Path of directory on guest to remove.
1174	* @param fFlags Directory remove flags to use.
1175	* @param pvrcGuest Where to return the guest error when
1176	* VERR_GSTCTL_GUEST_ERROR was returned. Optional.
1177	*
1178	* @note Takes the read lock.
1179	*/
1180	int GuestSession::i_directoryRemove(const Utf8Str &strPath, uint32_t fFlags, int *pvrcGuest)
1181	{
1182	AssertReturn(!(fFlags & ~DIRREMOVEREC_FLAG_VALID_MASK), VERR_INVALID_PARAMETER);
1183	AssertPtrReturn(pvrcGuest, VERR_INVALID_POINTER);
1184
1185	LogFlowThisFunc(("strPath=%s, uFlags=0x%x\n", strPath.c_str(), fFlags));
1186
1187	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1188
1189	GuestWaitEvent *pEvent = NULL;
1190	int vrc = registerWaitEvent(mData.mSession.mID, mData.mObjectID, &pEvent);
1191	if (RT_FAILURE(vrc))
1192	return vrc;
1193
1194	/* Prepare HGCM call. */
1195	VBOXHGCMSVCPARM paParms[8];
1196	int i = 0;
1197	HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
1198	HGCMSvcSetPv(&paParms[i++], (void*)strPath.c_str(),
1199	(ULONG)strPath.length() + 1);
1200	HGCMSvcSetU32(&paParms[i++], fFlags);
1201
1202	alock.release(); /* Drop lock before sending. */
1203
1204	vrc = i_sendMessage(HOST_MSG_DIR_REMOVE, i, paParms);
1205	if (RT_SUCCESS(vrc))
1206	{
1207	vrc = pEvent->Wait(30 * 1000);
1208	if (pEvent->HasGuestError() && pvrcGuest)
1209	*pvrcGuest = pEvent->GuestResult();
1210	}
1211
1212	unregisterWaitEvent(pEvent);
1213
1214	LogFlowFuncLeaveRC(vrc);
1215	return vrc;
1216	}
1217
1218	/**
1219	* Creates a temporary directory / file on the guest (legacy version).
1220	*
1221	* @returns VBox status code.
1222	* @returns VERR_GSTCTL_GUEST_ERROR on received guest error.
1223	* @param strTemplate Name template to use.
1224	* \sa RTDirCreateTemp / RTDirCreateTempSecure.
1225	* @param strPath Path where to create the temporary directory / file.
1226	* @param fDirectory Whether to create a temporary directory or file.
1227	* @param strName Where to return the created temporary name on success.
1228	* @param fMode File mode to use for creation (octal, umask-style).
1229	* Ignored when \a fSecure is specified.
1230	* @param fSecure Whether to perform a secure creation or not.
1231	* @param pvrcGuest Guest VBox status code, when returning
1232	* VERR_GSTCTL_GUEST_ERROR.
1233	*/
1234	int GuestSession::i_fsCreateTempViaToolbox(const Utf8Str &strTemplate, const Utf8Str &strPath, bool fDirectory, Utf8Str &strName,
1235	uint32_t fMode, bool fSecure, int *pvrcGuest)
1236	{
1237	int vrc;
1238
1239	GuestProcessStartupInfo procInfo;
1240	procInfo.mFlags = ProcessCreateFlag_WaitForStdOut;
1241	try
1242	{
1243	procInfo.mExecutable = Utf8Str(VBOXSERVICE_TOOL_MKTEMP);
1244	procInfo.mArguments.push_back(procInfo.mExecutable); /* Set argv0. */
1245	procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
1246	if (fDirectory)
1247	procInfo.mArguments.push_back(Utf8Str("-d"));
1248	if (strPath.length()) /* Otherwise use /tmp or equivalent. */
1249	{
1250	procInfo.mArguments.push_back(Utf8Str("-t"));
1251	procInfo.mArguments.push_back(strPath);
1252	}
1253	/* Note: Secure flag and mode cannot be specified at the same time. */
1254	if (fSecure)
1255	{
1256	procInfo.mArguments.push_back(Utf8Str("--secure"));
1257	}
1258	else
1259	{
1260	procInfo.mArguments.push_back(Utf8Str("--mode"));
1261
1262	/* Note: Pass the mode unmodified down to the guest. See @ticketref{21394}. */
1263	char szMode[16];
1264	vrc = RTStrPrintf2(szMode, sizeof(szMode), "%d", fMode);
1265	AssertRCReturn(vrc, vrc);
1266	procInfo.mArguments.push_back(szMode);
1267	}
1268	procInfo.mArguments.push_back("--"); /* strTemplate could be '--help'. */
1269	procInfo.mArguments.push_back(strTemplate);
1270	}
1271	catch (std::bad_alloc &)
1272	{
1273	Log(("Out of memory!\n"));
1274	return VERR_NO_MEMORY;
1275	}
1276
1277	GuestCtrlStreamObjects stdOut;
1278	int vrcGuest;
1279	vrc = GuestProcessToolbox::runTool(this, procInfo, &vrcGuest, &stdOut);
1280	if (!GuestProcess::i_isGuestError(vrc))
1281	{
1282	GuestFsObjData objData;
1283	if (!stdOut.empty())
1284	{
1285	vrc = objData.FromToolboxMkTemp(stdOut.at(0));
1286	if (RT_FAILURE(vrc))
1287	{
1288	vrcGuest = vrc;
1289	if (pvrcGuest)
1290	*pvrcGuest = vrcGuest;
1291	vrc = VERR_GSTCTL_GUEST_ERROR;
1292	}
1293	}
1294	else
1295	vrc = VERR_BROKEN_PIPE;
1296
1297	if (RT_SUCCESS(vrc))
1298	strName = objData.mName;
1299	}
1300	else if (pvrcGuest)
1301	*pvrcGuest = vrcGuest;
1302
1303	return vrc;
1304	}
1305
1306	/**
1307	* Creates a temporary directory / file on the guest.
1308	*
1309	* @returns VBox status code.
1310	* @returns VERR_GSTCTL_GUEST_ERROR on received guest error.
1311	* @param strTemplate Name template to use.
1312	* \sa RTDirCreateTemp / RTDirCreateTempSecure.
1313	* @param strPath Path where to create the temporary directory / file.
1314	* @param fDirectory Whether to create a temporary directory or file.
1315	* @param strName Where to return the created temporary name on success.
1316	* @param fMode File mode to use for creation (octal, umask-style).
1317	* Ignored when \a fSecure is specified.
1318	* @param fSecure Whether to perform a secure creation or not.
1319	* @param pvrcGuest Guest VBox status code, when returning
1320	* VERR_GSTCTL_GUEST_ERROR.
1321	*/
1322	int GuestSession::i_fsCreateTemp(const Utf8Str &strTemplate, const Utf8Str &strPath, bool fDirectory, Utf8Str &strName,
1323	uint32_t fMode, bool fSecure, int *pvrcGuest)
1324	{
1325	AssertPtrReturn(pvrcGuest, VERR_INVALID_POINTER);
1326	AssertReturn(fSecure \|\| !(fMode & ~07777), VERR_INVALID_PARAMETER);
1327
1328	LogFlowThisFunc(("strTemplate=%s, strPath=%s, fDirectory=%RTbool, fMode=%o, fSecure=%RTbool\n",
1329	strTemplate.c_str(), strPath.c_str(), fDirectory, fMode, fSecure));
1330
1331	int vrc;
1332	#ifdef VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS
1333	if (mParent->i_getGuestControlFeatures0() & VBOX_GUESTCTRL_GF_0_TOOLBOX_AS_CMDS)
1334	{
1335	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1336
1337	GuestWaitEvent *pEvent = NULL;
1338	vrc = registerWaitEvent(mData.mSession.mID, mData.mObjectID, &pEvent);
1339	if (RT_FAILURE(vrc))
1340	return vrc;
1341
1342	uint32_t fFlags = GSTCTL_CREATETEMP_F_NONE;
1343	if (fDirectory)
1344	fFlags \|= GSTCTL_CREATETEMP_F_DIRECTORY;
1345	if (fSecure)
1346	fFlags \|= GSTCTL_CREATETEMP_F_SECURE;
1347	Assert(!(fFlags & ~GSTCTL_CREATETEMP_F_VALID_MASK));
1348
1349	/* Prepare HGCM call. */
1350	VBOXHGCMSVCPARM paParms[8];
1351	int i = 0;
1352	HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
1353	HGCMSvcSetStr(&paParms[i++], strTemplate.c_str());
1354	HGCMSvcSetStr(&paParms[i++], strPath.c_str());
1355	HGCMSvcSetU32(&paParms[i++], fFlags);
1356	HGCMSvcSetU32(&paParms[i++], fMode);
1357
1358	alock.release(); /* Drop lock before sending. */
1359
1360	vrc = i_sendMessage(HOST_MSG_FS_CREATE_TEMP, i, paParms);
1361	if (RT_SUCCESS(vrc))
1362	{
1363	vrc = pEvent->Wait(30 * 1000);
1364	if (RT_SUCCESS(vrc))
1365	{
1366	PCALLBACKDATA_FS_NOTIFY const pFsNotify = (PCALLBACKDATA_FS_NOTIFY)pEvent->Payload().Raw();
1367	AssertPtrReturn(pFsNotify, VERR_INVALID_POINTER);
1368	int vrcGuest = (int)pFsNotify->rc;
1369	if (RT_SUCCESS(vrcGuest))
1370	{
1371	AssertReturn(pFsNotify->uType == GUEST_FS_NOTIFYTYPE_CREATE_TEMP, VERR_INVALID_PARAMETER);
1372	AssertReturn(pFsNotify->u.CreateTemp.cbPath, VERR_INVALID_PARAMETER);
1373	strName = pFsNotify->u.CreateTemp.pszPath;
1374	RTStrFree(pFsNotify->u.CreateTemp.pszPath);
1375	}
1376	else
1377	{
1378	if (pvrcGuest)
1379	*pvrcGuest = vrcGuest;
1380	vrc = VERR_GSTCTL_GUEST_ERROR;
1381	}
1382	}
1383	else
1384	{
1385	if (pEvent->HasGuestError() && pvrcGuest)
1386	*pvrcGuest = pEvent->GuestResult();
1387	}
1388	}
1389	}
1390	else
1391	#endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */
1392	{
1393	vrc = i_fsCreateTempViaToolbox(strTemplate, strPath, fDirectory, strName, fMode, fSecure, pvrcGuest);
1394	}
1395
1396	LogFlowThisFunc(("Returning vrc=%Rrc, vrcGuest=%Rrc\n", vrc, pvrcGuest ? *pvrcGuest : VERR_IPE_UNINITIALIZED_STATUS));
1397	return vrc;
1398	}
1399
1400	/**
1401	* Open a directory on the guest.
1402	*
1403	* @returns VBox status code.
1404	* @returns VERR_GSTCTL_GUEST_ERROR on received guest error.
1405	* @param openInfo Open information to use.
1406	* @param pDirectory Where to return the guest directory object on success.
1407	* @param pvrcGuest Where to return the guest error when
1408	* VERR_GSTCTL_GUEST_ERROR was returned. Optional.
1409	*
1410	* @note Takes the write lock.
1411	*/
1412	int GuestSession::i_directoryOpen(const GuestDirectoryOpenInfo &openInfo, ComObjPtr<GuestDirectory> &pDirectory, int *pvrcGuest)
1413	{
1414	AssertPtrReturn(pvrcGuest, VERR_INVALID_POINTER);
1415
1416	LogFlowThisFunc(("strPath=%s, strPath=%s, uFlags=%x\n", openInfo.mPath.c_str(), openInfo.mFilter.c_str(), openInfo.mFlags));
1417
1418	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1419
1420	/* Create the directory object. */
1421	HRESULT hrc = pDirectory.createObject();
1422	if (FAILED(hrc))
1423	return Global::vboxStatusCodeFromCOM(hrc);
1424
1425	/* Register a new object ID. */
1426	uint32_t idObject;
1427	int vrc = i_objectRegister(pDirectory, SESSIONOBJECTTYPE_DIRECTORY, &idObject);
1428	if (RT_FAILURE(vrc))
1429	{
1430	pDirectory.setNull();
1431	return vrc;
1432	}
1433
1434	/**
1435	* If VBOX_WITH_GSTCTL_TOOLBOX_SUPPORT is enabled:
1436	*
1437	* We need to release the write lock first before opening the directory object below,
1438	* as we're starting a guest process as part of it. This in turn will try to acquire the session's
1439	* write lock. */
1440	alock.release();
1441
1442	Console *pConsole = mParent->i_getConsole();
1443	AssertPtr(pConsole);
1444
1445	vrc = pDirectory->init(pConsole, this /* Parent */, idObject, openInfo);
1446	if (RT_SUCCESS(vrc))
1447	vrc = pDirectory->i_open(pvrcGuest);
1448
1449	if (RT_FAILURE(vrc))
1450	{
1451	/* Make sure to acquire the write lock again before unregistering the object. */
1452	alock.acquire();
1453
1454	int vrc2 = i_objectUnregister(idObject);
1455	AssertRC(vrc2);
1456
1457	pDirectory.setNull();
1458	}
1459	else
1460	{
1461	/* Make sure to acquire the write lock again before continuing. */
1462	alock.acquire();
1463
1464	try
1465	{
1466	/* Add the created directory to our map. */
1467	mData.mDirectories[idObject] = pDirectory;
1468
1469	LogFlowFunc(("Added new guest directory \"%s\" (Session: %RU32) (now total %zu directories)\n",
1470	openInfo.mPath.c_str(), mData.mSession.mID, mData.mDirectories.size()));
1471
1472	alock.release(); /* Release lock before firing off event. */
1473
1474	/** @todo Fire off a VBoxEventType_OnGuestDirectoryRegistered event? */
1475	}
1476	catch (std::bad_alloc &)
1477	{
1478	vrc = VERR_NO_MEMORY;
1479	}
1480	}
1481
1482	if (RT_SUCCESS(vrc))
1483	{
1484	/* Nothing further to do here yet. */
1485	if (pvrcGuest)
1486	*pvrcGuest = VINF_SUCCESS;
1487	}
1488
1489	LogFlowFuncLeaveRC(vrc);
1490	return vrc;
1491	}
1492
1493	/**
1494	* Dispatches a host callback to its corresponding object.
1495	*
1496	* @return VBox status code. VERR_NOT_FOUND if no corresponding object was found.
1497	* @param pCtxCb Host callback context.
1498	* @param pSvcCb Service callback data.
1499	*
1500	* @note Takes the read lock.
1501	*/
1502	int GuestSession::i_dispatchToObject(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
1503	{
1504	LogFlowFunc(("pCtxCb=%p, pSvcCb=%p\n", pCtxCb, pSvcCb));
1505
1506	AssertPtrReturn(pCtxCb, VERR_INVALID_POINTER);
1507	AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
1508
1509	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1510
1511	/*
1512	* Find the object.
1513	*/
1514	int vrc = VERR_NOT_FOUND;
1515	const uint32_t idObject = VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(pCtxCb->uContextID);
1516	SessionObjects::const_iterator itObj = mData.mObjects.find(idObject);
1517	if (itObj != mData.mObjects.end())
1518	{
1519	/* Set protocol version so that pSvcCb can be interpreted right. */
1520	pCtxCb->uProtocol = mData.mProtocolVersion;
1521
1522	switch (itObj->second.enmType)
1523	{
1524	/* Note: The session object is special, as it does not inherit from GuestObject we could call
1525	* its dispatcher for -- so treat this separately and call it directly. */
1526	case SESSIONOBJECTTYPE_SESSION:
1527	{
1528	alock.release();
1529
1530	vrc = i_dispatchToThis(pCtxCb, pSvcCb);
1531	break;
1532	}
1533	case SESSIONOBJECTTYPE_DIRECTORY:
1534	{
1535	ComObjPtr<GuestDirectory> pObj((GuestDirectory *)itObj->second.pObject);
1536	AssertReturn(!pObj.isNull(), VERR_INVALID_POINTER);
1537
1538	alock.release();
1539
1540	vrc = pObj->i_callbackDispatcher(pCtxCb, pSvcCb);
1541	break;
1542	}
1543	case SESSIONOBJECTTYPE_FILE:
1544	{
1545	ComObjPtr<GuestFile> pObj((GuestFile *)itObj->second.pObject);
1546	AssertReturn(!pObj.isNull(), VERR_INVALID_POINTER);
1547
1548	alock.release();
1549
1550	vrc = pObj->i_callbackDispatcher(pCtxCb, pSvcCb);
1551	break;
1552	}
1553	case SESSIONOBJECTTYPE_PROCESS:
1554	{
1555	ComObjPtr<GuestProcess> pObj((GuestProcess *)itObj->second.pObject);
1556	AssertReturn(!pObj.isNull(), VERR_INVALID_POINTER);
1557
1558	alock.release();
1559
1560	vrc = pObj->i_callbackDispatcher(pCtxCb, pSvcCb);
1561	break;
1562	}
1563	default:
1564	AssertMsgFailed(("%d\n", itObj->second.enmType));
1565	vrc = VERR_INTERNAL_ERROR_4;
1566	break;
1567	}
1568	}
1569
1570	LogFlowFuncLeaveRC(vrc);
1571	return vrc;
1572	}
1573
1574	/**
1575	* Main handler for guest session messages from the guest.
1576	*
1577	* @returns VBox status code.
1578	* @param pCbCtx Host callback context from HGCM service.
1579	* @param pSvcCbData HGCM service callback data.
1580	*
1581	* @note No locking!
1582	*/
1583	int GuestSession::i_dispatchToThis(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
1584	{
1585	AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
1586	AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
1587
1588	LogFlowThisFunc(("sessionID=%RU32, CID=%RU32, uMessage=%RU32, pSvcCb=%p\n",
1589	mData.mSession.mID, pCbCtx->uContextID, pCbCtx->uMessage, pSvcCbData));
1590	int vrc;
1591	switch (pCbCtx->uMessage)
1592	{
1593	case GUEST_MSG_DISCONNECTED:
1594	/** @todo Handle closing all guest objects. */
1595	vrc = VERR_INTERNAL_ERROR;
1596	break;
1597
1598	#ifdef VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS
1599	case GUEST_MSG_FS_NOTIFY:
1600	vrc = i_onFsNotify(pCbCtx, pSvcCbData);
1601	break;
1602	#endif
1603	case GUEST_MSG_SESSION_NOTIFY: /* Guest Additions >= 4.3.0. */
1604	vrc = i_onSessionStatusChange(pCbCtx, pSvcCbData);
1605	break;
1606
1607	default:
1608	vrc = dispatchGeneric(pCbCtx, pSvcCbData);
1609	break;
1610	}
1611
1612	LogFlowFuncLeaveRC(vrc);
1613	return vrc;
1614	}
1615
1616	/**
1617	* Validates and extracts file copy flags from a comma-separated string.
1618	*
1619	* @return COM status, error set on failure
1620	* @param strFlags String to extract flags from.
1621	* @param fStrict Whether to set an error when an unknown / invalid flag is detected.
1622	* @param pfFlags Where to store the extracted (and validated) flags.
1623	*/
1624	HRESULT GuestSession::i_fileCopyFlagFromStr(const com::Utf8Str &strFlags, bool fStrict, FileCopyFlag_T *pfFlags)
1625	{
1626	unsigned fFlags = (unsigned)FileCopyFlag_None;
1627
1628	/* Validate and set flags. */
1629	if (strFlags.isNotEmpty())
1630	{
1631	const char *pszNext = strFlags.c_str();
1632	for (;;)
1633	{
1634	/* Find the next keyword, ignoring all whitespace. */
1635	pszNext = RTStrStripL(pszNext);
1636
1637	const char * const pszComma = strchr(pszNext, ',');
1638	size_t cchKeyword = pszComma ? pszComma - pszNext : strlen(pszNext);
1639	while (cchKeyword > 0 && RT_C_IS_SPACE(pszNext[cchKeyword - 1]))
1640	cchKeyword--;
1641
1642	if (cchKeyword > 0)
1643	{
1644	/* Convert keyword to flag. */
1645	#define MATCH_KEYWORD(a_szKeyword) ( cchKeyword == sizeof(a_szKeyword) - 1U \
1646	&& memcmp(pszNext, a_szKeyword, sizeof(a_szKeyword) - 1U) == 0)
1647	if (MATCH_KEYWORD("NoReplace"))
1648	fFlags \|= (unsigned)FileCopyFlag_NoReplace;
1649	else if (MATCH_KEYWORD("FollowLinks"))
1650	fFlags \|= (unsigned)FileCopyFlag_FollowLinks;
1651	else if (MATCH_KEYWORD("Update"))
1652	fFlags \|= (unsigned)FileCopyFlag_Update;
1653	else if (fStrict)
1654	return setError(E_INVALIDARG, tr("Invalid file copy flag: %.*s"), (int)cchKeyword, pszNext);
1655	#undef MATCH_KEYWORD
1656	}
1657	if (!pszComma)
1658	break;
1659	pszNext = pszComma + 1;
1660	}
1661	}
1662
1663	if (pfFlags)
1664	*pfFlags = (FileCopyFlag_T)fFlags;
1665	return S_OK;
1666	}
1667
1668	/**
1669	* Checks if a file object exists and optionally returns its object.
1670	*
1671	* @returns \c true if file object exists, or \c false if not.
1672	* @param uFileID ID of file object to check.
1673	* @param pFile Where to return the found file object on success.
1674	*/
1675	inline bool GuestSession::i_fileExists(uint32_t uFileID, ComObjPtr<GuestFile> *pFile)
1676	{
1677	SessionFiles::const_iterator it = mData.mFiles.find(uFileID);
1678	if (it != mData.mFiles.end())
1679	{
1680	if (pFile)
1681	*pFile = it->second;
1682	return true;
1683	}
1684	return false;
1685	}
1686
1687	/**
1688	* Unregisters a file object from a guest session.
1689	*
1690	* @returns VBox status code. VERR_NOT_FOUND if the file is not registered (anymore).
1691	* @param pFile File object to unregister from session.
1692	*
1693	* @note Takes the write lock.
1694	*/
1695	int GuestSession::i_fileUnregister(GuestFile *pFile)
1696	{
1697	AssertPtrReturn(pFile, VERR_INVALID_POINTER);
1698
1699	LogFlowThisFunc(("pFile=%p\n", pFile));
1700
1701	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1702
1703	const uint32_t idObject = pFile->getObjectID();
1704
1705	LogFlowFunc(("Removing file (objectID=%RU32) ...\n", idObject));
1706
1707	int vrc = i_objectUnregister(idObject);
1708	if (RT_FAILURE(vrc))
1709	return vrc;
1710
1711	SessionFiles::iterator itFiles = mData.mFiles.find(idObject);
1712	AssertReturn(itFiles != mData.mFiles.end(), VERR_NOT_FOUND);
1713
1714	/* Make sure to consume the pointer before the one of the iterator gets released. */
1715	ComObjPtr<GuestFile> pFileConsumed = pFile;
1716
1717	LogFlowFunc(("Removing file ID=%RU32 (session %RU32, now total %zu files)\n",
1718	pFileConsumed->getObjectID(), mData.mSession.mID, mData.mFiles.size()));
1719
1720	vrc = pFileConsumed->i_onUnregister();
1721	AssertRCReturn(vrc, vrc);
1722
1723	mData.mFiles.erase(itFiles);
1724
1725	alock.release(); /* Release lock before firing off event. */
1726
1727	::FireGuestFileRegisteredEvent(mEventSource, this, pFileConsumed, false /* Unregistered */);
1728
1729	pFileConsumed.setNull();
1730
1731	LogFlowFuncLeaveRC(vrc);
1732	return vrc;
1733	}
1734
1735	/**
1736	* Removes a file from the guest (legacy version).
1737	*
1738	* @returns VBox status code.
1739	* @returns VERR_GSTCTL_GUEST_ERROR on received guest error.
1740	* @param strPath Path of file on guest to remove.
1741	* @param pvrcGuest Where to return the guest error when
1742	* VERR_GSTCTL_GUEST_ERROR was returned. Optional.
1743	*/
1744	int GuestSession::i_fileRemoveViaToolbox(const Utf8Str &strPath, int *pvrcGuest)
1745	{
1746	GuestProcessStartupInfo procInfo;
1747	GuestToolboxStream streamOut;
1748
1749	procInfo.mFlags = ProcessCreateFlag_WaitForStdOut;
1750	procInfo.mExecutable = Utf8Str(VBOXSERVICE_TOOL_RM);
1751
1752	try
1753	{
1754	procInfo.mArguments.push_back(procInfo.mExecutable); /* Set argv0. */
1755	procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
1756	procInfo.mArguments.push_back("--"); /* strPath could be '--help', which is a valid filename. */
1757	procInfo.mArguments.push_back(strPath); /* The file we want to remove. */
1758	}
1759	catch (std::bad_alloc &)
1760	{
1761	return VERR_NO_MEMORY;
1762	}
1763
1764	GuestCtrlStreamObjects stdOut;
1765	int vrcGuest;
1766	int vrc = GuestProcessToolbox::runTool(this, procInfo, &vrcGuest, &stdOut);
1767	if (!GuestProcess::i_isGuestError(vrc))
1768	{
1769	if (!stdOut.empty())
1770	{
1771	GuestFsObjData objData;
1772	vrc = objData.FromToolboxRm(stdOut.at(0));
1773	if (RT_FAILURE(vrc))
1774	{
1775	vrcGuest = vrc;
1776	if (pvrcGuest)
1777	*pvrcGuest = vrcGuest;
1778	vrc = VERR_GSTCTL_GUEST_ERROR;
1779	}
1780	}
1781	else
1782	vrc = VERR_BROKEN_PIPE;
1783	}
1784	else if (pvrcGuest)
1785	*pvrcGuest = vrcGuest;
1786
1787	return vrc;
1788	}
1789
1790	/**
1791	* Removes a file from the guest.
1792	*
1793	* @returns VBox status code.
1794	* @returns VERR_GSTCTL_GUEST_ERROR on received guest error.
1795	* @param strPath Path of file on guest to remove.
1796	* @param pvrcGuest Where to return the guest error when
1797	* VERR_GSTCTL_GUEST_ERROR was returned. Optional.
1798	*/
1799	int GuestSession::i_fileRemove(const Utf8Str &strPath, int *pvrcGuest)
1800	{
1801	LogFlowThisFunc(("strPath=%s\n", strPath.c_str()));
1802
1803	int vrc;
1804	#ifdef VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS
1805	if (mParent->i_getGuestControlFeatures0() & VBOX_GUESTCTRL_GF_0_TOOLBOX_AS_CMDS)
1806	{
1807	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1808
1809	GuestWaitEvent *pEvent = NULL;
1810	vrc = registerWaitEvent(mData.mSession.mID, mData.mObjectID, &pEvent);
1811	if (RT_FAILURE(vrc))
1812	return vrc;
1813
1814	/* Prepare HGCM call. */
1815	VBOXHGCMSVCPARM paParms[4];
1816	int i = 0;
1817	HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
1818	HGCMSvcSetPv (&paParms[i++], (void*)strPath.c_str(), (ULONG)strPath.length() + 1);
1819
1820	alock.release(); /* Drop lock before sending. */
1821
1822	vrc = i_sendMessage(HOST_MSG_FILE_REMOVE, i, paParms);
1823	if (RT_SUCCESS(vrc))
1824	{
1825	vrc = pEvent->Wait(30 * 1000);
1826	if (RT_SUCCESS(vrc))
1827	{
1828	// Nothing to do here.
1829	}
1830	else if (pEvent->HasGuestError() && pvrcGuest)
1831	*pvrcGuest = pEvent->GuestResult();
1832	}
1833	}
1834	else
1835	#endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */
1836	{
1837	vrc = i_fileRemoveViaToolbox(strPath, pvrcGuest);
1838	}
1839
1840	LogFlowThisFunc(("Returning vrc=%Rrc, vrcGuest=%Rrc\n", vrc, pvrcGuest ? *pvrcGuest : VERR_IPE_UNINITIALIZED_STATUS));
1841	return vrc;
1842	}
1843
1844	/**
1845	* Opens a file on the guest.
1846	*
1847	* @returns VBox status code.
1848	* @returns VERR_GSTCTL_GUEST_ERROR on received guest error.
1849	* @param aPath File path on guest to open.
1850	* @param aAccessMode Access mode to use.
1851	* @param aOpenAction Open action to use.
1852	* @param aSharingMode Sharing mode to use.
1853	* @param aCreationMode Creation mode to use.
1854	* @param aFlags Open flags to use.
1855	* @param pFile Where to return the file object on success.
1856	* @param pvrcGuest Where to return the guest error when
1857	* VERR_GSTCTL_GUEST_ERROR was returned. Optional.
1858	*
1859	* @note Takes the write lock.
1860	*/
1861	int GuestSession::i_fileOpenEx(const com::Utf8Str &aPath, FileAccessMode_T aAccessMode, FileOpenAction_T aOpenAction,
1862	FileSharingMode_T aSharingMode, ULONG aCreationMode, const std::vector<FileOpenExFlag_T> &aFlags,
1863	ComObjPtr<GuestFile> &pFile, int *pvrcGuest)
1864	{
1865	GuestFileOpenInfo openInfo;
1866	openInfo.mFilename = aPath;
1867	openInfo.mCreationMode = aCreationMode;
1868	openInfo.mAccessMode = aAccessMode;
1869	openInfo.mOpenAction = aOpenAction;
1870	openInfo.mSharingMode = aSharingMode;
1871
1872	/* Combine and validate flags. */
1873	for (size_t i = 0; i < aFlags.size(); i++)
1874	openInfo.mfOpenEx \|= aFlags[i];
1875	/* Validation is done in i_fileOpen(). */
1876
1877	return i_fileOpen(openInfo, pFile, pvrcGuest);
1878	}
1879
1880	/**
1881	* Opens a file on the guest.
1882	*
1883	* @returns VBox status code.
1884	* @returns VERR_GSTCTL_GUEST_ERROR on received guest error.
1885	* @param openInfo Open information to use for opening the file.
1886	* @param pFile Where to return the file object on success.
1887	* @param pvrcGuest Where to return the guest error when
1888	* VERR_GSTCTL_GUEST_ERROR was returned. Optional.
1889	*
1890	* @note Takes the write lock.
1891	*/
1892	int GuestSession::i_fileOpen(const GuestFileOpenInfo &openInfo, ComObjPtr<GuestFile> &pFile, int *pvrcGuest)
1893	{
1894	LogFlowThisFunc(("strFile=%s, enmAccessMode=0x%x, enmOpenAction=0x%x, uCreationMode=%RU32, mfOpenEx=%RU32\n",
1895	openInfo.mFilename.c_str(), openInfo.mAccessMode, openInfo.mOpenAction, openInfo.mCreationMode,
1896	openInfo.mfOpenEx));
1897
1898	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1899
1900	/* Guest Additions < 4.3 don't support handling guest files, skip. */
1901	if (mData.mProtocolVersion < 2)
1902	{
1903	if (pvrcGuest)
1904	*pvrcGuest = VERR_NOT_SUPPORTED;
1905	return VERR_GSTCTL_GUEST_ERROR;
1906	}
1907
1908	if (!openInfo.IsValid())
1909	return VERR_INVALID_PARAMETER;
1910
1911	/* Create the directory object. */
1912	HRESULT hrc = pFile.createObject();
1913	if (FAILED(hrc))
1914	return VERR_COM_UNEXPECTED;
1915
1916	/* Register a new object ID. */
1917	uint32_t idObject;
1918	int vrc = i_objectRegister(pFile, SESSIONOBJECTTYPE_FILE, &idObject);
1919	if (RT_FAILURE(vrc))
1920	{
1921	pFile.setNull();
1922	return vrc;
1923	}
1924
1925	Console *pConsole = mParent->i_getConsole();
1926	AssertPtr(pConsole);
1927
1928	vrc = pFile->init(pConsole, this /* GuestSession */, idObject, openInfo);
1929	if (RT_FAILURE(vrc))
1930	return vrc;
1931
1932	/*
1933	* Since this is a synchronous guest call we have to
1934	* register the file object first, releasing the session's
1935	* lock and then proceed with the actual opening command
1936	* -- otherwise the file's opening callback would hang
1937	* because the session's lock still is in place.
1938	*/
1939	try
1940	{
1941	/* Add the created file to our vector. */
1942	mData.mFiles[idObject] = pFile;
1943
1944	LogFlowFunc(("Added new guest file \"%s\" (Session: %RU32) (now total %zu files)\n",
1945	openInfo.mFilename.c_str(), mData.mSession.mID, mData.mFiles.size()));
1946
1947	alock.release(); /* Release lock before firing off event. */
1948
1949	::FireGuestFileRegisteredEvent(mEventSource, this, pFile, true /* Registered */);
1950	}
1951	catch (std::bad_alloc &)
1952	{
1953	vrc = VERR_NO_MEMORY;
1954	}
1955
1956	if (RT_SUCCESS(vrc))
1957	{
1958	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
1959	vrc = pFile->i_openFile(30 * 1000 /* 30s timeout */, &vrcGuest);
1960	if ( vrc == VERR_GSTCTL_GUEST_ERROR
1961	&& pvrcGuest)
1962	*pvrcGuest = vrcGuest;
1963	}
1964
1965	LogFlowFuncLeaveRC(vrc);
1966	return vrc;
1967	}
1968
1969	/**
1970	* Queries information from a file on the guest.
1971	*
1972	* @returns IPRT status code. VERR_NOT_A_FILE if the queried file system object on the guest is not a file,
1973	* or VERR_GSTCTL_GUEST_ERROR if pvrcGuest contains
1974	* more error information from the guest.
1975	* @param strPath Absolute path of file to query information for.
1976	* @param fFollowSymlinks Whether or not to follow symbolic links on the guest.
1977	* @param objData Where to store the acquired information.
1978	* @param pvrcGuest Where to store the guest VBox status code.
1979	* Optional.
1980	*/
1981	int GuestSession::i_fileQueryInfo(const Utf8Str &strPath, bool fFollowSymlinks, GuestFsObjData &objData, int *pvrcGuest)
1982	{
1983	LogFlowThisFunc(("strPath=%s fFollowSymlinks=%RTbool\n", strPath.c_str(), fFollowSymlinks));
1984
1985	int vrc = i_fsObjQueryInfo(strPath, fFollowSymlinks, objData, pvrcGuest);
1986	if (RT_SUCCESS(vrc))
1987	vrc = objData.mType == FsObjType_File ? VINF_SUCCESS : VERR_NOT_A_FILE;
1988
1989	LogFlowFuncLeaveRC(vrc);
1990	return vrc;
1991	}
1992
1993	/**
1994	* Queries the size of a file on the guest.
1995	*
1996	* @returns VBox status code.
1997	* @returns VERR_GSTCTL_GUEST_ERROR on received guest error.
1998	* @retval VERR_
1999	* @param strPath Path of file on guest to query size for.
2000	* @param fFollowSymlinks \c true when wanting to follow symbolic links, \c false if not.
2001	* @param pllSize Where to return the queried file size on success.
2002	* @param pvrcGuest Where to return the guest error when
2003	* VERR_GSTCTL_GUEST_ERROR was returned. Optional.
2004	*/
2005	int GuestSession::i_fileQuerySize(const Utf8Str &strPath, bool fFollowSymlinks, int64_t pllSize, int pvrcGuest)
2006	{
2007	AssertPtrReturn(pllSize, VERR_INVALID_POINTER);
2008
2009	GuestFsObjData objData;
2010	int vrc = i_fileQueryInfo(strPath, fFollowSymlinks, objData, pvrcGuest);
2011	if (RT_SUCCESS(vrc))
2012	*pllSize = objData.mObjectSize;
2013
2014	return vrc;
2015	}
2016
2017	/**
2018	* Queries information of a file system object (file, directory, ...). Legacy version.
2019	*
2020	* @return IPRT status code.
2021	* @param strPath Path to file system object to query information for.
2022	* @param fFollowSymlinks Whether to follow symbolic links or not.
2023	* @param objData Where to return the file system object data, if found.
2024	* @param pvrcGuest Guest VBox status code, when returning
2025	* VERR_GSTCTL_GUEST_ERROR. Any other return code
2026	* indicates some host side error.
2027	*/
2028	int GuestSession::i_fsObjQueryInfoViaToolbox(const Utf8Str &strPath, bool fFollowSymlinks, GuestFsObjData &objData, int *pvrcGuest)
2029	{
2030	/** @todo Merge this with IGuestFile::queryInfo(). */
2031	GuestProcessStartupInfo procInfo;
2032	procInfo.mFlags = ProcessCreateFlag_WaitForStdOut;
2033	try
2034	{
2035	procInfo.mExecutable = VBOXSERVICE_TOOL_STAT;
2036	procInfo.mArguments.push_back(procInfo.mExecutable); /* Set argv0. */
2037	procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
2038	if (fFollowSymlinks)
2039	procInfo.mArguments.push_back(Utf8Str("-L"));
2040	procInfo.mArguments.push_back("--"); /* strPath could be '--help', which is a valid filename. */
2041	procInfo.mArguments.push_back(strPath);
2042	}
2043	catch (std::bad_alloc &)
2044	{
2045	Log(("Out of memory!\n"));
2046	return VERR_NO_MEMORY;
2047	}
2048
2049	GuestCtrlStreamObjects stdOut;
2050	int vrcGuest;
2051	int vrc = GuestProcessToolbox::runTool(this, procInfo, &vrcGuest, &stdOut);
2052	if (!GuestProcess::i_isGuestError(vrc))
2053	{
2054	if (!stdOut.empty())
2055	{
2056	vrc = objData.FromToolboxStat(stdOut.at(0));
2057	if (RT_FAILURE(vrc))
2058	{
2059	vrcGuest = vrc;
2060	if (pvrcGuest)
2061	*pvrcGuest = vrcGuest;
2062	vrc = VERR_GSTCTL_GUEST_ERROR;
2063	}
2064	}
2065	else
2066	vrc = VERR_BROKEN_PIPE;
2067	}
2068	else if (pvrcGuest)
2069	*pvrcGuest = vrcGuest;
2070
2071	return vrc;
2072	}
2073
2074	/**
2075	* Queries information of a guest file system.
2076	*
2077	* @return IPRT status code.
2078	* @param strPath Path to file system object to query information for.
2079	* @param pFsInfo Where to return the file system information on success.
2080	* @param pvrcGuest Guest VBox status code, when returning
2081	* VERR_GSTCTL_GUEST_ERROR. Any other return code
2082	* indicates some host side error.
2083	*/
2084	int GuestSession::i_fsQueryInfo(const Utf8Str &strPath, PGSTCTLFSINFO pFsInfo, int *pvrcGuest)
2085	{
2086	LogFlowThisFunc(("strPath=%s\n", strPath.c_str()));
2087
2088	int vrc;
2089	#ifdef VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS
2090	if (mParent->i_getGuestControlFeatures0() & VBOX_GUESTCTRL_GF_0_TOOLBOX_AS_CMDS)
2091	{
2092	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2093
2094	GuestWaitEvent *pEvent = NULL;
2095	vrc = registerWaitEvent(mData.mSession.mID, mData.mObjectID, &pEvent);
2096	if (RT_FAILURE(vrc))
2097	return vrc;
2098
2099	/* Prepare HGCM call. */
2100	VBOXHGCMSVCPARM paParms[2];
2101	int i = 0;
2102	HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
2103	HGCMSvcSetStr(&paParms[i++], strPath.c_str());
2104
2105	alock.release(); /* Drop lock before sending. */
2106
2107	vrc = i_sendMessage(HOST_MSG_FS_QUERY_INFO, i, paParms);
2108	if (RT_SUCCESS(vrc))
2109	{
2110	vrc = pEvent->Wait(30 * 1000);
2111	if (RT_SUCCESS(vrc))
2112	{
2113	PCALLBACKDATA_FS_NOTIFY const pFsNotify = (PCALLBACKDATA_FS_NOTIFY)pEvent->Payload().Raw();
2114	AssertPtrReturn(pFsNotify, VERR_INVALID_POINTER);
2115	int vrcGuest = (int)pFsNotify->rc;
2116	if (RT_SUCCESS(vrcGuest))
2117	{
2118	AssertReturn(pFsNotify->uType == GUEST_FS_NOTIFYTYPE_QUERY_INFO, VERR_INVALID_PARAMETER);
2119	memcpy(pFsInfo, &pFsNotify->u.QueryInfo.fsInfo, sizeof(GSTCTLFSINFO));
2120	}
2121	else
2122	{
2123	if (pvrcGuest)
2124	*pvrcGuest = vrcGuest;
2125	vrc = VERR_GSTCTL_GUEST_ERROR;
2126	}
2127	}
2128	else
2129	{
2130	if (pEvent->HasGuestError() && pvrcGuest)
2131	*pvrcGuest = pEvent->GuestResult();
2132	}
2133	}
2134	unregisterWaitEvent(pEvent);
2135	}
2136	else
2137	#endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */
2138	{
2139	vrc = VERR_NOT_SUPPORTED;
2140	}
2141
2142	LogFlowThisFunc(("Returning vrc=%Rrc, vrcGuest=%Rrc\n", vrc, pvrcGuest ? *pvrcGuest : VERR_IPE_UNINITIALIZED_STATUS));
2143	return vrc;
2144	}
2145
2146	/**
2147	* Queries information of a file system object (file, directory, ...).
2148	*
2149	* @return IPRT status code.
2150	* @param strPath Path to file system object to query information for.
2151	* @param fFollowSymlinks Whether to follow symbolic links or not.
2152	* @param objData Where to return the file system object data, if found.
2153	* @param pvrcGuest Guest VBox status code, when returning
2154	* VERR_GSTCTL_GUEST_ERROR. Any other return code
2155	* indicates some host side error.
2156	*/
2157	int GuestSession::i_fsObjQueryInfo(const Utf8Str &strPath, bool fFollowSymlinks, GuestFsObjData &objData, int *pvrcGuest)
2158	{
2159	LogFlowThisFunc(("strPath=%s\n", strPath.c_str()));
2160
2161	int vrc;
2162	#ifdef VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS
2163	if (mParent->i_getGuestControlFeatures0() & VBOX_GUESTCTRL_GF_0_TOOLBOX_AS_CMDS)
2164	{
2165	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2166
2167	GuestWaitEvent *pEvent = NULL;
2168	vrc = registerWaitEvent(mData.mSession.mID, mData.mObjectID, &pEvent);
2169	if (RT_FAILURE(vrc))
2170	return vrc;
2171
2172	uint32_t const fFlags = fFollowSymlinks ? GSTCTL_PATH_F_FOLLOW_LINK : GSTCTL_PATH_F_ON_LINK;
2173
2174	/* Prepare HGCM call. */
2175	VBOXHGCMSVCPARM paParms[4];
2176	int i = 0;
2177	HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
2178	HGCMSvcSetStr(&paParms[i++], strPath.c_str());
2179	HGCMSvcSetU32(&paParms[i++], GSTCTLFSOBJATTRADD_UNIX /* Implicit */);
2180	HGCMSvcSetU32(&paParms[i++], fFlags);
2181
2182	alock.release(); /* Drop lock before sending. */
2183
2184	vrc = i_sendMessage(HOST_MSG_FS_OBJ_QUERY_INFO, i, paParms);
2185	if (RT_SUCCESS(vrc))
2186	{
2187	vrc = pEvent->Wait(30 * 1000);
2188	if (RT_SUCCESS(vrc))
2189	{
2190	PCALLBACKDATA_FS_NOTIFY const pFsNotify = (PCALLBACKDATA_FS_NOTIFY)pEvent->Payload().Raw();
2191	AssertPtrReturn(pFsNotify, VERR_INVALID_POINTER);
2192	int vrcGuest = (int)pFsNotify->rc;
2193	if (RT_SUCCESS(vrcGuest))
2194	{
2195	AssertReturn(pFsNotify->uType == GUEST_FS_NOTIFYTYPE_QUERY_OBJ_INFO, VERR_INVALID_PARAMETER);
2196	objData.Init(strPath);
2197	vrc = objData.FromGuestFsObjInfo(&pFsNotify->u.QueryObjInfo.objInfo);
2198	RTStrFree(pFsNotify->u.QueryObjInfo.pszUser);
2199	RTStrFree(pFsNotify->u.QueryObjInfo.pszGroups);
2200	}
2201	else
2202	{
2203	if (pvrcGuest)
2204	*pvrcGuest = vrcGuest;
2205	vrc = VERR_GSTCTL_GUEST_ERROR;
2206	}
2207	}
2208	else
2209	{
2210	if (pEvent->HasGuestError() && pvrcGuest)
2211	*pvrcGuest = pEvent->GuestResult();
2212	}
2213	}
2214	unregisterWaitEvent(pEvent);
2215	}
2216	else
2217	#endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */
2218	{
2219	vrc = i_fsObjQueryInfoViaToolbox(strPath, fFollowSymlinks, objData, pvrcGuest);
2220	}
2221
2222	LogFlowThisFunc(("Returning vrc=%Rrc, vrcGuest=%Rrc\n", vrc, pvrcGuest ? *pvrcGuest : VERR_IPE_UNINITIALIZED_STATUS));
2223	return vrc;
2224	}
2225
2226	/**
2227	* Returns the guest credentials of a guest session.
2228	*
2229	* @returns Guest credentials.
2230	*/
2231	const GuestCredentials& GuestSession::i_getCredentials(void)
2232	{
2233	return mData.mCredentials;
2234	}
2235
2236	/**
2237	* Returns the guest session (friendly) name.
2238	*
2239	* @returns Guest session name.
2240	*/
2241	Utf8Str GuestSession::i_getName(void)
2242	{
2243	return mData.mSession.mName;
2244	}
2245
2246	/**
2247	* Returns a stringified error description for a given guest result code.
2248	*
2249	* @returns Stringified error description.
2250	*/
2251	/* static */
2252	Utf8Str GuestSession::i_guestErrorToString(int vrcGuest)
2253	{
2254	Utf8Str strError;
2255
2256	/** @todo pData->u32Flags: int vs. uint32 -- IPRT errors are negative !!! */
2257	switch (vrcGuest)
2258	{
2259	case VERR_INVALID_VM_HANDLE:
2260	strError.printf(tr("VMM device is not available (is the VM running?)"));
2261	break;
2262
2263	case VERR_HGCM_SERVICE_NOT_FOUND:
2264	strError.printf(tr("The guest execution service is not available"));
2265	break;
2266
2267	case VERR_ACCOUNT_RESTRICTED:
2268	strError.printf(tr("The specified user account on the guest is restricted and can't be used to logon"));
2269	break;
2270
2271	case VERR_AUTHENTICATION_FAILURE:
2272	strError.printf(tr("The specified user was not able to logon on guest"));
2273	break;
2274
2275	case VERR_TIMEOUT:
2276	strError.printf(tr("The guest did not respond within time"));
2277	break;
2278
2279	case VERR_CANCELLED:
2280	strError.printf(tr("The session operation was canceled"));
2281	break;
2282
2283	case VERR_GSTCTL_MAX_CID_OBJECTS_REACHED:
2284	strError.printf(tr("Maximum number of concurrent guest processes has been reached"));
2285	break;
2286
2287	case VERR_NOT_FOUND:
2288	strError.printf(tr("The guest execution service is not ready (yet)"));
2289	break;
2290
2291	default:
2292	strError.printf("%Rrc", vrcGuest);
2293	break;
2294	}
2295
2296	return strError;
2297	}
2298
2299	/**
2300	* Returns whether the session is in a started state or not.
2301	*
2302	* @returns \c true if in a started state, or \c false if not.
2303	*/
2304	bool GuestSession::i_isStarted(void) const
2305	{
2306	return (mData.mStatus == GuestSessionStatus_Started);
2307	}
2308
2309	/**
2310	* Checks if this session is ready state where it can handle
2311	* all session-bound actions (like guest processes, guest files).
2312	* Only used by official API methods. Will set an external
2313	* error when not ready.
2314	*/
2315	HRESULT GuestSession::i_isStartedExternal(void)
2316	{
2317	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2318
2319	/** @todo Be a bit more informative. */
2320	if (!i_isStarted())
2321	return setError(E_UNEXPECTED, tr("Session is not in started state"));
2322
2323	return S_OK;
2324	}
2325
2326	/**
2327	* Returns whether a guest session status implies a terminated state or not.
2328	*
2329	* @returns \c true if it's a terminated state, or \c false if not.
2330	*/
2331	/* static */
2332	bool GuestSession::i_isTerminated(GuestSessionStatus_T enmStatus)
2333	{
2334	switch (enmStatus)
2335	{
2336	case GuestSessionStatus_Terminated:
2337	RT_FALL_THROUGH();
2338	case GuestSessionStatus_TimedOutKilled:
2339	RT_FALL_THROUGH();
2340	case GuestSessionStatus_TimedOutAbnormally:
2341	RT_FALL_THROUGH();
2342	case GuestSessionStatus_Down:
2343	RT_FALL_THROUGH();
2344	case GuestSessionStatus_Error:
2345	return true;
2346
2347	default:
2348	break;
2349	}
2350
2351	return false;
2352	}
2353
2354	/**
2355	* Returns whether the session is in a terminated state or not.
2356	*
2357	* @returns \c true if in a terminated state, or \c false if not.
2358	*/
2359	bool GuestSession::i_isTerminated(void) const
2360	{
2361	return GuestSession::i_isTerminated(mData.mStatus);
2362	}
2363
2364	/**
2365	* Called by IGuest right before this session gets removed from
2366	* the public session list.
2367	*
2368	* @note Takes the write lock.
2369	*/
2370	int GuestSession::i_onRemove(void)
2371	{
2372	LogFlowThisFuncEnter();
2373
2374	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2375
2376	int vrc = i_objectsUnregister();
2377
2378	/*
2379	* Note: The event source stuff holds references to this object,
2380	* so make sure that this is cleaned up before calling uninit.
2381	*/
2382	if (!mEventSource.isNull())
2383	{
2384	mEventSource->UnregisterListener(mLocalListener);
2385
2386	mLocalListener.setNull();
2387	unconst(mEventSource).setNull();
2388	}
2389
2390	LogFlowFuncLeaveRC(vrc);
2391	return vrc;
2392	}
2393
2394	#ifdef VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS
2395	/**
2396	* Handles guest file system notifications.
2397	*
2398	* @returns VBox status code.
2399	* @param pCbCtx Host callback context from HGCM service.
2400	* @param pSvcCbData HGCM service callback data.
2401	*/
2402	int GuestSession::i_onFsNotify(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
2403	{
2404	AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
2405	AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
2406
2407	if (pSvcCbData->mParms < 4)
2408	return VERR_INVALID_PARAMETER;
2409
2410	CALLBACKDATA_FS_NOTIFY dataCb;
2411	RT_ZERO(dataCb);
2412	/* pSvcCb->mpaParms[0] always contains the context ID. */
2413	int vrc = HGCMSvcGetU32(&pSvcCbData->mpaParms[1], &dataCb.uType);
2414	AssertRCReturn(vrc, vrc);
2415	vrc = HGCMSvcGetU32(&pSvcCbData->mpaParms[2], &dataCb.rc);
2416	AssertRCReturn(vrc, vrc);
2417
2418	int const vrcGuest = (int)dataCb.rc;
2419
2420	if (RT_SUCCESS(vrcGuest))
2421	{
2422	switch (dataCb.uType)
2423	{
2424	case GUEST_FS_NOTIFYTYPE_CREATE_TEMP:
2425	{
2426	char *pszPath;
2427	uint32_t cbPath;
2428	vrc = HGCMSvcGetStr(&pSvcCbData->mpaParms[3], &pszPath, &cbPath);
2429	AssertRCBreak(vrc);
2430	dataCb.u.CreateTemp.pszPath = RTStrDup(pszPath);
2431	AssertPtrBreakStmt(dataCb.u.CreateTemp.pszPath, vrc = VERR_NO_MEMORY);
2432	dataCb.u.CreateTemp.cbPath = cbPath;
2433	break;
2434	}
2435
2436	case GUEST_FS_NOTIFYTYPE_QUERY_OBJ_INFO:
2437	{
2438	AssertBreakStmt(pSvcCbData->mParms >= 6, vrc = VERR_INVALID_PARAMETER);
2439	PGSTCTLFSOBJINFO pObjInfo;
2440	uint32_t cbObjInfo;
2441	vrc = HGCMSvcGetPv(&pSvcCbData->mpaParms[3], (void **)&pObjInfo, &cbObjInfo);
2442	AssertRCBreak(vrc);
2443	AssertBreakStmt(cbObjInfo == sizeof(GSTCTLFSOBJINFO), vrc = VERR_INVALID_PARAMETER);
2444	memcpy(&dataCb.u.QueryObjInfo.objInfo, pObjInfo, sizeof(GSTCTLFSOBJINFO));
2445
2446	char *pszUser;
2447	uint32_t cbUser;
2448	vrc = HGCMSvcGetStr(&pSvcCbData->mpaParms[4], &pszUser, &cbUser);
2449	AssertRCBreak(vrc);
2450	dataCb.u.QueryObjInfo.pszUser = RTStrDup(pszUser);
2451	AssertPtrBreakStmt(dataCb.u.QueryObjInfo.pszUser, vrc = VERR_NO_MEMORY);
2452	dataCb.u.QueryObjInfo.cbUser = cbUser;
2453
2454	char *pszGroups;
2455	uint32_t cbGroups;
2456	vrc = HGCMSvcGetStr(&pSvcCbData->mpaParms[5], &pszGroups, &cbGroups);
2457	AssertRCBreak(vrc);
2458	dataCb.u.QueryObjInfo.pszGroups = RTStrDup(pszGroups);
2459	AssertPtrBreakStmt(dataCb.u.QueryObjInfo.pszGroups, vrc = VERR_NO_MEMORY);
2460	dataCb.u.QueryObjInfo.cbGroups = cbGroups;
2461	break;
2462	}
2463
2464	case GUEST_FS_NOTIFYTYPE_QUERY_INFO:
2465	{
2466	AssertBreakStmt(pSvcCbData->mParms >= 2, vrc = VERR_INVALID_PARAMETER);
2467	PGSTCTLFSINFO pFsInfo;
2468	uint32_t cbFsInfo;
2469	vrc = HGCMSvcGetPv(&pSvcCbData->mpaParms[3], (void **)&pFsInfo, &cbFsInfo);
2470	AssertRCBreak(vrc);
2471	AssertBreakStmt(cbFsInfo == sizeof(GSTCTLFSINFO), vrc = VERR_INVALID_PARAMETER);
2472	memcpy(&dataCb.u.QueryInfo.fsInfo, pFsInfo, sizeof(GSTCTLFSINFO));
2473	break;
2474	}
2475
2476	case GUEST_FS_NOTIFYTYPE_UNKNOWN:
2477	RT_FALL_THROUGH();
2478	default:
2479	vrc = VERR_NOT_SUPPORTED;
2480	break;
2481	}
2482	}
2483
2484	try
2485	{
2486	GuestWaitEventPayload evPayload(dataCb.uType, &dataCb, sizeof(dataCb));
2487	vrc = signalWaitEventInternal(pCbCtx, dataCb.rc, &evPayload);
2488	}
2489	catch (int vrcEx) /* Thrown by GuestWaitEventPayload constructor. */
2490	{
2491	vrc = vrcEx;
2492	}
2493
2494	return vrc;
2495	}
2496	#endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */
2497
2498	/**
2499	* Handles guest session status changes from the guest.
2500	*
2501	* @returns VBox status code.
2502	* @param pCbCtx Host callback context from HGCM service.
2503	* @param pSvcCbData HGCM service callback data.
2504	*
2505	* @note Takes the read lock (for session ID lookup).
2506	*/
2507	int GuestSession::i_onSessionStatusChange(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
2508	{
2509	AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
2510	AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
2511
2512	if (pSvcCbData->mParms < 3)
2513	return VERR_INVALID_PARAMETER;
2514
2515	CALLBACKDATA_SESSION_NOTIFY dataCb;
2516	/* pSvcCb->mpaParms[0] always contains the context ID. */
2517	int vrc = HGCMSvcGetU32(&pSvcCbData->mpaParms[1], &dataCb.uType);
2518	AssertRCReturn(vrc, vrc);
2519	vrc = HGCMSvcGetU32(&pSvcCbData->mpaParms[2], &dataCb.uResult);
2520	AssertRCReturn(vrc, vrc);
2521
2522	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2523
2524	LogFlowThisFunc(("ID=%RU32, uType=%RU32, vrcGuest=%Rrc\n", mData.mSession.mID, dataCb.uType, dataCb.uResult));
2525
2526	GuestSessionStatus_T sessionStatus = GuestSessionStatus_Undefined;
2527
2528	int vrcGuest = dataCb.uResult; /** @todo uint32_t vs. int. */
2529	switch (dataCb.uType)
2530	{
2531	case GUEST_SESSION_NOTIFYTYPE_ERROR:
2532	sessionStatus = GuestSessionStatus_Error;
2533	LogRel(("Guest Control: Error starting Session '%s' (%Rrc) \n", mData.mSession.mName.c_str(), vrcGuest));
2534	break;
2535
2536	case GUEST_SESSION_NOTIFYTYPE_STARTED:
2537	sessionStatus = GuestSessionStatus_Started;
2538	#if 0 /** @todo If we get some environment stuff along with this kind notification: */
2539	const char *pszzEnvBlock = ...;
2540	uint32_t cbEnvBlock = ...;
2541	if (!mData.mpBaseEnvironment)
2542	{
2543	GuestEnvironment *pBaseEnv;
2544	try { pBaseEnv = new GuestEnvironment(); } catch (std::bad_alloc &) { pBaseEnv = NULL; }
2545	if (pBaseEnv)
2546	{
2547	int vrc = pBaseEnv->initNormal(Guest.i_isGuestInWindowsNtFamily() ? RTENV_CREATE_F_ALLOW_EQUAL_FIRST_IN_VAR : 0);
2548	if (RT_SUCCESS(vrc))
2549	vrc = pBaseEnv->copyUtf8Block(pszzEnvBlock, cbEnvBlock);
2550	if (RT_SUCCESS(vrc))
2551	mData.mpBaseEnvironment = pBaseEnv;
2552	else
2553	pBaseEnv->release();
2554	}
2555	}
2556	#endif
2557	LogRel(("Guest Control: Session '%s' was successfully started\n", mData.mSession.mName.c_str()));
2558	break;
2559
2560	case GUEST_SESSION_NOTIFYTYPE_TEN:
2561	LogRel(("Guest Control: Session '%s' was terminated normally with exit code %#x\n",
2562	mData.mSession.mName.c_str(), dataCb.uResult));
2563	sessionStatus = GuestSessionStatus_Terminated;
2564	break;
2565
2566	case GUEST_SESSION_NOTIFYTYPE_TEA:
2567	LogRel(("Guest Control: Session '%s' was terminated abnormally\n", mData.mSession.mName.c_str()));
2568	sessionStatus = GuestSessionStatus_Terminated;
2569	/* dataCb.uResult is undefined. */
2570	break;
2571
2572	case GUEST_SESSION_NOTIFYTYPE_TES:
2573	LogRel(("Guest Control: Session '%s' was terminated via signal %#x\n", mData.mSession.mName.c_str(), dataCb.uResult));
2574	sessionStatus = GuestSessionStatus_Terminated;
2575	break;
2576
2577	case GUEST_SESSION_NOTIFYTYPE_TOK:
2578	sessionStatus = GuestSessionStatus_TimedOutKilled;
2579	LogRel(("Guest Control: Session '%s' timed out and was killed\n", mData.mSession.mName.c_str()));
2580	break;
2581
2582	case GUEST_SESSION_NOTIFYTYPE_TOA:
2583	sessionStatus = GuestSessionStatus_TimedOutAbnormally;
2584	LogRel(("Guest Control: Session '%s' timed out and was not killed successfully\n", mData.mSession.mName.c_str()));
2585	break;
2586
2587	case GUEST_SESSION_NOTIFYTYPE_DWN:
2588	sessionStatus = GuestSessionStatus_Down;
2589	LogRel(("Guest Control: Session '%s' got killed as guest service/OS is down\n", mData.mSession.mName.c_str()));
2590	break;
2591
2592	case GUEST_SESSION_NOTIFYTYPE_UNDEFINED:
2593	default:
2594	vrc = VERR_NOT_SUPPORTED;
2595	break;
2596	}
2597
2598	/* Leave the lock, as i_setSessionStatus() below will require a write lock for actually
2599	* committing the session state. */
2600	alock.release();
2601
2602	if (RT_SUCCESS(vrc))
2603	{
2604	if (RT_FAILURE(vrcGuest))
2605	sessionStatus = GuestSessionStatus_Error;
2606	}
2607
2608	/* Set the session status. */
2609	if (RT_SUCCESS(vrc))
2610	vrc = i_setSessionStatus(sessionStatus, vrcGuest);
2611
2612	LogFlowThisFunc(("ID=%RU32, vrcGuest=%Rrc\n", mData.mSession.mID, vrcGuest));
2613
2614	LogFlowFuncLeaveRC(vrc);
2615	return vrc;
2616	}
2617
2618	/**
2619	* Returns the path separation style used on the guest.
2620	*
2621	* @returns Separation style used on the guest.
2622	*/
2623	PathStyle_T GuestSession::i_getGuestPathStyle(void)
2624	{
2625	PathStyle_T enmPathStyle;
2626
2627	VBOXOSTYPE enmOsType = mParent->i_getGuestOSType();
2628	if (enmOsType < VBOXOSTYPE_DOS)
2629	{
2630	LogFlowFunc(("returns PathStyle_Unknown\n"));
2631	enmPathStyle = PathStyle_Unknown;
2632	}
2633	else if (enmOsType < VBOXOSTYPE_Linux)
2634	{
2635	LogFlowFunc(("returns PathStyle_DOS\n"));
2636	enmPathStyle = PathStyle_DOS;
2637	}
2638	else
2639	{
2640	LogFlowFunc(("returns PathStyle_UNIX\n"));
2641	enmPathStyle = PathStyle_UNIX;
2642	}
2643
2644	return enmPathStyle;
2645	}
2646
2647	/**
2648	* Returns the path separation style used on the host.
2649	*
2650	* @returns Separation style used on the host.
2651	*/
2652	/* static */
2653	PathStyle_T GuestSession::i_getHostPathStyle(void)
2654	{
2655	#if RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS
2656	return PathStyle_DOS;
2657	#else
2658	return PathStyle_UNIX;
2659	#endif
2660	}
2661
2662	/**
2663	* Starts the guest session on the guest.
2664	*
2665	* @returns VBox status code.
2666	* @param pvrcGuest Where to return the guest error when
2667	* VERR_GSTCTL_GUEST_ERROR was returned. Optional.
2668	*
2669	* @note Takes the read and write locks.
2670	*/
2671	int GuestSession::i_startSession(int *pvrcGuest)
2672	{
2673	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2674
2675	LogFlowThisFunc(("mID=%RU32, mName=%s, uProtocolVersion=%RU32, openFlags=%x, openTimeoutMS=%RU32\n",
2676	mData.mSession.mID, mData.mSession.mName.c_str(), mData.mProtocolVersion,
2677	mData.mSession.mOpenFlags, mData.mSession.mOpenTimeoutMS));
2678
2679	/* Guest Additions < 4.3 don't support opening dedicated
2680	guest sessions. Simply return success here. */
2681	if (mData.mProtocolVersion < 2)
2682	{
2683	alock.release(); /* Release lock before changing status. */
2684
2685	i_setSessionStatus(GuestSessionStatus_Started, VINF_SUCCESS); /* ignore return code*/
2686	LogFlowThisFunc(("Installed Guest Additions don't support opening dedicated sessions, skipping\n"));
2687	return VINF_SUCCESS;
2688	}
2689
2690	if (mData.mStatus != GuestSessionStatus_Undefined)
2691	return VINF_SUCCESS;
2692
2693	/** @todo mData.mSession.uFlags validation. */
2694
2695	alock.release(); /* Release lock before changing status. */
2696
2697	/* Set current session status. */
2698	int vrc = i_setSessionStatus(GuestSessionStatus_Starting, VINF_SUCCESS);
2699	if (RT_FAILURE(vrc))
2700	return vrc;
2701
2702	GuestWaitEvent *pEvent = NULL;
2703	GuestEventTypes eventTypes;
2704	try
2705	{
2706	eventTypes.push_back(VBoxEventType_OnGuestSessionStateChanged);
2707
2708	vrc = registerWaitEventEx(mData.mSession.mID, mData.mObjectID, eventTypes, &pEvent);
2709	}
2710	catch (std::bad_alloc &)
2711	{
2712	vrc = VERR_NO_MEMORY;
2713	}
2714
2715	if (RT_FAILURE(vrc))
2716	return vrc;
2717
2718	alock.acquire(); /* Re-acquire lock before accessing session attributes below. */
2719
2720	VBOXHGCMSVCPARM paParms[8];
2721
2722	int i = 0;
2723	HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
2724	HGCMSvcSetU32(&paParms[i++], mData.mProtocolVersion);
2725	HGCMSvcSetPv(&paParms[i++], (void*)mData.mCredentials.mUser.c_str(),
2726	(ULONG)mData.mCredentials.mUser.length() + 1);
2727	HGCMSvcSetPv(&paParms[i++], (void*)mData.mCredentials.mPassword.c_str(),
2728	(ULONG)mData.mCredentials.mPassword.length() + 1);
2729	HGCMSvcSetPv(&paParms[i++], (void*)mData.mCredentials.mDomain.c_str(),
2730	(ULONG)mData.mCredentials.mDomain.length() + 1);
2731	HGCMSvcSetU32(&paParms[i++], mData.mSession.mOpenFlags);
2732
2733	alock.release(); /* Drop lock before sending. */
2734
2735	vrc = i_sendMessage(HOST_MSG_SESSION_CREATE, i, paParms, VBOX_GUESTCTRL_DST_ROOT_SVC);
2736	if (RT_SUCCESS(vrc))
2737	{
2738	vrc = i_waitForStatusChange(pEvent, GuestSessionWaitForFlag_Start,
2739	30 * 1000 /* 30s timeout */,
2740	NULL /* Session status */, pvrcGuest);
2741	}
2742	else
2743	{
2744	/*
2745	* Unable to start guest session - update its current state.
2746	* Since there is no (official API) way to recover a failed guest session
2747	* this also marks the end state. Internally just calling this
2748	* same function again will work though.
2749	*/
2750	i_setSessionStatus(GuestSessionStatus_Error, vrc); /* ignore return code */
2751	}
2752
2753	unregisterWaitEvent(pEvent);
2754
2755	LogFlowFuncLeaveRC(vrc);
2756	return vrc;
2757	}
2758
2759	/**
2760	* Starts the guest session asynchronously in a separate worker thread.
2761	*
2762	* @returns IPRT status code.
2763	*/
2764	int GuestSession::i_startSessionAsync(void)
2765	{
2766	LogFlowThisFuncEnter();
2767
2768	/* Create task: */
2769	GuestSessionTaskInternalStart *pTask = NULL;
2770	try
2771	{
2772	pTask = new GuestSessionTaskInternalStart(this);
2773	}
2774	catch (std::bad_alloc &)
2775	{
2776	return VERR_NO_MEMORY;
2777	}
2778	if (pTask->isOk())
2779	{
2780	/* Kick off the thread: */
2781	HRESULT hrc = pTask->createThread();
2782	pTask = NULL; /* Not valid anymore, not even on failure! */
2783	if (SUCCEEDED(hrc))
2784	{
2785	LogFlowFuncLeaveRC(VINF_SUCCESS);
2786	return VINF_SUCCESS;
2787	}
2788	LogFlow(("GuestSession: Failed to create thread for GuestSessionTaskInternalOpen task.\n"));
2789	}
2790	else
2791	LogFlow(("GuestSession: GuestSessionTaskInternalStart creation failed: %Rhrc.\n", pTask->vrc()));
2792	LogFlowFuncLeaveRC(VERR_GENERAL_FAILURE);
2793	return VERR_GENERAL_FAILURE;
2794	}
2795
2796	/**
2797	* Static function to start a guest session asynchronously.
2798	*
2799	* @returns IPRT status code.
2800	* @param pTask Task object to use for starting the guest session.
2801	*/
2802	/* static */
2803	int GuestSession::i_startSessionThreadTask(GuestSessionTaskInternalStart *pTask)
2804	{
2805	LogFlowFunc(("pTask=%p\n", pTask));
2806	AssertPtr(pTask);
2807
2808	const ComObjPtr<GuestSession> pSession(pTask->Session());
2809	Assert(!pSession.isNull());
2810
2811	AutoCaller autoCaller(pSession);
2812	if (FAILED(autoCaller.hrc()))
2813	return VERR_COM_INVALID_OBJECT_STATE;
2814
2815	int vrc = pSession->i_startSession(NULL /pvrcGuest/);
2816	/* Nothing to do here anymore. */
2817
2818	LogFlowFuncLeaveRC(vrc);
2819	return vrc;
2820	}
2821
2822	/**
2823	* Registers an object with the session, i.e. allocates an object ID.
2824	*
2825	* @return VBox status code.
2826	* @retval VERR_GSTCTL_MAX_OBJECTS_REACHED if the maximum of concurrent objects
2827	* is reached.
2828	* @param pObject Guest object to register (weak pointer). Optional.
2829	* @param enmType Session object type to register.
2830	* @param pidObject Where to return the object ID on success. Optional.
2831	*/
2832	int GuestSession::i_objectRegister(GuestObject pObject, SESSIONOBJECTTYPE enmType, uint32_t pidObject)
2833	{
2834	/* pObject can be NULL. */
2835	/* pidObject is optional. */
2836
2837	/*
2838	* Pick a random bit as starting point. If it's in use, search forward
2839	* for a free one, wrapping around. We've reserved both the zero'th and
2840	* max-1 IDs (see Data constructor).
2841	*/
2842	uint32_t idObject = RTRandU32Ex(1, VBOX_GUESTCTRL_MAX_OBJECTS - 2);
2843	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2844	if (!ASMBitTestAndSet(&mData.bmObjectIds[0], idObject))
2845	{ /* likely */ }
2846	else if (mData.mObjects.size() < VBOX_GUESTCTRL_MAX_OBJECTS - 2 /* First and last are not used */)
2847	{
2848	/* Forward search. */
2849	int iHit = ASMBitNextClear(&mData.bmObjectIds[0], VBOX_GUESTCTRL_MAX_OBJECTS, idObject);
2850	if (iHit < 0)
2851	iHit = ASMBitFirstClear(&mData.bmObjectIds[0], VBOX_GUESTCTRL_MAX_OBJECTS);
2852	AssertLogRelMsgReturn(iHit >= 0, ("object count: %#zu\n", mData.mObjects.size()), VERR_GSTCTL_MAX_CID_OBJECTS_REACHED);
2853	idObject = iHit;
2854	AssertLogRelMsgReturn(!ASMBitTestAndSet(&mData.bmObjectIds[0], idObject), ("idObject=%#x\n", idObject), VERR_INTERNAL_ERROR_2);
2855	}
2856	else
2857	{
2858	LogFunc(("Maximum number of objects reached (enmType=%RU32, %zu objects)\n", enmType, mData.mObjects.size()));
2859	return VERR_GSTCTL_MAX_CID_OBJECTS_REACHED;
2860	}
2861
2862	Log2Func(("enmType=%RU32 -> idObject=%RU32 (%zu objects)\n", enmType, idObject, mData.mObjects.size()));
2863
2864	try
2865	{
2866	mData.mObjects[idObject].pObject = pObject; /* Can be NULL. */
2867	mData.mObjects[idObject].enmType = enmType;
2868	mData.mObjects[idObject].msBirth = RTTimeMilliTS();
2869	}
2870	catch (std::bad_alloc &)
2871	{
2872	ASMBitClear(&mData.bmObjectIds[0], idObject);
2873	return VERR_NO_MEMORY;
2874	}
2875
2876	if (pidObject)
2877	*pidObject = idObject;
2878
2879	return VINF_SUCCESS;
2880	}
2881
2882	/**
2883	* Unregisters an object from the session objects list.
2884	*
2885	* @retval VINF_SUCCESS on success.
2886	* @retval VERR_NOT_FOUND if the object ID was not found.
2887	* @param idObject Object ID to unregister.
2888	*
2889	* @note Takes the write lock.
2890	*/
2891	int GuestSession::i_objectUnregister(uint32_t idObject)
2892	{
2893	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2894
2895	int vrc = VINF_SUCCESS;
2896	AssertMsgStmt(ASMBitTestAndClear(&mData.bmObjectIds, idObject), ("idObject=%#x\n", idObject), vrc = VERR_NOT_FOUND);
2897
2898	SessionObjects::iterator ItObj = mData.mObjects.find(idObject);
2899	AssertMsgReturn(ItObj != mData.mObjects.end(), ("idObject=%#x\n", idObject), VERR_NOT_FOUND);
2900	mData.mObjects.erase(ItObj);
2901
2902	return vrc;
2903	}
2904
2905	/**
2906	* Unregisters all objects from the session list.
2907	*
2908	* @returns VBox status code.
2909	*
2910	* @note Takes the write lock.
2911	*/
2912	int GuestSession::i_objectsUnregister(void)
2913	{
2914	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2915
2916	LogFlowThisFunc(("Unregistering directories (%zu total)\n", mData.mDirectories.size()));
2917
2918	SessionDirectories::iterator itDirs;
2919	while ((itDirs = mData.mDirectories.begin()) != mData.mDirectories.end())
2920	{
2921	alock.release();
2922	i_directoryUnregister(itDirs->second);
2923	alock.acquire();
2924	}
2925
2926	Assert(mData.mDirectories.size() == 0);
2927	mData.mDirectories.clear();
2928
2929	LogFlowThisFunc(("Unregistering files (%zu total)\n", mData.mFiles.size()));
2930
2931	SessionFiles::iterator itFiles;
2932	while ((itFiles = mData.mFiles.begin()) != mData.mFiles.end())
2933	{
2934	alock.release();
2935	i_fileUnregister(itFiles->second);
2936	alock.acquire();
2937	}
2938
2939	Assert(mData.mFiles.size() == 0);
2940	mData.mFiles.clear();
2941
2942	LogFlowThisFunc(("Unregistering processes (%zu total)\n", mData.mProcesses.size()));
2943
2944	SessionProcesses::iterator itProcs;
2945	while ((itProcs = mData.mProcesses.begin()) != mData.mProcesses.end())
2946	{
2947	alock.release();
2948	i_processUnregister(itProcs->second);
2949	alock.acquire();
2950	}
2951
2952	Assert(mData.mProcesses.size() == 0);
2953	mData.mProcesses.clear();
2954
2955	return VINF_SUCCESS;
2956	}
2957
2958	/**
2959	* Notifies all registered objects about a guest session status change.
2960	*
2961	* @returns VBox status code.
2962	* @param enmSessionStatus Session status to notify objects about.
2963	*/
2964	int GuestSession::i_objectsNotifyAboutStatusChange(GuestSessionStatus_T enmSessionStatus)
2965	{
2966	LogFlowThisFunc(("enmSessionStatus=%RU32\n", enmSessionStatus));
2967
2968	int vrc = VINF_SUCCESS;
2969
2970	SessionObjects::iterator itObjs = mData.mObjects.begin();
2971	while (itObjs != mData.mObjects.end())
2972	{
2973	GuestObject *pObj = itObjs->second.pObject;
2974	if (pObj) /* pObject can be NULL (weak pointer). */
2975	{
2976	int vrc2 = pObj->i_onSessionStatusChange(enmSessionStatus);
2977	if (RT_SUCCESS(vrc))
2978	vrc = vrc2;
2979
2980	/* If the session got terminated, make sure to cancel all wait events for
2981	* the current object. */
2982	if (i_isTerminated())
2983	pObj->cancelWaitEvents();
2984	}
2985
2986	++itObjs;
2987	}
2988
2989	LogFlowFuncLeaveRC(vrc);
2990	return vrc;
2991	}
2992
2993	/**
2994	* Renames a path on the guest.
2995	*
2996	* @returns VBox status code.
2997	* @returns VERR_GSTCTL_GUEST_ERROR on received guest error.
2998	* @param strSource Source path on guest to rename.
2999	* @param strDest Destination path on guest to rename \a strSource to.
3000	* @param uFlags Renaming flags.
3001	* @param pvrcGuest Where to return the guest error when
3002	* VERR_GSTCTL_GUEST_ERROR was returned. Optional.
3003	* @note Takes the read lock.
3004	*/
3005	int GuestSession::i_pathRename(const Utf8Str &strSource, const Utf8Str &strDest, uint32_t uFlags, int *pvrcGuest)
3006	{
3007	AssertReturn(!(uFlags & ~PATHRENAME_FLAG_VALID_MASK), VERR_INVALID_PARAMETER);
3008
3009	LogFlowThisFunc(("strSource=%s, strDest=%s, uFlags=0x%x\n",
3010	strSource.c_str(), strDest.c_str(), uFlags));
3011
3012	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3013
3014	GuestWaitEvent *pEvent = NULL;
3015	int vrc = registerWaitEvent(mData.mSession.mID, mData.mObjectID, &pEvent);
3016	if (RT_FAILURE(vrc))
3017	return vrc;
3018
3019	/* Prepare HGCM call. */
3020	VBOXHGCMSVCPARM paParms[8];
3021	int i = 0;
3022	HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
3023	HGCMSvcSetPv(&paParms[i++], (void*)strSource.c_str(),
3024	(ULONG)strSource.length() + 1);
3025	HGCMSvcSetPv(&paParms[i++], (void*)strDest.c_str(),
3026	(ULONG)strDest.length() + 1);
3027	HGCMSvcSetU32(&paParms[i++], uFlags);
3028
3029	alock.release(); /* Drop lock before sending. */
3030
3031	vrc = i_sendMessage(HOST_MSG_PATH_RENAME, i, paParms);
3032	if (RT_SUCCESS(vrc))
3033	{
3034	vrc = pEvent->Wait(30 * 1000);
3035	if (pEvent->HasGuestError() && pvrcGuest)
3036	*pvrcGuest = pEvent->GuestResult();
3037	}
3038
3039	unregisterWaitEvent(pEvent);
3040
3041	LogFlowFuncLeaveRC(vrc);
3042	return vrc;
3043	}
3044
3045	/**
3046	* Returns the user's absolute documents path, if any.
3047	*
3048	* @returns VBox status code.
3049	* @param strPath Where to store the user's document path.
3050	* @param pvrcGuest Guest VBox status code, when returning
3051	* VERR_GSTCTL_GUEST_ERROR. Any other return code indicates
3052	* some host side error.
3053	*
3054	* @note Takes the read lock.
3055	*/
3056	int GuestSession::i_pathUserDocuments(Utf8Str &strPath, int *pvrcGuest)
3057	{
3058	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3059
3060	/** @todo Cache the user's document path? */
3061
3062	GuestWaitEvent *pEvent = NULL;
3063	int vrc = registerWaitEvent(mData.mSession.mID, mData.mObjectID, &pEvent);
3064	if (RT_FAILURE(vrc))
3065	return vrc;
3066
3067	/* Prepare HGCM call. */
3068	VBOXHGCMSVCPARM paParms[2];
3069	int i = 0;
3070	HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
3071
3072	alock.release(); /* Drop lock before sending. */
3073
3074	vrc = i_sendMessage(HOST_MSG_PATH_USER_DOCUMENTS, i, paParms);
3075	if (RT_SUCCESS(vrc))
3076	{
3077	vrc = pEvent->Wait(30 * 1000);
3078	if (RT_SUCCESS(vrc))
3079	{
3080	strPath = pEvent->Payload().ToString();
3081	}
3082	else
3083	{
3084	if (pEvent->HasGuestError() && pvrcGuest)
3085	*pvrcGuest = pEvent->GuestResult();
3086	}
3087	}
3088
3089	unregisterWaitEvent(pEvent);
3090
3091	LogFlowFuncLeaveRC(vrc);
3092	return vrc;
3093	}
3094
3095	/**
3096	* Returns the user's absolute home path, if any.
3097	*
3098	* @returns VBox status code.
3099	* @param strPath Where to store the user's home path.
3100	* @param pvrcGuest Guest VBox status code, when returning
3101	* VERR_GSTCTL_GUEST_ERROR. Any other return code indicates
3102	* some host side error.
3103	*
3104	* @note Takes the read lock.
3105	*/
3106	int GuestSession::i_pathUserHome(Utf8Str &strPath, int *pvrcGuest)
3107	{
3108	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3109
3110	/** @todo Cache the user's home path? */
3111
3112	GuestWaitEvent *pEvent = NULL;
3113	int vrc = registerWaitEvent(mData.mSession.mID, mData.mObjectID, &pEvent);
3114	if (RT_FAILURE(vrc))
3115	return vrc;
3116
3117	/* Prepare HGCM call. */
3118	VBOXHGCMSVCPARM paParms[2];
3119	int i = 0;
3120	HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
3121
3122	alock.release(); /* Drop lock before sending. */
3123
3124	vrc = i_sendMessage(HOST_MSG_PATH_USER_HOME, i, paParms);
3125	if (RT_SUCCESS(vrc))
3126	{
3127	vrc = pEvent->Wait(30 * 1000);
3128	if (RT_SUCCESS(vrc))
3129	{
3130	strPath = pEvent->Payload().ToString();
3131	}
3132	else
3133	{
3134	if (pEvent->HasGuestError() && pvrcGuest)
3135	*pvrcGuest = pEvent->GuestResult();
3136	}
3137	}
3138
3139	unregisterWaitEvent(pEvent);
3140
3141	LogFlowFuncLeaveRC(vrc);
3142	return vrc;
3143	}
3144
3145	/**
3146	* Unregisters a process object from a guest session.
3147	*
3148	* @returns VBox status code. VERR_NOT_FOUND if the process is not registered (anymore).
3149	* @param pProcess Process object to unregister from session.
3150	*
3151	* @note Takes the write lock.
3152	*/
3153	int GuestSession::i_processUnregister(GuestProcess *pProcess)
3154	{
3155	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
3156
3157	LogFlowThisFunc(("pProcess=%p\n", pProcess));
3158
3159	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3160
3161	const uint32_t idObject = pProcess->getObjectID();
3162
3163	LogFlowFunc(("Removing process (objectID=%RU32) ...\n", idObject));
3164
3165	int vrc = i_objectUnregister(idObject);
3166	if (RT_FAILURE(vrc))
3167	return vrc;
3168
3169	SessionProcesses::iterator itProcs = mData.mProcesses.find(idObject);
3170	AssertReturn(itProcs != mData.mProcesses.end(), VERR_NOT_FOUND);
3171
3172	/* Make sure to consume the pointer before the one of the iterator gets released. */
3173	ComObjPtr<GuestProcess> pProc = pProcess;
3174
3175	ULONG uPID;
3176	HRESULT hrc = pProc->COMGETTER(PID)(&uPID);
3177	ComAssertComRC(hrc);
3178
3179	LogFlowFunc(("Removing process ID=%RU32 (session %RU32, guest PID %RU32, now total %zu processes)\n",
3180	idObject, mData.mSession.mID, uPID, mData.mProcesses.size()));
3181
3182	vrc = pProcess->i_onUnregister();
3183	AssertRCReturn(vrc, vrc);
3184
3185	mData.mProcesses.erase(itProcs);
3186
3187	alock.release(); /* Release lock before firing off event. */
3188
3189	::FireGuestProcessRegisteredEvent(mEventSource, this /* Session /, pProc, uPID, false / Process unregistered */);
3190
3191	pProc.setNull();
3192
3193	LogFlowFuncLeaveRC(vrc);
3194	return vrc;
3195	}
3196
3197	/**
3198	* Creates but does not start the process yet.
3199	*
3200	* See GuestProcess::startProcess() or GuestProcess::startProcessAsync() for
3201	* starting the process.
3202	*
3203	* @returns IPRT status code.
3204	* @param procInfo Process startup info to use for starting the process.
3205	* @param pProcess Where to return the created guest process object on success.
3206	*
3207	* @note Takes the write lock.
3208	*/
3209	int GuestSession::i_processCreateEx(GuestProcessStartupInfo &procInfo, ComObjPtr<GuestProcess> &pProcess)
3210	{
3211	LogFlowFunc(("mExe=%s, mFlags=%x, mTimeoutMS=%RU32\n",
3212	procInfo.mExecutable.c_str(), procInfo.mFlags, procInfo.mTimeoutMS));
3213	#ifdef DEBUG
3214	if (procInfo.mArguments.size())
3215	{
3216	LogFlowFunc(("Arguments:"));
3217	ProcessArguments::const_iterator it = procInfo.mArguments.begin();
3218	while (it != procInfo.mArguments.end())
3219	{
3220	LogFlow((" %s", (*it).c_str()));
3221	++it;
3222	}
3223	LogFlow(("\n"));
3224	}
3225	#endif
3226
3227	/* Validate flags. */
3228	if (procInfo.mFlags)
3229	{
3230	if ( !(procInfo.mFlags & ProcessCreateFlag_IgnoreOrphanedProcesses)
3231	&& !(procInfo.mFlags & ProcessCreateFlag_WaitForProcessStartOnly)
3232	&& !(procInfo.mFlags & ProcessCreateFlag_Hidden)
3233	&& !(procInfo.mFlags & ProcessCreateFlag_Profile)
3234	&& !(procInfo.mFlags & ProcessCreateFlag_WaitForStdOut)
3235	&& !(procInfo.mFlags & ProcessCreateFlag_WaitForStdErr))
3236	{
3237	return VERR_INVALID_PARAMETER;
3238	}
3239	}
3240
3241	if ( (procInfo.mFlags & ProcessCreateFlag_WaitForProcessStartOnly)
3242	&& ( (procInfo.mFlags & ProcessCreateFlag_WaitForStdOut)
3243	\|\| (procInfo.mFlags & ProcessCreateFlag_WaitForStdErr)
3244	)
3245	)
3246	{
3247	return VERR_INVALID_PARAMETER;
3248	}
3249
3250	if (procInfo.mPriority)
3251	{
3252	if (!(procInfo.mPriority & ProcessPriority_Default))
3253	return VERR_INVALID_PARAMETER;
3254	}
3255
3256	/* Adjust timeout.
3257	* If set to 0, we define an infinite timeout (unlimited process run time). */
3258	if (procInfo.mTimeoutMS == 0)
3259	procInfo.mTimeoutMS = UINT32_MAX;
3260
3261	/** @todo Implement process priority + affinity. */
3262
3263	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3264
3265	/* Create the process object. */
3266	HRESULT hrc = pProcess.createObject();
3267	if (FAILED(hrc))
3268	return VERR_COM_UNEXPECTED;
3269
3270	/* Register a new object ID. */
3271	uint32_t idObject;
3272	int vrc = i_objectRegister(pProcess, SESSIONOBJECTTYPE_PROCESS, &idObject);
3273	if (RT_FAILURE(vrc))
3274	{
3275	pProcess.setNull();
3276	return vrc;
3277	}
3278
3279	vrc = pProcess->init(mParent->i_getConsole() /* Console /, this / Session */, idObject, procInfo, mData.mpBaseEnvironment);
3280	if (RT_FAILURE(vrc))
3281	return vrc;
3282
3283	/* Add the created process to our map. */
3284	try
3285	{
3286	mData.mProcesses[idObject] = pProcess;
3287
3288	LogFlowFunc(("Added new process (Session: %RU32) with process ID=%RU32 (now total %zu processes)\n",
3289	mData.mSession.mID, idObject, mData.mProcesses.size()));
3290
3291	alock.release(); /* Release lock before firing off event. */
3292
3293	::FireGuestProcessRegisteredEvent(mEventSource, this /* Session /, pProcess, 0 / PID /, true / Process registered */);
3294	}
3295	catch (std::bad_alloc &)
3296	{
3297	vrc = VERR_NO_MEMORY;
3298	}
3299
3300	return vrc;
3301	}
3302
3303	/**
3304	* Checks if a process object exists and optionally returns its object.
3305	*
3306	* @returns \c true if process object exists, or \c false if not.
3307	* @param uProcessID ID of process object to check.
3308	* @param pProcess Where to return the found process object on success.
3309	*
3310	* @note No locking done!
3311	*/
3312	inline bool GuestSession::i_processExists(uint32_t uProcessID, ComObjPtr<GuestProcess> *pProcess)
3313	{
3314	SessionProcesses::const_iterator it = mData.mProcesses.find(uProcessID);
3315	if (it != mData.mProcesses.end())
3316	{
3317	if (pProcess)
3318	*pProcess = it->second;
3319	return true;
3320	}
3321	return false;
3322	}
3323
3324	/**
3325	* Returns the process object from a guest PID.
3326	*
3327	* @returns VBox status code.
3328	* @param uPID Guest PID to get process object for.
3329	* @param pProcess Where to return the process object on success.
3330	*
3331	* @note No locking done!
3332	*/
3333	inline int GuestSession::i_processGetByPID(ULONG uPID, ComObjPtr<GuestProcess> *pProcess)
3334	{
3335	AssertReturn(uPID, false);
3336	/* pProcess is optional. */
3337
3338	SessionProcesses::iterator itProcs = mData.mProcesses.begin();
3339	for (; itProcs != mData.mProcesses.end(); ++itProcs)
3340	{
3341	ComObjPtr<GuestProcess> pCurProc = itProcs->second;
3342	AutoCaller procCaller(pCurProc);
3343	if (!procCaller.isOk())
3344	return VERR_COM_INVALID_OBJECT_STATE;
3345
3346	ULONG uCurPID;
3347	HRESULT hrc = pCurProc->COMGETTER(PID)(&uCurPID);
3348	ComAssertComRC(hrc);
3349
3350	if (uCurPID == uPID)
3351	{
3352	if (pProcess)
3353	*pProcess = pCurProc;
3354	return VINF_SUCCESS;
3355	}
3356	}
3357
3358	return VERR_NOT_FOUND;
3359	}
3360
3361	/**
3362	* Sends a message to the HGCM host service.
3363	*
3364	* @returns VBox status code.
3365	* @param uMessage Message ID to send.
3366	* @param uParms Number of parameters in \a paParms to send.
3367	* @param paParms Array of HGCM parameters to send.
3368	* @param fDst Host message destination flags of type VBOX_GUESTCTRL_DST_XXX.
3369	*/
3370	int GuestSession::i_sendMessage(uint32_t uMessage, uint32_t uParms, PVBOXHGCMSVCPARM paParms,
3371	uint64_t fDst /= VBOX_GUESTCTRL_DST_SESSION/)
3372	{
3373	LogFlowThisFuncEnter();
3374
3375	#ifndef VBOX_GUESTCTRL_TEST_CASE
3376	ComObjPtr<Console> pConsole = mParent->i_getConsole();
3377	Assert(!pConsole.isNull());
3378
3379	/* Forward the information to the VMM device. */
3380	VMMDev *pVMMDev = pConsole->i_getVMMDev();
3381	AssertPtr(pVMMDev);
3382
3383	LogFlowThisFunc(("uMessage=%RU32 (%s), uParms=%RU32\n", uMessage, GstCtrlHostMsgtoStr((guestControl::eHostMsg)uMessage), uParms));
3384
3385	/* HACK ALERT! We extend the first parameter to 64-bit and use the
3386	two topmost bits for call destination information. */
3387	Assert(fDst == VBOX_GUESTCTRL_DST_SESSION \|\| fDst == VBOX_GUESTCTRL_DST_ROOT_SVC \|\| fDst == VBOX_GUESTCTRL_DST_BOTH);
3388	Assert(paParms[0].type == VBOX_HGCM_SVC_PARM_32BIT);
3389	paParms[0].type = VBOX_HGCM_SVC_PARM_64BIT;
3390	paParms[0].u.uint64 = (uint64_t)paParms[0].u.uint32 \| fDst;
3391
3392	/* Make the call. */
3393	int vrc = pVMMDev->hgcmHostCall(HGCMSERVICE_NAME, uMessage, uParms, paParms);
3394	if (RT_FAILURE(vrc))
3395	{
3396	/** @todo What to do here? */
3397	}
3398	#else
3399	/* Not needed within testcases. */
3400	int vrc = VINF_SUCCESS;
3401	#endif
3402	LogFlowFuncLeaveRC(vrc);
3403	return vrc;
3404	}
3405
3406	/**
3407	* Sets the guest session's current status.
3408	*
3409	* @returns VBox status code.
3410	* @param sessionStatus Session status to set.
3411	* @param vrcSession Session result to set (for error handling).
3412	*
3413	* @note Takes the write lock.
3414	*/
3415	int GuestSession::i_setSessionStatus(GuestSessionStatus_T sessionStatus, int vrcSession)
3416	{
3417	LogFlowThisFunc(("oldStatus=%RU32, newStatus=%RU32, vrcSession=%Rrc\n", mData.mStatus, sessionStatus, vrcSession));
3418
3419	if (sessionStatus == GuestSessionStatus_Error)
3420	{
3421	AssertMsg(RT_FAILURE(vrcSession), ("Guest vrcSession must be an error (%Rrc)\n", vrcSession));
3422	/* Do not allow overwriting an already set error. If this happens
3423	* this means we forgot some error checking/locking somewhere. */
3424	AssertMsg(RT_SUCCESS(mData.mVrc), ("Guest mVrc already set (to %Rrc)\n", mData.mVrc));
3425	}
3426	else
3427	AssertMsg(RT_SUCCESS(vrcSession), ("Guest vrcSession must not be an error (%Rrc)\n", vrcSession));
3428
3429	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3430
3431	int vrc = VINF_SUCCESS;
3432
3433	if (mData.mStatus != sessionStatus)
3434	{
3435	mData.mStatus = sessionStatus;
3436	mData.mVrc = vrcSession;
3437
3438	/* Make sure to notify all underlying objects first. */
3439	vrc = i_objectsNotifyAboutStatusChange(sessionStatus);
3440
3441	ComObjPtr<VirtualBoxErrorInfo> errorInfo;
3442	HRESULT hrc = errorInfo.createObject();
3443	ComAssertComRC(hrc);
3444	int vrc2 = errorInfo->initEx(VBOX_E_IPRT_ERROR, vrcSession, COM_IIDOF(IGuestSession), getComponentName(),
3445	i_guestErrorToString(vrcSession));
3446	AssertRC(vrc2);
3447
3448	alock.release(); /* Release lock before firing off event. */
3449
3450	::FireGuestSessionStateChangedEvent(mEventSource, this, mData.mSession.mID, sessionStatus, errorInfo);
3451	}
3452
3453	LogFlowFuncLeaveRC(vrc);
3454	return vrc;
3455	}
3456
3457	/** @todo Unused --remove? */
3458	int GuestSession::i_signalWaiters(GuestSessionWaitResult_T enmWaitResult, int vrc /= VINF_SUCCESS /)
3459	{
3460	RT_NOREF(enmWaitResult, vrc);
3461
3462	/*LogFlowThisFunc(("enmWaitResult=%d, vrc=%Rrc, mWaitCount=%RU32, mWaitEvent=%p\n",
3463	enmWaitResult, vrc, mData.mWaitCount, mData.mWaitEvent));*/
3464
3465	/* Note: No write locking here -- already done in the caller. */
3466
3467	int vrc2 = VINF_SUCCESS;
3468	/*if (mData.mWaitEvent)
3469	vrc2 = mData.mWaitEvent->Signal(enmWaitResult, vrc);*/
3470	LogFlowFuncLeaveRC(vrc2);
3471	return vrc2;
3472	}
3473
3474	/**
3475	* Shuts down (and optionally powers off / reboots) the guest.
3476	* Needs supported Guest Additions installed.
3477	*
3478	* @returns VBox status code. VERR_NOT_SUPPORTED if not supported by Guest Additions.
3479	* @param fFlags Guest shutdown flags.
3480	* @param pvrcGuest Guest VBox status code, when returning
3481	* VERR_GSTCTL_GUEST_ERROR. Any other return code indicates
3482	* some host side error.
3483	*
3484	* @note Takes the read lock.
3485	*/
3486	int GuestSession::i_shutdown(uint32_t fFlags, int *pvrcGuest)
3487	{
3488	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3489
3490	AssertPtrReturn(mParent, VERR_INVALID_POINTER);
3491	if (!(mParent->i_getGuestControlFeatures0() & VBOX_GUESTCTRL_GF_0_SHUTDOWN))
3492	return VERR_NOT_SUPPORTED;
3493
3494	LogRel(("Guest Control: Shutting down guest (flags = %#x) ...\n", fFlags));
3495
3496	GuestWaitEvent *pEvent = NULL;
3497	int vrc = registerWaitEvent(mData.mSession.mID, mData.mObjectID, &pEvent);
3498	if (RT_FAILURE(vrc))
3499	return vrc;
3500
3501	/* Prepare HGCM call. */
3502	VBOXHGCMSVCPARM paParms[2];
3503	int i = 0;
3504	HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
3505	HGCMSvcSetU32(&paParms[i++], fFlags);
3506
3507	alock.release(); /* Drop lock before sending. */
3508
3509	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
3510
3511	vrc = i_sendMessage(HOST_MSG_SHUTDOWN, i, paParms);
3512	if (RT_SUCCESS(vrc))
3513	{
3514	vrc = pEvent->Wait(30 * 1000);
3515	if (RT_FAILURE(vrc))
3516	{
3517	if (pEvent->HasGuestError())
3518	vrcGuest = pEvent->GuestResult();
3519	}
3520	}
3521
3522	if (RT_FAILURE(vrc))
3523	{
3524	LogRel(("Guest Control: Shutting down guest failed, vrc=%Rrc\n", vrc == VERR_GSTCTL_GUEST_ERROR ? vrcGuest : vrc));
3525	if (pEvent->HasGuestError() && pvrcGuest)
3526	*pvrcGuest = vrcGuest;
3527	}
3528
3529	unregisterWaitEvent(pEvent);
3530
3531	LogFlowFuncLeaveRC(vrc);
3532	return vrc;
3533	}
3534
3535	/**
3536	* Determines the protocol version (sets mData.mProtocolVersion).
3537	*
3538	* This is called from the init method prior to to establishing a guest session.
3539	*
3540	* @returns VBox status code.
3541	* @retval VERR_NOT_FOUND if the Guest Additions were not found (or were not reported) yet.
3542	*/
3543	int GuestSession::i_determineProtocolVersion(void)
3544	{
3545	/*
3546	* We currently do this based on the reported Guest Additions version,
3547	* ASSUMING that VBoxService and VBoxDrv are at the same version.
3548	*/
3549	ComObjPtr<Guest> pGuest = mParent;
3550	AssertReturn(!pGuest.isNull(), VERR_NOT_SUPPORTED);
3551	uint32_t uGaVersion = pGuest->i_getAdditionsVersion();
3552	if (!uGaVersion) /* If 0, there was no Guest Additions version detected (yet), or the VM is in reset state. */
3553	return VERR_NOT_FOUND;
3554
3555	/* Everyone supports version one, if they support anything at all. */
3556	mData.mProtocolVersion = 1;
3557
3558	/* Guest control 2.0 was introduced with 4.3.0. */
3559	if (uGaVersion >= VBOX_FULL_VERSION_MAKE(4,3,0))
3560	mData.mProtocolVersion = 2; /* Guest control 2.0. */
3561
3562	LogFlowThisFunc(("uGaVersion=%u.%u.%u => mProtocolVersion=%u\n",
3563	VBOX_FULL_VERSION_GET_MAJOR(uGaVersion), VBOX_FULL_VERSION_GET_MINOR(uGaVersion),
3564	VBOX_FULL_VERSION_GET_BUILD(uGaVersion), mData.mProtocolVersion));
3565
3566	/*
3567	* Inform the user about outdated Guest Additions (VM release log).
3568	*/
3569	if (mData.mProtocolVersion < 2)
3570	LogRelMax(3, ("Warning: Guest Additions v%u.%u.%u only supports the older guest control protocol version %u.\n"
3571	" Please upgrade GAs to the current version to get full guest control capabilities.\n",
3572	VBOX_FULL_VERSION_GET_MAJOR(uGaVersion), VBOX_FULL_VERSION_GET_MINOR(uGaVersion),
3573	VBOX_FULL_VERSION_GET_BUILD(uGaVersion), mData.mProtocolVersion));
3574
3575	return VINF_SUCCESS;
3576	}
3577
3578	/**
3579	* Waits for guest session events.
3580	*
3581	* @returns VBox status code.
3582	* @retval VERR_GSTCTL_GUEST_ERROR on received guest error.
3583	* @retval VERR_TIMEOUT when a timeout has occurred.
3584	* @param fWaitFlags Wait flags to use.
3585	* @param uTimeoutMS Timeout (in ms) to wait.
3586	* @param waitResult Where to return the wait result on success.
3587	* @param pvrcGuest Where to return the guest error when
3588	* VERR_GSTCTL_GUEST_ERROR was returned. Optional.
3589	*
3590	* @note Takes the read lock.
3591	*/
3592	int GuestSession::i_waitFor(uint32_t fWaitFlags, ULONG uTimeoutMS, GuestSessionWaitResult_T &waitResult, int *pvrcGuest)
3593	{
3594	LogFlowThisFuncEnter();
3595
3596	AssertReturn(fWaitFlags, VERR_INVALID_PARAMETER);
3597
3598	/*LogFlowThisFunc(("fWaitFlags=0x%x, uTimeoutMS=%RU32, mStatus=%RU32, mWaitCount=%RU32, mWaitEvent=%p, pvrcGuest=%p\n",
3599	fWaitFlags, uTimeoutMS, mData.mStatus, mData.mWaitCount, mData.mWaitEvent, pvrcGuest));*/
3600
3601	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3602
3603	/* Did some error occur before? Then skip waiting and return. */
3604	if (mData.mStatus == GuestSessionStatus_Error)
3605	{
3606	waitResult = GuestSessionWaitResult_Error;
3607	AssertMsg(RT_FAILURE(mData.mVrc), ("No error mVrc (%Rrc) set when guest session indicated an error\n", mData.mVrc));
3608	if (pvrcGuest)
3609	pvrcGuest = mData.mVrc; / Return last set error. */
3610	return VERR_GSTCTL_GUEST_ERROR;
3611	}
3612
3613	/* Guest Additions < 4.3 don't support session handling, skip. */
3614	if (mData.mProtocolVersion < 2)
3615	{
3616	waitResult = GuestSessionWaitResult_WaitFlagNotSupported;
3617
3618	LogFlowThisFunc(("Installed Guest Additions don't support waiting for dedicated sessions, skipping\n"));
3619	return VINF_SUCCESS;
3620	}
3621
3622	waitResult = GuestSessionWaitResult_None;
3623	if (fWaitFlags & GuestSessionWaitForFlag_Terminate)
3624	{
3625	switch (mData.mStatus)
3626	{
3627	case GuestSessionStatus_Terminated:
3628	case GuestSessionStatus_Down:
3629	waitResult = GuestSessionWaitResult_Terminate;
3630	break;
3631
3632	case GuestSessionStatus_TimedOutKilled:
3633	case GuestSessionStatus_TimedOutAbnormally:
3634	waitResult = GuestSessionWaitResult_Timeout;
3635	break;
3636
3637	case GuestSessionStatus_Error:
3638	/* Handled above. */
3639	break;
3640
3641	case GuestSessionStatus_Started:
3642	waitResult = GuestSessionWaitResult_Start;
3643	break;
3644
3645	case GuestSessionStatus_Undefined:
3646	case GuestSessionStatus_Starting:
3647	/* Do the waiting below. */
3648	break;
3649
3650	default:
3651	AssertMsgFailed(("Unhandled session status %RU32\n", mData.mStatus));
3652	return VERR_NOT_IMPLEMENTED;
3653	}
3654	}
3655	else if (fWaitFlags & GuestSessionWaitForFlag_Start)
3656	{
3657	switch (mData.mStatus)
3658	{
3659	case GuestSessionStatus_Started:
3660	case GuestSessionStatus_Terminating:
3661	case GuestSessionStatus_Terminated:
3662	case GuestSessionStatus_Down:
3663	waitResult = GuestSessionWaitResult_Start;
3664	break;
3665
3666	case GuestSessionStatus_Error:
3667	waitResult = GuestSessionWaitResult_Error;
3668	break;
3669
3670	case GuestSessionStatus_TimedOutKilled:
3671	case GuestSessionStatus_TimedOutAbnormally:
3672	waitResult = GuestSessionWaitResult_Timeout;
3673	break;
3674
3675	case GuestSessionStatus_Undefined:
3676	case GuestSessionStatus_Starting:
3677	/* Do the waiting below. */
3678	break;
3679
3680	default:
3681	AssertMsgFailed(("Unhandled session status %RU32\n", mData.mStatus));
3682	return VERR_NOT_IMPLEMENTED;
3683	}
3684	}
3685
3686	LogFlowThisFunc(("sessionStatus=%RU32, vrcSession=%Rrc, waitResult=%RU32\n", mData.mStatus, mData.mVrc, waitResult));
3687
3688	/* No waiting needed? Return immediately using the last set error. */
3689	if (waitResult != GuestSessionWaitResult_None)
3690	{
3691	if (pvrcGuest)
3692	pvrcGuest = mData.mVrc; / Return last set error (if any). */
3693	return RT_SUCCESS(mData.mVrc) ? VINF_SUCCESS : VERR_GSTCTL_GUEST_ERROR;
3694	}
3695
3696	int vrc = VINF_SUCCESS;
3697
3698	uint64_t const tsStart = RTTimeMilliTS();
3699	uint64_t tsNow = tsStart;
3700
3701	while (tsNow - tsStart < uTimeoutMS)
3702	{
3703	GuestWaitEvent *pEvent = NULL;
3704	GuestEventTypes eventTypes;
3705	try
3706	{
3707	eventTypes.push_back(VBoxEventType_OnGuestSessionStateChanged);
3708
3709	vrc = registerWaitEventEx(mData.mSession.mID, mData.mObjectID, eventTypes, &pEvent);
3710	}
3711	catch (std::bad_alloc &)
3712	{
3713	vrc = VERR_NO_MEMORY;
3714	}
3715
3716	if (RT_FAILURE(vrc))
3717	return vrc;
3718
3719	alock.release(); /* Release lock before waiting. */
3720
3721	GuestSessionStatus_T sessionStatus;
3722	vrc = i_waitForStatusChange(pEvent, fWaitFlags,
3723	uTimeoutMS - (tsNow - tsStart), &sessionStatus, pvrcGuest);
3724	if (RT_SUCCESS(vrc))
3725	{
3726	switch (sessionStatus)
3727	{
3728	case GuestSessionStatus_Started:
3729	waitResult = GuestSessionWaitResult_Start;
3730	break;
3731
3732	case GuestSessionStatus_Starting:
3733	RT_FALL_THROUGH();
3734	case GuestSessionStatus_Terminating:
3735	if (fWaitFlags & GuestSessionWaitForFlag_Status) /* Any status wanted? */
3736	waitResult = GuestSessionWaitResult_Status;
3737	/* else: Wait another round until we get the event(s) fWaitFlags defines. */
3738	break;
3739
3740	case GuestSessionStatus_Terminated:
3741	waitResult = GuestSessionWaitResult_Terminate;
3742	break;
3743
3744	case GuestSessionStatus_TimedOutKilled:
3745	RT_FALL_THROUGH();
3746	case GuestSessionStatus_TimedOutAbnormally:
3747	waitResult = GuestSessionWaitResult_Timeout;
3748	break;
3749
3750	case GuestSessionStatus_Down:
3751	waitResult = GuestSessionWaitResult_Terminate;
3752	break;
3753
3754	case GuestSessionStatus_Error:
3755	waitResult = GuestSessionWaitResult_Error;
3756	break;
3757
3758	default:
3759	waitResult = GuestSessionWaitResult_Status;
3760	break;
3761	}
3762	}
3763
3764	unregisterWaitEvent(pEvent);
3765
3766	/* Wait result not None, e.g. some result acquired or a wait error occurred? Bail out. */
3767	if ( waitResult != GuestSessionWaitResult_None
3768	\|\| RT_FAILURE(vrc))
3769	break;
3770
3771	tsNow = RTTimeMilliTS();
3772
3773	alock.acquire(); /* Re-acquire lock before waiting for the next event. */
3774	}
3775
3776	if (tsNow - tsStart >= uTimeoutMS)
3777	{
3778	waitResult = GuestSessionWaitResult_None; /* Paranoia. */
3779	vrc = VERR_TIMEOUT;
3780	}
3781
3782	LogFlowFuncLeaveRC(vrc);
3783	return vrc;
3784	}
3785
3786	/**
3787	* Waits for guest session status changes.
3788	*
3789	* @returns VBox status code.
3790	* @retval VERR_GSTCTL_GUEST_ERROR on received guest error.
3791	* @retval VERR_WRONG_ORDER when an unexpected event type has been received.
3792	* @param pEvent Wait event to use for waiting.
3793	* @param fWaitFlags Wait flags to use.
3794	* @param uTimeoutMS Timeout (in ms) to wait.
3795	* @param pSessionStatus Where to return the guest session status.
3796	* @param pvrcGuest Where to return the guest error when
3797	* VERR_GSTCTL_GUEST_ERROR was returned. Optional.
3798	*/
3799	int GuestSession::i_waitForStatusChange(GuestWaitEvent *pEvent, uint32_t fWaitFlags, uint32_t uTimeoutMS,
3800	GuestSessionStatus_T pSessionStatus, int pvrcGuest)
3801	{
3802	RT_NOREF(fWaitFlags);
3803	AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
3804
3805	VBoxEventType_T evtType;
3806	ComPtr<IEvent> pIEvent;
3807	int vrc = waitForEvent(pEvent, uTimeoutMS, &evtType, pIEvent.asOutParam());
3808	if (RT_SUCCESS(vrc))
3809	{
3810	if (evtType == VBoxEventType_OnGuestSessionStateChanged)
3811	{
3812	ComPtr<IGuestSessionStateChangedEvent> pChangedEvent = pIEvent;
3813	Assert(!pChangedEvent.isNull());
3814
3815	GuestSessionStatus_T sessionStatus;
3816	pChangedEvent->COMGETTER(Status)(&sessionStatus);
3817	if (pSessionStatus)
3818	*pSessionStatus = sessionStatus;
3819
3820	ComPtr<IVirtualBoxErrorInfo> errorInfo;
3821	HRESULT hrc = pChangedEvent->COMGETTER(Error)(errorInfo.asOutParam());
3822	ComAssertComRC(hrc);
3823
3824	LONG lGuestRc;
3825	hrc = errorInfo->COMGETTER(ResultDetail)(&lGuestRc);
3826	ComAssertComRC(hrc);
3827	if (RT_FAILURE((int)lGuestRc))
3828	vrc = VERR_GSTCTL_GUEST_ERROR;
3829	if (pvrcGuest)
3830	*pvrcGuest = (int)lGuestRc;
3831
3832	LogFlowThisFunc(("Status changed event for session ID=%RU32, new status is: %RU32 (%Rrc)\n",
3833	mData.mSession.mID, sessionStatus,
3834	RT_SUCCESS((int)lGuestRc) ? VINF_SUCCESS : (int)lGuestRc));
3835	}
3836	else /** @todo Re-visit this. Can this happen more frequently? */
3837	AssertMsgFailedReturn(("Got unexpected event type %#x\n", evtType), VERR_WRONG_ORDER);
3838	}
3839	/* waitForEvent may also return VERR_GSTCTL_GUEST_ERROR like we do above, so make pvrcGuest is set. */
3840	else if (pEvent->HasGuestError() && pvrcGuest)
3841	*pvrcGuest = pEvent->GuestResult();
3842	Assert(vrc != VERR_GSTCTL_GUEST_ERROR \|\| !pvrcGuest \|\| *pvrcGuest != (int)0xcccccccc);
3843
3844	LogFlowFuncLeaveRC(vrc);
3845	return vrc;
3846	}
3847
3848	// implementation of public methods
3849	/////////////////////////////////////////////////////////////////////////////
3850
3851	HRESULT GuestSession::close()
3852	{
3853	LogFlowThisFuncEnter();
3854
3855	/* Note: Don't check if the session is ready via i_isStartedExternal() here;
3856	* the session (already) could be in a stopped / aborted state. */
3857
3858	int vrc = VINF_SUCCESS; /* Shut up MSVC. */
3859	int vrcGuest = VINF_SUCCESS;
3860
3861	uint32_t msTimeout = RT_MS_10SEC; /* 10s timeout by default */
3862	for (int i = 0; i < 3; i++)
3863	{
3864	if (i)
3865	{
3866	LogRel(("Guest Control: Closing session '%s' timed out (%RU32s timeout, attempt %d/10), retrying ...\n",
3867	mData.mSession.mName.c_str(), msTimeout / RT_MS_1SEC, i + 1));
3868	msTimeout += RT_MS_5SEC; /* Slightly increase the timeout. */
3869	}
3870
3871	/* Close session on guest. */
3872	vrc = i_closeSession(0 /* Flags */, msTimeout, &vrcGuest);
3873	if ( RT_SUCCESS(vrc)
3874	\|\| vrc != VERR_TIMEOUT) /* If something else happened there is no point in retrying further. */
3875	break;
3876	}
3877
3878	/* On failure don't return here, instead do all the cleanup
3879	* work first and then return an error. */
3880
3881	/* Destroy session + remove ourselves from the session list. */
3882	AssertPtr(mParent);
3883	int vrc2 = mParent->i_sessionDestroy(mData.mSession.mID);
3884	if (vrc2 == VERR_NOT_FOUND) /* Not finding the session anymore isn't critical. */
3885	vrc2 = VINF_SUCCESS;
3886
3887	if (RT_SUCCESS(vrc))
3888	vrc = vrc2;
3889
3890	LogFlowThisFunc(("Returning vrc=%Rrc, vrcGuest=%Rrc\n", vrc, vrcGuest));
3891
3892	if (RT_FAILURE(vrc))
3893	{
3894	if (vrc == VERR_GSTCTL_GUEST_ERROR)
3895	{
3896	GuestErrorInfo ge(GuestErrorInfo::Type_Session, vrcGuest, mData.mSession.mName.c_str());
3897	return setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest, tr("Closing guest session failed: %s"),
3898	GuestBase::getErrorAsString(ge).c_str());
3899	}
3900	return setError(VBOX_E_IPRT_ERROR, tr("Closing guest session \"%s\" failed with %Rrc"),
3901	mData.mSession.mName.c_str(), vrc);
3902	}
3903
3904	return S_OK;
3905	}
3906
3907	HRESULT GuestSession::fileCopy(const com::Utf8Str &aSource, const com::Utf8Str &aDestination,
3908	const std::vector<FileCopyFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
3909	{
3910	RT_NOREF(aSource, aDestination, aFlags, aProgress);
3911	ReturnComNotImplemented();
3912	}
3913
3914	HRESULT GuestSession::fileCopyFromGuest(const com::Utf8Str &aSource, const com::Utf8Str &aDestination,
3915	const std::vector<FileCopyFlag_T> &aFlags,
3916	ComPtr<IProgress> &aProgress)
3917	{
3918	uint32_t fFlags = FileCopyFlag_None;
3919	if (aFlags.size())
3920	{
3921	for (size_t i = 0; i < aFlags.size(); i++)
3922	fFlags \|= aFlags[i];
3923
3924	const uint32_t fValidFlags = FileCopyFlag_None \| FileCopyFlag_NoReplace \| FileCopyFlag_FollowLinks \| FileCopyFlag_Update;
3925	if (fFlags & ~fValidFlags)
3926	return setError(E_INVALIDARG,tr("Unknown flags: flags value %#x, invalid: %#x"), fFlags, fFlags & ~fValidFlags);
3927	}
3928
3929	GuestSessionFsSourceSet SourceSet;
3930
3931	GuestSessionFsSourceSpec source;
3932	source.strSource = aSource;
3933	source.enmType = FsObjType_File;
3934	source.enmPathStyle = i_getGuestPathStyle();
3935	source.fDryRun = false; /** @todo Implement support for a dry run. */
3936	source.fDirCopyFlags = DirectoryCopyFlag_None;
3937	source.fFileCopyFlags = (FileCopyFlag_T)fFlags;
3938
3939	SourceSet.push_back(source);
3940
3941	return i_copyFromGuest(SourceSet, aDestination, aProgress);
3942	}
3943
3944	HRESULT GuestSession::fileCopyToGuest(const com::Utf8Str &aSource, const com::Utf8Str &aDestination,
3945	const std::vector<FileCopyFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
3946	{
3947	uint32_t fFlags = FileCopyFlag_None;
3948	if (aFlags.size())
3949	{
3950	for (size_t i = 0; i < aFlags.size(); i++)
3951	fFlags \|= aFlags[i];
3952
3953	const uint32_t fValidFlags = FileCopyFlag_None \| FileCopyFlag_NoReplace \| FileCopyFlag_FollowLinks \| FileCopyFlag_Update;
3954	if (fFlags & ~fValidFlags)
3955	return setError(E_INVALIDARG,tr("Unknown flags: flags value %#x, invalid: %#x"), fFlags, fFlags & ~fValidFlags);
3956	}
3957
3958	GuestSessionFsSourceSet SourceSet;
3959
3960	GuestSessionFsSourceSpec source;
3961	source.strSource = aSource;
3962	source.enmType = FsObjType_File;
3963	source.enmPathStyle = GuestSession::i_getHostPathStyle();
3964	source.fDryRun = false; /** @todo Implement support for a dry run. */
3965	source.fDirCopyFlags = DirectoryCopyFlag_None;
3966	source.fFileCopyFlags = (FileCopyFlag_T)fFlags;
3967
3968	SourceSet.push_back(source);
3969
3970	return i_copyToGuest(SourceSet, aDestination, aProgress);
3971	}
3972
3973	HRESULT GuestSession::copyFromGuest(const std::vector<com::Utf8Str> &aSources, const std::vector<com::Utf8Str> &aFilters,
3974	const std::vector<com::Utf8Str> &aFlags, const com::Utf8Str &aDestination,
3975	ComPtr<IProgress> &aProgress)
3976	{
3977	const size_t cSources = aSources.size();
3978	if ( (aFilters.size() && aFilters.size() != cSources)
3979	\|\| (aFlags.size() && aFlags.size() != cSources))
3980	{
3981	return setError(E_INVALIDARG, tr("Parameter array sizes don't match to the number of sources specified"));
3982	}
3983
3984	GuestSessionFsSourceSet SourceSet;
3985
3986	std::vector<com::Utf8Str>::const_iterator itSource = aSources.begin();
3987	std::vector<com::Utf8Str>::const_iterator itFilter = aFilters.begin();
3988	std::vector<com::Utf8Str>::const_iterator itFlags = aFlags.begin();
3989
3990	const bool fContinueOnErrors = false; /** @todo Do we want a flag for that? */
3991	const bool fFollowSymlinks = true; /** @todo Ditto. */
3992
3993	while (itSource != aSources.end())
3994	{
3995	GuestFsObjData objData;
3996	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
3997	int vrc = i_fsObjQueryInfo(*(itSource), fFollowSymlinks, objData, &vrcGuest);
3998	if ( RT_FAILURE(vrc)
3999	&& !fContinueOnErrors)
4000	{
4001	if (GuestProcess::i_isGuestError(vrc))
4002	{
4003	GuestErrorInfo ge(GuestErrorInfo::Type_Process, vrcGuest, (*itSource).c_str());
4004	return setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest, tr("Querying type for guest source failed: %s"),
4005	GuestBase::getErrorAsString(ge).c_str());
4006	}
4007	return setError(E_FAIL, tr("Querying type for guest source \"%s\" failed: %Rrc"), (*itSource).c_str(), vrc);
4008	}
4009
4010	Utf8Str strFlags;
4011	if (itFlags != aFlags.end())
4012	{
4013	strFlags = *itFlags;
4014	++itFlags;
4015	}
4016
4017	Utf8Str strFilter;
4018	if (itFilter != aFilters.end())
4019	{
4020	strFilter = *itFilter;
4021	++itFilter;
4022	}
4023
4024	GuestSessionFsSourceSpec source;
4025	source.strSource = *itSource;
4026	source.strFilter = strFilter;
4027	source.enmType = objData.mType;
4028	source.enmPathStyle = i_getGuestPathStyle();
4029	source.fDryRun = false; /** @todo Implement support for a dry run. */
4030
4031	/* Check both flag groups here, as copying a directory also could mean to explicitly
4032	* not replacing any existing files (or just copy files which are newer, for instance). */
4033	GuestSession::i_directoryCopyFlagFromStr(strFlags, false /* fStrict */, &source.fDirCopyFlags);
4034	GuestSession::i_fileCopyFlagFromStr(strFlags, false /* fStrict */, &source.fFileCopyFlags);
4035
4036	SourceSet.push_back(source);
4037
4038	++itSource;
4039	}
4040
4041	return i_copyFromGuest(SourceSet, aDestination, aProgress);
4042	}
4043
4044	HRESULT GuestSession::copyToGuest(const std::vector<com::Utf8Str> &aSources, const std::vector<com::Utf8Str> &aFilters,
4045	const std::vector<com::Utf8Str> &aFlags, const com::Utf8Str &aDestination,
4046	ComPtr<IProgress> &aProgress)
4047	{
4048	const size_t cSources = aSources.size();
4049	if ( (aFilters.size() && aFilters.size() != cSources)
4050	\|\| (aFlags.size() && aFlags.size() != cSources))
4051	{
4052	return setError(E_INVALIDARG, tr("Parameter array sizes don't match to the number of sources specified"));
4053	}
4054
4055	GuestSessionFsSourceSet SourceSet;
4056
4057	std::vector<com::Utf8Str>::const_iterator itSource = aSources.begin();
4058	std::vector<com::Utf8Str>::const_iterator itFilter = aFilters.begin();
4059	std::vector<com::Utf8Str>::const_iterator itFlags = aFlags.begin();
4060
4061	const bool fContinueOnErrors = false; /** @todo Do we want a flag for that? */
4062
4063	while (itSource != aSources.end())
4064	{
4065	RTFSOBJINFO objInfo;
4066	int vrc = RTPathQueryInfo((*itSource).c_str(), &objInfo, RTFSOBJATTRADD_NOTHING);
4067	if ( RT_FAILURE(vrc)
4068	&& !fContinueOnErrors)
4069	{
4070	return setError(E_FAIL, tr("Unable to query type for source '%s' (%Rrc)"), (*itSource).c_str(), vrc);
4071	}
4072
4073	Utf8Str strFlags;
4074	if (itFlags != aFlags.end())
4075	{
4076	strFlags = *itFlags;
4077	++itFlags;
4078	}
4079
4080	Utf8Str strFilter;
4081	if (itFilter != aFilters.end())
4082	{
4083	strFilter = *itFilter;
4084	++itFilter;
4085	}
4086
4087	GuestSessionFsSourceSpec source;
4088	source.strSource = *itSource;
4089	source.strFilter = strFilter;
4090	source.enmType = GuestBase::fileModeToFsObjType(objInfo.Attr.fMode);
4091	source.enmPathStyle = GuestSession::i_getHostPathStyle();
4092	source.fDryRun = false; /** @todo Implement support for a dry run. */
4093
4094	GuestSession::i_directoryCopyFlagFromStr(strFlags, false /* fStrict */, &source.fDirCopyFlags);
4095	GuestSession::i_fileCopyFlagFromStr(strFlags, false /* fStrict */, &source.fFileCopyFlags);
4096
4097	SourceSet.push_back(source);
4098
4099	++itSource;
4100	}
4101
4102	/* (Re-)Validate stuff. */
4103	if (RT_UNLIKELY(SourceSet.size() == 0)) /* At least one source must be present. */
4104	return setError(E_INVALIDARG, tr("No sources specified"));
4105	if (RT_UNLIKELY(SourceSet[0].strSource.isEmpty()))
4106	return setError(E_INVALIDARG, tr("First source entry is empty"));
4107	if (RT_UNLIKELY(aDestination.isEmpty()))
4108	return setError(E_INVALIDARG, tr("No destination specified"));
4109
4110	return i_copyToGuest(SourceSet, aDestination, aProgress);
4111	}
4112
4113	HRESULT GuestSession::directoryCopy(const com::Utf8Str &aSource, const com::Utf8Str &aDestination,
4114	const std::vector<DirectoryCopyFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
4115	{
4116	RT_NOREF(aSource, aDestination, aFlags, aProgress);
4117	ReturnComNotImplemented();
4118	}
4119
4120	HRESULT GuestSession::directoryCopyFromGuest(const com::Utf8Str &aSource, const com::Utf8Str &aDestination,
4121	const std::vector<DirectoryCopyFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
4122	{
4123	uint32_t fFlags = DirectoryCopyFlag_None;
4124	if (aFlags.size())
4125	{
4126	for (size_t i = 0; i < aFlags.size(); i++)
4127	fFlags \|= aFlags[i];
4128
4129	const uint32_t fValidFlags = DirectoryCopyFlag_None \| DirectoryCopyFlag_CopyIntoExisting \| DirectoryCopyFlag_Recursive
4130	\| DirectoryCopyFlag_FollowLinks;
4131	if (fFlags & ~fValidFlags)
4132	return setError(E_INVALIDARG,tr("Unknown flags: flags value %#x, invalid: %#x"), fFlags, fFlags & ~fValidFlags);
4133	}
4134
4135	GuestSessionFsSourceSet SourceSet;
4136
4137	GuestSessionFsSourceSpec source;
4138	source.strSource = aSource;
4139	source.enmType = FsObjType_Directory;
4140	source.enmPathStyle = i_getGuestPathStyle();
4141	source.fDryRun = false; /** @todo Implement support for a dry run. */
4142	source.fDirCopyFlags = (DirectoryCopyFlag_T)fFlags;
4143	source.fFileCopyFlags = FileCopyFlag_None; /* Overwrite existing files. */
4144
4145	SourceSet.push_back(source);
4146
4147	return i_copyFromGuest(SourceSet, aDestination, aProgress);
4148	}
4149
4150	HRESULT GuestSession::directoryCopyToGuest(const com::Utf8Str &aSource, const com::Utf8Str &aDestination,
4151	const std::vector<DirectoryCopyFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
4152	{
4153	uint32_t fFlags = DirectoryCopyFlag_None;
4154	if (aFlags.size())
4155	{
4156	for (size_t i = 0; i < aFlags.size(); i++)
4157	fFlags \|= aFlags[i];
4158
4159	const uint32_t fValidFlags = DirectoryCopyFlag_None \| DirectoryCopyFlag_CopyIntoExisting \| DirectoryCopyFlag_Recursive
4160	\| DirectoryCopyFlag_FollowLinks;
4161	if (fFlags & ~fValidFlags)
4162	return setError(E_INVALIDARG,tr("Unknown flags: flags value %#x, invalid: %#x"), fFlags, fFlags & ~fValidFlags);
4163	}
4164
4165	GuestSessionFsSourceSet SourceSet;
4166
4167	GuestSessionFsSourceSpec source;
4168	source.strSource = aSource;
4169	source.enmType = FsObjType_Directory;
4170	source.enmPathStyle = GuestSession::i_getHostPathStyle();
4171	source.fDryRun = false; /** @todo Implement support for a dry run. */
4172	source.fDirCopyFlags = (DirectoryCopyFlag_T)fFlags;
4173	source.fFileCopyFlags = FileCopyFlag_None; /* Overwrite existing files. */
4174
4175	SourceSet.push_back(source);
4176
4177	return i_copyToGuest(SourceSet, aDestination, aProgress);
4178	}
4179
4180	HRESULT GuestSession::directoryCreate(const com::Utf8Str &aPath, ULONG aMode,
4181	const std::vector<DirectoryCreateFlag_T> &aFlags)
4182	{
4183	if (RT_UNLIKELY((aPath.c_str()) == NULL \|\| *(aPath.c_str()) == '\0'))
4184	return setError(E_INVALIDARG, tr("No directory to create specified"));
4185
4186	uint32_t fFlags = DirectoryCreateFlag_None;
4187	if (aFlags.size())
4188	{
4189	for (size_t i = 0; i < aFlags.size(); i++)
4190	fFlags \|= aFlags[i];
4191
4192	if (fFlags & ~DirectoryCreateFlag_Parents)
4193	return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), fFlags);
4194	}
4195
4196	HRESULT hrc = i_isStartedExternal();
4197	if (FAILED(hrc))
4198	return hrc;
4199
4200	LogFlowThisFuncEnter();
4201
4202	ComObjPtr <GuestDirectory> pDirectory;
4203	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
4204	int vrc = i_directoryCreate(aPath, (uint32_t)aMode, fFlags, &vrcGuest);
4205	if (RT_FAILURE(vrc))
4206	{
4207	if (GuestProcess::i_isGuestError(vrc))
4208	{
4209	GuestErrorInfo ge(GuestErrorInfo::Type_Directory, vrcGuest, aPath.c_str());
4210	return setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest, tr("Guest directory creation failed: %s"),
4211	GuestBase::getErrorAsString(ge).c_str());
4212	}
4213	switch (vrc)
4214	{
4215	case VERR_INVALID_PARAMETER:
4216	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Guest directory creation failed: Invalid parameters given"));
4217	break;
4218
4219	case VERR_BROKEN_PIPE:
4220	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Guest directory creation failed: Unexpectedly aborted"));
4221	break;
4222
4223	default:
4224	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Guest directory creation failed: %Rrc"), vrc);
4225	break;
4226	}
4227	}
4228
4229	return hrc;
4230	}
4231
4232	HRESULT GuestSession::directoryCreateTemp(const com::Utf8Str &aTemplateName, ULONG aMode, const com::Utf8Str &aPath,
4233	BOOL aSecure, com::Utf8Str &aDirectory)
4234	{
4235	if (RT_UNLIKELY((aTemplateName.c_str()) == NULL \|\| *(aTemplateName.c_str()) == '\0'))
4236	return setError(E_INVALIDARG, tr("No template specified"));
4237	if (RT_UNLIKELY((aPath.c_str()) == NULL \|\| *(aPath.c_str()) == '\0'))
4238	return setError(E_INVALIDARG, tr("No directory name specified"));
4239	if (!aSecure) /* Ignore what mode is specified when a secure temp thing needs to be created. */
4240	if (RT_UNLIKELY(aMode & ~07777))
4241	return setError(E_INVALIDARG, tr("Mode invalid (must be specified in octal mode)"));
4242
4243	HRESULT hrc = i_isStartedExternal();
4244	if (FAILED(hrc))
4245	return hrc;
4246
4247	LogFlowThisFuncEnter();
4248
4249	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
4250	int vrc = i_fsCreateTemp(aTemplateName, aPath, true /* Directory */, aDirectory, aMode, RT_BOOL(aSecure), &vrcGuest);
4251	if (!RT_SUCCESS(vrc))
4252	{
4253	switch (vrc)
4254	{
4255	case VERR_GSTCTL_GUEST_ERROR:
4256	{
4257	GuestErrorInfo ge(GuestErrorInfo::Type_Fs, vrcGuest, aPath.c_str());
4258	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest, tr("Temporary guest directory creation failed: %s"),
4259	GuestBase::getErrorAsString(ge).c_str());
4260	break;
4261	}
4262	default:
4263	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Temporary guest directory creation \"%s\" with template \"%s\" failed: %Rrc"),
4264	aPath.c_str(), aTemplateName.c_str(), vrc);
4265	break;
4266	}
4267	}
4268
4269	return hrc;
4270	}
4271
4272	HRESULT GuestSession::directoryExists(const com::Utf8Str &aPath, BOOL aFollowSymlinks, BOOL *aExists)
4273	{
4274	if (RT_UNLIKELY(aPath.isEmpty()))
4275	return setError(E_INVALIDARG, tr("Empty path"));
4276
4277	HRESULT hrc = i_isStartedExternal();
4278	if (FAILED(hrc))
4279	return hrc;
4280
4281	LogFlowThisFuncEnter();
4282
4283	GuestFsObjData objData;
4284	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
4285
4286	int vrc = i_directoryQueryInfo(aPath, aFollowSymlinks != FALSE, objData, &vrcGuest);
4287	if (RT_SUCCESS(vrc))
4288	*aExists = TRUE;
4289	else
4290	{
4291	switch (vrc)
4292	{
4293	case VERR_GSTCTL_GUEST_ERROR:
4294	{
4295	switch (vrcGuest)
4296	{
4297	case VERR_PATH_NOT_FOUND:
4298	*aExists = FALSE;
4299	break;
4300	default:
4301	{
4302	GuestErrorInfo ge(GuestErrorInfo::Type_Fs, vrcGuest, aPath.c_str());
4303	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest, tr("Querying directory existence failed: %s"),
4304	GuestBase::getErrorAsString(ge).c_str());
4305	break;
4306	}
4307	}
4308	break;
4309	}
4310
4311	case VERR_NOT_A_DIRECTORY:
4312	{
4313	*aExists = FALSE;
4314	break;
4315	}
4316
4317	default:
4318	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Querying directory existence \"%s\" failed: %Rrc"),
4319	aPath.c_str(), vrc);
4320	break;
4321	}
4322	}
4323
4324	return hrc;
4325	}
4326
4327	HRESULT GuestSession::directoryOpen(const com::Utf8Str &aPath, const com::Utf8Str &aFilter,
4328	const std::vector<DirectoryOpenFlag_T> &aFlags, ComPtr<IGuestDirectory> &aDirectory)
4329	{
4330	if (RT_UNLIKELY((aPath.c_str()) == NULL \|\| *(aPath.c_str()) == '\0'))
4331	return setError(E_INVALIDARG, tr("No directory to open specified"));
4332	if (RT_UNLIKELY((aFilter.c_str()) != NULL && *(aFilter.c_str()) != '\0'))
4333	return setError(E_INVALIDARG, tr("Directory filters are not implemented yet"));
4334
4335	uint32_t fFlags = DirectoryOpenFlag_None;
4336	if (aFlags.size())
4337	{
4338	for (size_t i = 0; i < aFlags.size(); i++)
4339	fFlags \|= aFlags[i];
4340
4341	if (fFlags)
4342	return setError(E_INVALIDARG, tr("Open flags (%#x) not implemented yet"), fFlags);
4343	}
4344
4345	HRESULT hrc = i_isStartedExternal();
4346	if (FAILED(hrc))
4347	return hrc;
4348
4349	LogFlowThisFuncEnter();
4350
4351	GuestDirectoryOpenInfo openInfo;
4352	openInfo.mPath = aPath;
4353	openInfo.mFilter = aFilter;
4354	openInfo.mFlags = fFlags;
4355
4356	ComObjPtr<GuestDirectory> pDirectory;
4357	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
4358	int vrc = i_directoryOpen(openInfo, pDirectory, &vrcGuest);
4359	if (RT_SUCCESS(vrc))
4360	{
4361	/* Return directory object to the caller. */
4362	hrc = pDirectory.queryInterfaceTo(aDirectory.asOutParam());
4363	}
4364	else
4365	{
4366	switch (vrc)
4367	{
4368	case VERR_INVALID_PARAMETER:
4369	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Opening guest directory \"%s\" failed; invalid parameters given"),
4370	aPath.c_str());
4371	break;
4372
4373	case VERR_GSTCTL_GUEST_ERROR:
4374	{
4375	GuestErrorInfo ge(GuestErrorInfo::Type_Directory, vrcGuest, aPath.c_str());
4376	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest, tr("Opening guest directory failed: %s"),
4377	GuestBase::getErrorAsString(ge).c_str());
4378	break;
4379	}
4380	default:
4381	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Opening guest directory \"%s\" failed: %Rrc"), aPath.c_str(), vrc);
4382	break;
4383	}
4384	}
4385
4386	return hrc;
4387	}
4388
4389	HRESULT GuestSession::directoryRemove(const com::Utf8Str &aPath)
4390	{
4391	if (RT_UNLIKELY(aPath.c_str() == NULL \|\| *aPath.c_str() == '\0'))
4392	return setError(E_INVALIDARG, tr("No directory to remove specified"));
4393
4394	HRESULT hrc = i_isStartedExternal();
4395	if (FAILED(hrc))
4396	return hrc;
4397
4398	LogFlowThisFuncEnter();
4399
4400	/* No flags; only remove the directory when empty. */
4401	uint32_t fFlags = DIRREMOVEREC_FLAG_NONE;
4402
4403	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
4404	int vrc = i_directoryRemove(aPath, fFlags, &vrcGuest);
4405	if (RT_FAILURE(vrc))
4406	{
4407	switch (vrc)
4408	{
4409	case VERR_NOT_SUPPORTED:
4410	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
4411	tr("Handling removing guest directories not supported by installed Guest Additions"));
4412	break;
4413
4414	case VERR_GSTCTL_GUEST_ERROR:
4415	{
4416	GuestErrorInfo ge(GuestErrorInfo::Type_Directory, vrcGuest, aPath.c_str());
4417	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest, tr("Removing guest directory failed: %s"),
4418	GuestBase::getErrorAsString(ge).c_str());
4419	break;
4420	}
4421	default:
4422	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Removing guest directory \"%s\" failed: %Rrc"), aPath.c_str(), vrc);
4423	break;
4424	}
4425	}
4426
4427	return hrc;
4428	}
4429
4430	HRESULT GuestSession::directoryRemoveRecursive(const com::Utf8Str &aPath, const std::vector<DirectoryRemoveRecFlag_T> &aFlags,
4431	ComPtr<IProgress> &aProgress)
4432	{
4433	if (RT_UNLIKELY(aPath.c_str() == NULL \|\| *aPath.c_str() == '\0'))
4434	return setError(E_INVALIDARG, tr("No directory to remove recursively specified"));
4435
4436	/* By defautl remove recursively as the function name implies. */
4437	uint32_t fFlags = DIRREMOVEREC_FLAG_RECURSIVE;
4438	if (aFlags.size())
4439	{
4440	for (size_t i = 0; i < aFlags.size(); i++)
4441	{
4442	switch (aFlags[i])
4443	{
4444	case DirectoryRemoveRecFlag_None: /* Skip. */
4445	continue;
4446
4447	case DirectoryRemoveRecFlag_ContentAndDir:
4448	fFlags \|= DIRREMOVEREC_FLAG_CONTENT_AND_DIR;
4449	break;
4450
4451	case DirectoryRemoveRecFlag_ContentOnly:
4452	fFlags \|= DIRREMOVEREC_FLAG_CONTENT_ONLY;
4453	break;
4454
4455	default:
4456	return setError(E_INVALIDARG, tr("Invalid flags specified"));
4457	}
4458	}
4459	}
4460
4461	HRESULT hrc = i_isStartedExternal();
4462	if (FAILED(hrc))
4463	return hrc;
4464
4465	LogFlowThisFuncEnter();
4466
4467	ComObjPtr<Progress> pProgress;
4468	hrc = pProgress.createObject();
4469	if (SUCCEEDED(hrc))
4470	hrc = pProgress->init(static_cast<IGuestSession *>(this),
4471	Bstr(tr("Removing guest directory")).raw(),
4472	TRUE /aCancelable/);
4473	if (FAILED(hrc))
4474	return hrc;
4475
4476	/* Note: At the moment we don't supply progress information while
4477	* deleting a guest directory recursively. So just complete
4478	* the progress object right now. */
4479	/** @todo Implement progress reporting on guest directory deletion! */
4480	hrc = pProgress->i_notifyComplete(S_OK);
4481	if (FAILED(hrc))
4482	return hrc;
4483
4484	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
4485	int vrc = i_directoryRemove(aPath, fFlags, &vrcGuest);
4486	if (RT_FAILURE(vrc))
4487	{
4488	switch (vrc)
4489	{
4490	case VERR_NOT_SUPPORTED:
4491	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
4492	tr("Handling removing guest directories recursively not supported by installed Guest Additions"));
4493	break;
4494
4495	case VERR_GSTCTL_GUEST_ERROR:
4496	{
4497	GuestErrorInfo ge(GuestErrorInfo::Type_Directory, vrcGuest, aPath.c_str());
4498	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest, tr("Recursively removing guest directory failed: %s"),
4499	GuestBase::getErrorAsString(ge).c_str());
4500	break;
4501	}
4502	default:
4503	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Recursively removing guest directory \"%s\" failed: %Rrc"),
4504	aPath.c_str(), vrc);
4505	break;
4506	}
4507	}
4508	else
4509	{
4510	pProgress.queryInterfaceTo(aProgress.asOutParam());
4511	}
4512
4513	return hrc;
4514	}
4515
4516	HRESULT GuestSession::environmentScheduleSet(const com::Utf8Str &aName, const com::Utf8Str &aValue)
4517	{
4518	LogFlowThisFuncEnter();
4519	int vrc;
4520	{
4521	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4522	vrc = mData.mEnvironmentChanges.setVariable(aName, aValue);
4523	}
4524	HRESULT hrc;
4525	if (RT_SUCCESS(vrc))
4526	hrc = S_OK;
4527	else if (vrc == VERR_ENV_INVALID_VAR_NAME)
4528	hrc = setError(E_INVALIDARG, tr("Invalid environment variable name '%s'"), aName.c_str());
4529	else
4530	hrc = setErrorVrc(vrc, tr("Failed to schedule setting environment variable '%s' to '%s'"), aName.c_str(), aValue.c_str());
4531
4532	LogFlowThisFuncLeave();
4533	return hrc;
4534	}
4535
4536	HRESULT GuestSession::environmentScheduleUnset(const com::Utf8Str &aName)
4537	{
4538	LogFlowThisFuncEnter();
4539	int vrc;
4540	{
4541	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4542	vrc = mData.mEnvironmentChanges.unsetVariable(aName);
4543	}
4544	HRESULT hrc;
4545	if (RT_SUCCESS(vrc))
4546	hrc = S_OK;
4547	else if (vrc == VERR_ENV_INVALID_VAR_NAME)
4548	hrc = setError(E_INVALIDARG, tr("Invalid environment variable name '%s'"), aName.c_str());
4549	else
4550	hrc = setErrorVrc(vrc, tr("Failed to schedule unsetting environment variable '%s'"), aName.c_str());
4551
4552	LogFlowThisFuncLeave();
4553	return hrc;
4554	}
4555
4556	HRESULT GuestSession::environmentGetBaseVariable(const com::Utf8Str &aName, com::Utf8Str &aValue)
4557	{
4558	LogFlowThisFuncEnter();
4559	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4560
4561	HRESULT hrc;
4562	if (mData.mpBaseEnvironment)
4563	{
4564	int vrc = mData.mpBaseEnvironment->getVariable(aName, &aValue);
4565	if (RT_SUCCESS(vrc))
4566	hrc = S_OK;
4567	else if (vrc == VERR_ENV_INVALID_VAR_NAME)
4568	hrc = setError(E_INVALIDARG, tr("Invalid environment variable name '%s'"), aName.c_str());
4569	else
4570	hrc = setErrorVrc(vrc);
4571	}
4572	else if (mData.mProtocolVersion < 99999)
4573	hrc = setError(VBOX_E_NOT_SUPPORTED, tr("The base environment feature is not supported by the Guest Additions"));
4574	else
4575	hrc = setError(VBOX_E_INVALID_OBJECT_STATE, tr("The base environment has not yet been reported by the guest"));
4576
4577	LogFlowThisFuncLeave();
4578	return hrc;
4579	}
4580
4581	HRESULT GuestSession::environmentDoesBaseVariableExist(const com::Utf8Str &aName, BOOL *aExists)
4582	{
4583	LogFlowThisFuncEnter();
4584	*aExists = FALSE;
4585	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4586
4587	HRESULT hrc;
4588	if (mData.mpBaseEnvironment)
4589	{
4590	hrc = S_OK;
4591	*aExists = mData.mpBaseEnvironment->doesVariableExist(aName);
4592	}
4593	else if (mData.mProtocolVersion < 99999)
4594	hrc = setError(VBOX_E_NOT_SUPPORTED, tr("The base environment feature is not supported by the Guest Additions"));
4595	else
4596	hrc = setError(VBOX_E_INVALID_OBJECT_STATE, tr("The base environment has not yet been reported by the guest"));
4597
4598	LogFlowThisFuncLeave();
4599	return hrc;
4600	}
4601
4602	HRESULT GuestSession::fileCreateTemp(const com::Utf8Str &aTemplateName, ULONG aMode, const com::Utf8Str &aPath, BOOL aSecure,
4603	ComPtr<IGuestFile> &aFile)
4604	{
4605	RT_NOREF(aTemplateName, aMode, aPath, aSecure, aFile);
4606	ReturnComNotImplemented();
4607	}
4608
4609	HRESULT GuestSession::fileExists(const com::Utf8Str &aPath, BOOL aFollowSymlinks, BOOL *aExists)
4610	{
4611	/* By default we return non-existent. */
4612	*aExists = FALSE;
4613
4614	if (RT_UNLIKELY((aPath.c_str()) == NULL \|\| *(aPath.c_str()) == '\0'))
4615	return S_OK;
4616
4617	HRESULT hrc = i_isStartedExternal();
4618	if (FAILED(hrc))
4619	return hrc;
4620
4621	LogFlowThisFuncEnter();
4622
4623	GuestFsObjData objData;
4624	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
4625	int vrc = i_fileQueryInfo(aPath, RT_BOOL(aFollowSymlinks), objData, &vrcGuest);
4626	if (RT_SUCCESS(vrc))
4627	{
4628	*aExists = TRUE;
4629	return S_OK;
4630	}
4631
4632	switch (vrc)
4633	{
4634	case VERR_GSTCTL_GUEST_ERROR:
4635	{
4636	switch (vrcGuest)
4637	{
4638	case VERR_PATH_NOT_FOUND:
4639	RT_FALL_THROUGH();
4640	case VERR_FILE_NOT_FOUND:
4641	break;
4642
4643	default:
4644	{
4645	GuestErrorInfo ge(GuestErrorInfo::Type_Fs, vrcGuest, aPath.c_str());
4646	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest, tr("Querying guest file existence failed: %s"),
4647	GuestBase::getErrorAsString(ge).c_str());
4648	break;
4649	}
4650	}
4651
4652	break;
4653	}
4654
4655	case VERR_NOT_A_FILE:
4656	break;
4657
4658	default:
4659	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Querying guest file information for \"%s\" failed: %Rrc"),
4660	aPath.c_str(), vrc);
4661	break;
4662	}
4663
4664	return hrc;
4665	}
4666
4667	HRESULT GuestSession::fileOpen(const com::Utf8Str &aPath, FileAccessMode_T aAccessMode, FileOpenAction_T aOpenAction,
4668	ULONG aCreationMode, ComPtr<IGuestFile> &aFile)
4669	{
4670	LogFlowThisFuncEnter();
4671
4672	const std::vector<FileOpenExFlag_T> EmptyFlags;
4673	return fileOpenEx(aPath, aAccessMode, aOpenAction, FileSharingMode_All, aCreationMode, EmptyFlags, aFile);
4674	}
4675
4676	HRESULT GuestSession::fileOpenEx(const com::Utf8Str &aPath, FileAccessMode_T aAccessMode, FileOpenAction_T aOpenAction,
4677	FileSharingMode_T aSharingMode, ULONG aCreationMode,
4678	const std::vector<FileOpenExFlag_T> &aFlags, ComPtr<IGuestFile> &aFile)
4679	{
4680	if (RT_UNLIKELY((aPath.c_str()) == NULL \|\| *(aPath.c_str()) == '\0'))
4681	return setError(E_INVALIDARG, tr("No file to open specified"));
4682
4683	HRESULT hrc = i_isStartedExternal();
4684	if (FAILED(hrc))
4685	return hrc;
4686
4687	LogFlowThisFuncEnter();
4688
4689	/* Validate aAccessMode. */
4690	switch (aAccessMode)
4691	{
4692	case FileAccessMode_ReadOnly:
4693	RT_FALL_THRU();
4694	case FileAccessMode_WriteOnly:
4695	RT_FALL_THRU();
4696	case FileAccessMode_ReadWrite:
4697	break;
4698	case FileAccessMode_AppendOnly:
4699	RT_FALL_THRU();
4700	case FileAccessMode_AppendRead:
4701	return setError(E_NOTIMPL, tr("Append access modes are not yet implemented"));
4702	default:
4703	return setError(E_INVALIDARG, tr("Unknown FileAccessMode value %u (%#x)"), aAccessMode, aAccessMode);
4704	}
4705
4706	/* Validate aOpenAction to the old format. */
4707	switch (aOpenAction)
4708	{
4709	case FileOpenAction_OpenExisting:
4710	RT_FALL_THRU();
4711	case FileOpenAction_OpenOrCreate:
4712	RT_FALL_THRU();
4713	case FileOpenAction_CreateNew:
4714	RT_FALL_THRU();
4715	case FileOpenAction_CreateOrReplace:
4716	RT_FALL_THRU();
4717	case FileOpenAction_OpenExistingTruncated:
4718	RT_FALL_THRU();
4719	case FileOpenAction_AppendOrCreate:
4720	break;
4721	default:
4722	return setError(E_INVALIDARG, tr("Unknown FileOpenAction value %u (%#x)"), aAccessMode, aAccessMode);
4723	}
4724
4725	/* Validate aSharingMode. */
4726	switch (aSharingMode)
4727	{
4728	case FileSharingMode_All:
4729	break;
4730	case FileSharingMode_Read:
4731	case FileSharingMode_Write:
4732	case FileSharingMode_ReadWrite:
4733	case FileSharingMode_Delete:
4734	case FileSharingMode_ReadDelete:
4735	case FileSharingMode_WriteDelete:
4736	return setError(E_NOTIMPL, tr("Only FileSharingMode_All is currently implemented"));
4737
4738	default:
4739	return setError(E_INVALIDARG, tr("Unknown FileOpenAction value %u (%#x)"), aAccessMode, aAccessMode);
4740	}
4741
4742	/* Combine and validate flags. */
4743	uint32_t fOpenEx = 0;
4744	for (size_t i = 0; i < aFlags.size(); i++)
4745	fOpenEx \|= aFlags[i];
4746	if (fOpenEx)
4747	return setError(E_INVALIDARG, tr("Unsupported FileOpenExFlag value(s) in aFlags (%#x)"), fOpenEx);
4748
4749	ComObjPtr <GuestFile> pFile;
4750	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
4751	int vrc = i_fileOpenEx(aPath, aAccessMode, aOpenAction, aSharingMode, aCreationMode, aFlags, pFile, &vrcGuest);
4752	if (RT_SUCCESS(vrc))
4753	/* Return directory object to the caller. */
4754	hrc = pFile.queryInterfaceTo(aFile.asOutParam());
4755	else
4756	{
4757	switch (vrc)
4758	{
4759	case VERR_NOT_SUPPORTED:
4760	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
4761	tr("Handling guest files not supported by installed Guest Additions"));
4762	break;
4763
4764	case VERR_GSTCTL_GUEST_ERROR:
4765	{
4766	GuestErrorInfo ge(GuestErrorInfo::Type_File, vrcGuest, aPath.c_str());
4767	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest, tr("Opening guest file failed: %s"),
4768	GuestBase::getErrorAsString(ge).c_str());
4769	break;
4770	}
4771	default:
4772	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Opening guest file \"%s\" failed: %Rrc"), aPath.c_str(), vrc);
4773	break;
4774	}
4775	}
4776
4777	return hrc;
4778	}
4779
4780	HRESULT GuestSession::fileQuerySize(const com::Utf8Str &aPath, BOOL aFollowSymlinks, LONG64 *aSize)
4781	{
4782	if (aPath.isEmpty())
4783	return setError(E_INVALIDARG, tr("No path specified"));
4784
4785	HRESULT hrc = i_isStartedExternal();
4786	if (FAILED(hrc))
4787	return hrc;
4788
4789	int64_t llSize;
4790	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
4791	int vrc = i_fileQuerySize(aPath, aFollowSymlinks != FALSE, &llSize, &vrcGuest);
4792	if (RT_SUCCESS(vrc))
4793	*aSize = llSize;
4794	else
4795	{
4796	if (GuestProcess::i_isGuestError(vrc))
4797	{
4798	GuestErrorInfo ge(GuestErrorInfo::Type_Fs, vrcGuest, aPath.c_str());
4799	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest, tr("Querying guest file size failed: %s"),
4800	GuestBase::getErrorAsString(ge).c_str());
4801	}
4802	else
4803	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Querying guest file size of \"%s\" failed: %Rrc"),
4804	vrc, aPath.c_str());
4805	}
4806
4807	return hrc;
4808	}
4809
4810	HRESULT GuestSession::fsQueryFreeSpace(const com::Utf8Str &aPath, LONG64 *aFreeSpace)
4811	{
4812	ComPtr<IGuestFsInfo> pFsInfo;
4813	HRESULT hrc = fsQueryInfo(aPath, pFsInfo);
4814	if (SUCCEEDED(hrc))
4815	hrc = pFsInfo->COMGETTER(FreeSize)(aFreeSpace);
4816
4817	return hrc;
4818	}
4819
4820	HRESULT GuestSession::fsQueryInfo(const com::Utf8Str &aPath, ComPtr<IGuestFsInfo> &aInfo)
4821	{
4822	if (aPath.isEmpty())
4823	return setError(E_INVALIDARG, tr("No path specified"));
4824
4825	HRESULT hrc = i_isStartedExternal();
4826	if (FAILED(hrc))
4827	return hrc;
4828
4829	GSTCTLFSINFO fsInfo;
4830	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
4831	int vrc = i_fsQueryInfo(aPath, &fsInfo, &vrcGuest);
4832	if (RT_SUCCESS(vrc))
4833	{
4834	ComObjPtr<GuestFsInfo> ptrFsInfo;
4835	hrc = ptrFsInfo.createObject();
4836	if (SUCCEEDED(hrc))
4837	{
4838	vrc = ptrFsInfo->init(&fsInfo);
4839	if (RT_SUCCESS(vrc))
4840	hrc = ptrFsInfo.queryInterfaceTo(aInfo.asOutParam());
4841	else
4842	hrc = setErrorVrc(vrc);
4843	}
4844	}
4845	else
4846	{
4847	if (GuestProcess::i_isGuestError(vrc))
4848	{
4849	GuestErrorInfo ge(GuestErrorInfo::Type_Fs, vrcGuest, aPath.c_str());
4850	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest, tr("Querying guest filesystem information failed: %s"),
4851	GuestBase::getErrorAsString(ge).c_str());
4852	}
4853	else
4854	hrc = setErrorVrc(vrc, tr("Querying guest filesystem information for \"%s\" failed: %Rrc"), aPath.c_str(), vrc);
4855	}
4856
4857	return hrc;
4858	}
4859
4860	HRESULT GuestSession::fsObjExists(const com::Utf8Str &aPath, BOOL aFollowSymlinks, BOOL *aExists)
4861	{
4862	if (aPath.isEmpty())
4863	return setError(E_INVALIDARG, tr("No path specified"));
4864
4865	HRESULT hrc = i_isStartedExternal();
4866	if (FAILED(hrc))
4867	return hrc;
4868
4869	LogFlowThisFunc(("aPath=%s, aFollowSymlinks=%RTbool\n", aPath.c_str(), RT_BOOL(aFollowSymlinks)));
4870
4871	*aExists = false;
4872
4873	GuestFsObjData objData;
4874	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
4875	int vrc = i_fsObjQueryInfo(aPath, aFollowSymlinks != FALSE, objData, &vrcGuest);
4876	if (RT_SUCCESS(vrc))
4877	*aExists = TRUE;
4878	else
4879	{
4880	if (GuestProcess::i_isGuestError(vrc))
4881	{
4882	if ( vrcGuest == VERR_NOT_A_FILE
4883	\|\| vrcGuest == VERR_PATH_NOT_FOUND
4884	\|\| vrcGuest == VERR_FILE_NOT_FOUND
4885	\|\| vrcGuest == VERR_INVALID_NAME)
4886	hrc = S_OK; /* Ignore these vrc values. */
4887	else
4888	{
4889	GuestErrorInfo ge(GuestErrorInfo::Type_Fs, vrcGuest, aPath.c_str());
4890	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest, tr("Querying guest file existence information failed: %s"),
4891	GuestBase::getErrorAsString(ge).c_str());
4892	}
4893	}
4894	else
4895	hrc = setErrorVrc(vrc, tr("Querying guest file existence information for \"%s\" failed: %Rrc"), aPath.c_str(), vrc);
4896	}
4897
4898	return hrc;
4899	}
4900
4901	HRESULT GuestSession::fsObjQueryInfo(const com::Utf8Str &aPath, BOOL aFollowSymlinks, ComPtr<IGuestFsObjInfo> &aInfo)
4902	{
4903	if (aPath.isEmpty())
4904	return setError(E_INVALIDARG, tr("No path specified"));
4905
4906	HRESULT hrc = i_isStartedExternal();
4907	if (FAILED(hrc))
4908	return hrc;
4909
4910	LogFlowThisFunc(("aPath=%s, aFollowSymlinks=%RTbool\n", aPath.c_str(), RT_BOOL(aFollowSymlinks)));
4911
4912	GuestFsObjData objData;
4913	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
4914	int vrc = i_fsObjQueryInfo(aPath, aFollowSymlinks != FALSE, objData, &vrcGuest);
4915	if (RT_SUCCESS(vrc))
4916	{
4917	ComObjPtr<GuestFsObjInfo> ptrFsObjInfo;
4918	hrc = ptrFsObjInfo.createObject();
4919	if (SUCCEEDED(hrc))
4920	{
4921	vrc = ptrFsObjInfo->init(objData);
4922	if (RT_SUCCESS(vrc))
4923	hrc = ptrFsObjInfo.queryInterfaceTo(aInfo.asOutParam());
4924	else
4925	hrc = setErrorVrc(vrc);
4926	}
4927	}
4928	else
4929	{
4930	if (GuestProcess::i_isGuestError(vrc))
4931	{
4932	GuestErrorInfo ge(GuestErrorInfo::Type_Fs, vrcGuest, aPath.c_str());
4933	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest, tr("Querying guest filesystem object information failed: %s"),
4934	GuestBase::getErrorAsString(ge).c_str());
4935	}
4936	else
4937	hrc = setErrorVrc(vrc, tr("Querying guest filesystem object information for \"%s\" failed: %Rrc"), aPath.c_str(), vrc);
4938	}
4939
4940	return hrc;
4941	}
4942
4943	HRESULT GuestSession::fsObjRemove(const com::Utf8Str &aPath)
4944	{
4945	if (RT_UNLIKELY(aPath.isEmpty()))
4946	return setError(E_INVALIDARG, tr("No path specified"));
4947
4948	HRESULT hrc = i_isStartedExternal();
4949	if (FAILED(hrc))
4950	return hrc;
4951
4952	LogFlowThisFunc(("aPath=%s\n", aPath.c_str()));
4953
4954	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
4955	int vrc = i_fileRemove(aPath, &vrcGuest);
4956	if (RT_FAILURE(vrc))
4957	{
4958	if (GuestProcess::i_isGuestError(vrc))
4959	{
4960	GuestErrorInfo ge(GuestErrorInfo::Type_File, vrcGuest, aPath.c_str());
4961	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest, tr("Removing guest file failed: %s"),
4962	GuestBase::getErrorAsString(ge).c_str());
4963	}
4964	else
4965	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Removing guest file \"%s\" failed: %Rrc"), aPath.c_str(), vrc);
4966	}
4967
4968	return hrc;
4969	}
4970
4971	HRESULT GuestSession::fsObjRemoveArray(const std::vector<com::Utf8Str> &aPaths, ComPtr<IProgress> &aProgress)
4972	{
4973	RT_NOREF(aPaths, aProgress);
4974	return E_NOTIMPL;
4975	}
4976
4977	HRESULT GuestSession::fsObjRename(const com::Utf8Str &aSource,
4978	const com::Utf8Str &aDestination,
4979	const std::vector<FsObjRenameFlag_T> &aFlags)
4980	{
4981	if (RT_UNLIKELY(aSource.isEmpty()))
4982	return setError(E_INVALIDARG, tr("No source path specified"));
4983
4984	if (RT_UNLIKELY(aDestination.isEmpty()))
4985	return setError(E_INVALIDARG, tr("No destination path specified"));
4986
4987	HRESULT hrc = i_isStartedExternal();
4988	if (FAILED(hrc))
4989	return hrc;
4990
4991	/* Combine, validate and convert flags. */
4992	uint32_t fApiFlags = 0;
4993	for (size_t i = 0; i < aFlags.size(); i++)
4994	fApiFlags \|= aFlags[i];
4995	if (fApiFlags & ~((uint32_t)FsObjRenameFlag_NoReplace \| (uint32_t)FsObjRenameFlag_Replace))
4996	return setError(E_INVALIDARG, tr("Unknown rename flag: %#x"), fApiFlags);
4997
4998	LogFlowThisFunc(("aSource=%s, aDestination=%s\n", aSource.c_str(), aDestination.c_str()));
4999
5000	AssertCompile(FsObjRenameFlag_NoReplace == 0);
5001	AssertCompile(FsObjRenameFlag_Replace != 0);
5002	uint32_t fBackend;
5003	if ((fApiFlags & ((uint32_t)FsObjRenameFlag_NoReplace \| (uint32_t)FsObjRenameFlag_Replace)) == FsObjRenameFlag_Replace)
5004	fBackend = PATHRENAME_FLAG_REPLACE;
5005	else
5006	fBackend = PATHRENAME_FLAG_NO_REPLACE;
5007
5008	/* Call worker to do the job. */
5009	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
5010	int vrc = i_pathRename(aSource, aDestination, fBackend, &vrcGuest);
5011	if (RT_FAILURE(vrc))
5012	{
5013	switch (vrc)
5014	{
5015	case VERR_NOT_SUPPORTED:
5016	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
5017	tr("Handling renaming guest paths not supported by installed Guest Additions"));
5018	break;
5019
5020	case VERR_GSTCTL_GUEST_ERROR:
5021	{
5022	GuestErrorInfo ge(GuestErrorInfo::Type_Process, vrcGuest, aSource.c_str());
5023	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest, tr("Renaming guest path failed: %s"),
5024	GuestBase::getErrorAsString(ge).c_str());
5025	break;
5026	}
5027	default:
5028	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Renaming guest path \"%s\" failed: %Rrc"),
5029	aSource.c_str(), vrc);
5030	break;
5031	}
5032	}
5033
5034	return hrc;
5035	}
5036
5037	HRESULT GuestSession::fsObjMove(const com::Utf8Str &aSource, const com::Utf8Str &aDestination,
5038	const std::vector<FsObjMoveFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
5039	{
5040	RT_NOREF(aSource, aDestination, aFlags, aProgress);
5041	ReturnComNotImplemented();
5042	}
5043
5044	HRESULT GuestSession::fsObjMoveArray(const std::vector<com::Utf8Str> &aSource,
5045	const com::Utf8Str &aDestination,
5046	const std::vector<FsObjMoveFlag_T> &aFlags,
5047	ComPtr<IProgress> &aProgress)
5048	{
5049	RT_NOREF(aSource, aDestination, aFlags, aProgress);
5050	ReturnComNotImplemented();
5051	}
5052
5053	HRESULT GuestSession::fsObjCopyArray(const std::vector<com::Utf8Str> &aSource,
5054	const com::Utf8Str &aDestination,
5055	const std::vector<FileCopyFlag_T> &aFlags,
5056	ComPtr<IProgress> &aProgress)
5057	{
5058	RT_NOREF(aSource, aDestination, aFlags, aProgress);
5059	ReturnComNotImplemented();
5060	}
5061
5062	HRESULT GuestSession::fsObjSetACL(const com::Utf8Str &aPath, BOOL aFollowSymlinks, const com::Utf8Str &aAcl, ULONG aMode)
5063	{
5064	RT_NOREF(aPath, aFollowSymlinks, aAcl, aMode);
5065	ReturnComNotImplemented();
5066	}
5067
5068
5069	HRESULT GuestSession::processCreate(const com::Utf8Str &aExecutable, const std::vector<com::Utf8Str> &aArguments,
5070	const com::Utf8Str &aCwd,
5071	const std::vector<com::Utf8Str> &aEnvironment,
5072	const std::vector<ProcessCreateFlag_T> &aFlags,
5073	ULONG aTimeoutMS, ComPtr<IGuestProcess> &aGuestProcess)
5074	{
5075	LogFlowThisFuncEnter();
5076
5077	std::vector<LONG> affinityIgnored;
5078	return processCreateEx(aExecutable, aArguments, aCwd, aEnvironment, aFlags, aTimeoutMS,
5079	ProcessPriority_Default, affinityIgnored, aGuestProcess);
5080	}
5081
5082	HRESULT GuestSession::processCreateEx(const com::Utf8Str &aExecutable, const std::vector<com::Utf8Str> &aArguments,
5083	const com::Utf8Str &aCwd,
5084	const std::vector<com::Utf8Str> &aEnvironment,
5085	const std::vector<ProcessCreateFlag_T> &aFlags, ULONG aTimeoutMS,
5086	ProcessPriority_T aPriority, const std::vector<LONG> &aAffinity,
5087	ComPtr<IGuestProcess> &aGuestProcess)
5088	{
5089	HRESULT hrc = i_isStartedExternal();
5090	if (FAILED(hrc))
5091	return hrc;
5092
5093	/*
5094	* Must have an executable to execute. If none is given, we try use the
5095	* zero'th argument.
5096	*/
5097	const char *pszExecutable = aExecutable.c_str();
5098	if (RT_UNLIKELY(pszExecutable == NULL \|\| *pszExecutable == '\0'))
5099	{
5100	if (aArguments.size() > 0)
5101	pszExecutable = aArguments[0].c_str();
5102	if (pszExecutable == NULL \|\| *pszExecutable == '\0')
5103	return setError(E_INVALIDARG, tr("No command to execute specified"));
5104	}
5105
5106	uint32_t const uProtocol = i_getProtocolVersion();
5107	uint64_t const fGuestControlFeatures0 = mParent->i_getGuestControlFeatures0();
5108
5109	/* If a current working directory (CWD) is set, make sure that the installed Guest Additions actually
5110	* support this before doing anything else. */
5111	if ( !aCwd.isEmpty()
5112	&& ( uProtocol < 2
5113	\|\| !(fGuestControlFeatures0 & VBOX_GUESTCTRL_GF_0_PROCESS_CWD)))
5114	return setError(VBOX_E_NOT_SUPPORTED,
5115	tr("Setting the current working directory is not supported by the installed Guest Addtions!"));
5116
5117	/* The rest of the input is being validated in i_processCreateEx(). */
5118
5119	LogFlowThisFuncEnter();
5120
5121	/*
5122	* Build the process startup info.
5123	*/
5124	GuestProcessStartupInfo procInfo;
5125
5126	/* Executable and arguments. */
5127	procInfo.mExecutable = pszExecutable;
5128	if (aArguments.size())
5129	{
5130	for (size_t i = 0; i < aArguments.size(); i++)
5131	procInfo.mArguments.push_back(aArguments[i]);
5132	}
5133	else /* If no arguments were given, add the executable as argv[0] by default. */
5134	procInfo.mArguments.push_back(procInfo.mExecutable);
5135
5136	/* Optional working directory */
5137	procInfo.mCwd = aCwd;
5138
5139	/* Combine the environment changes associated with the ones passed in by
5140	the caller, giving priority to the latter. The changes are putenv style
5141	and will be applied to the standard environment for the guest user. */
5142	int vrc = procInfo.mEnvironmentChanges.copy(mData.mEnvironmentChanges);
5143	if (RT_SUCCESS(vrc))
5144	{
5145	size_t idxError = ~(size_t)0;
5146	vrc = procInfo.mEnvironmentChanges.applyPutEnvArray(aEnvironment, &idxError);
5147	if (RT_SUCCESS(vrc))
5148	{
5149	/* Convert the flag array into a mask. */
5150	if (aFlags.size())
5151	for (size_t i = 0; i < aFlags.size(); i++)
5152	procInfo.mFlags \|= aFlags[i];
5153
5154	procInfo.mTimeoutMS = aTimeoutMS;
5155
5156	/** @todo use RTCPUSET instead of archaic 64-bit variables! */
5157	if (aAffinity.size())
5158	for (size_t i = 0; i < aAffinity.size(); i++)
5159	if (aAffinity[i])
5160	procInfo.mAffinity \|= (uint64_t)1 << i;
5161
5162	procInfo.mPriority = aPriority;
5163
5164	/*
5165	* Create a guest process object.
5166	*/
5167	ComObjPtr<GuestProcess> pProcess;
5168	vrc = i_processCreateEx(procInfo, pProcess);
5169	if (RT_SUCCESS(vrc))
5170	{
5171	ComPtr<IGuestProcess> pIProcess;
5172	hrc = pProcess.queryInterfaceTo(pIProcess.asOutParam());
5173	if (SUCCEEDED(hrc))
5174	{
5175	/*
5176	* Start the process.
5177	*/
5178	vrc = pProcess->i_startProcessAsync();
5179	if (RT_SUCCESS(vrc))
5180	{
5181	aGuestProcess = pIProcess;
5182
5183	LogFlowFuncLeaveRC(vrc);
5184	return S_OK;
5185	}
5186
5187	hrc = setErrorVrc(vrc, tr("Failed to start guest process: %Rrc"), vrc);
5188	}
5189	}
5190	else if (vrc == VERR_GSTCTL_MAX_CID_OBJECTS_REACHED)
5191	hrc = setErrorVrc(vrc, tr("Maximum number of concurrent guest processes per session (%u) reached"),
5192	VBOX_GUESTCTRL_MAX_OBJECTS);
5193	else
5194	hrc = setErrorVrc(vrc, tr("Failed to create guest process object: %Rrc"), vrc);
5195	}
5196	else
5197	hrc = setErrorBoth(vrc == VERR_ENV_INVALID_VAR_NAME ? E_INVALIDARG : Global::vboxStatusCodeToCOM(vrc), vrc,
5198	tr("Failed to apply environment variable '%s', index %u (%Rrc)'"),
5199	aEnvironment[idxError].c_str(), idxError, vrc);
5200	}
5201	else
5202	hrc = setErrorVrc(vrc, tr("Failed to set up the environment: %Rrc"), vrc);
5203
5204	LogFlowFuncLeaveRC(vrc);
5205	return hrc;
5206	}
5207
5208	HRESULT GuestSession::processGet(ULONG aPid, ComPtr<IGuestProcess> &aGuestProcess)
5209
5210	{
5211	if (aPid == 0)
5212	return setError(E_INVALIDARG, tr("No valid process ID (PID) specified"));
5213
5214	LogFlowThisFunc(("PID=%RU32\n", aPid));
5215
5216	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
5217
5218	HRESULT hrc = S_OK;
5219
5220	ComObjPtr<GuestProcess> pProcess;
5221	int vrc = i_processGetByPID(aPid, &pProcess);
5222	if (RT_FAILURE(vrc))
5223	hrc = setError(E_INVALIDARG, tr("No process with PID %RU32 found"), aPid);
5224
5225	/* This will set (aProcess) to NULL if pProgress is NULL. /
5226	HRESULT hrc2 = pProcess.queryInterfaceTo(aGuestProcess.asOutParam());
5227	if (SUCCEEDED(hrc))
5228	hrc = hrc2;
5229
5230	LogFlowThisFunc(("aProcess=%p, hrc=%Rhrc\n", (IGuestProcess*)aGuestProcess, hrc));
5231	return hrc;
5232	}
5233
5234	HRESULT GuestSession::symlinkCreate(const com::Utf8Str &aSource, const com::Utf8Str &aTarget, SymlinkType_T aType)
5235	{
5236	RT_NOREF(aSource, aTarget, aType);
5237	ReturnComNotImplemented();
5238	}
5239
5240	HRESULT GuestSession::symlinkExists(const com::Utf8Str &aSymlink, BOOL *aExists)
5241
5242	{
5243	RT_NOREF(aSymlink, aExists);
5244	ReturnComNotImplemented();
5245	}
5246
5247	HRESULT GuestSession::symlinkRead(const com::Utf8Str &aSymlink, const std::vector<SymlinkReadFlag_T> &aFlags,
5248	com::Utf8Str &aTarget)
5249	{
5250	RT_NOREF(aSymlink, aFlags, aTarget);
5251	ReturnComNotImplemented();
5252	}
5253
5254	HRESULT GuestSession::waitFor(ULONG aWaitFor, ULONG aTimeoutMS, GuestSessionWaitResult_T *aReason)
5255	{
5256	/* Note: No call to i_isStartedExternal() needed here, as the session might not has been started (yet). */
5257
5258	LogFlowThisFuncEnter();
5259
5260	HRESULT hrc = S_OK;
5261
5262	/*
5263	* Note: Do not hold any locks here while waiting!
5264	*/
5265	int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS; GuestSessionWaitResult_T waitResult;
5266	int vrc = i_waitFor(aWaitFor, aTimeoutMS, waitResult, &vrcGuest);
5267	if (RT_SUCCESS(vrc))
5268	*aReason = waitResult;
5269	else
5270	{
5271	switch (vrc)
5272	{
5273	case VERR_GSTCTL_GUEST_ERROR:
5274	{
5275	GuestErrorInfo ge(GuestErrorInfo::Type_Session, vrcGuest, mData.mSession.mName.c_str());
5276	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest, tr("Waiting for guest process failed: %s"),
5277	GuestBase::getErrorAsString(ge).c_str());
5278	break;
5279	}
5280	case VERR_TIMEOUT:
5281	*aReason = GuestSessionWaitResult_Timeout;
5282	break;
5283
5284	default:
5285	{
5286	const char *pszSessionName = mData.mSession.mName.c_str();
5287	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
5288	tr("Waiting for guest session \"%s\" failed: %Rrc"),
5289	pszSessionName ? pszSessionName : tr("Unnamed"), vrc);
5290	break;
5291	}
5292	}
5293	}
5294
5295	LogFlowFuncLeaveRC(vrc);
5296	return hrc;
5297	}
5298
5299	HRESULT GuestSession::waitForArray(const std::vector<GuestSessionWaitForFlag_T> &aWaitFor, ULONG aTimeoutMS,
5300	GuestSessionWaitResult_T *aReason)
5301	{
5302	/* Note: No call to i_isStartedExternal() needed here, as the session might not has been started (yet). */
5303
5304	LogFlowThisFuncEnter();
5305
5306	/*
5307	* Note: Do not hold any locks here while waiting!
5308	*/
5309	uint32_t fWaitFor = GuestSessionWaitForFlag_None;
5310	for (size_t i = 0; i < aWaitFor.size(); i++)
5311	fWaitFor \|= aWaitFor[i];
5312
5313	return WaitFor(fWaitFor, aTimeoutMS, aReason);
5314	}

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

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

Download in other formats: