VirtualBox

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

Last change on this file since 72057 was 72045, checked in by vboxsync, 7 years ago

Guest Control/Main: CopyTo/CopyFrom bugfixes.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 127.7 KB
Line 
1/* $Id: GuestSessionImpl.cpp 72045 2018-04-26 15:39:10Z vboxsync $ */
2/** @file
3 * VirtualBox Main - Guest session handling.
4 */
5
6/*
7 * Copyright (C) 2012-2018 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#define LOG_GROUP LOG_GROUP_MAIN_GUESTSESSION
23#include "LoggingNew.h"
24
25#include "GuestImpl.h"
26#ifndef VBOX_WITH_GUEST_CONTROL
27# error "VBOX_WITH_GUEST_CONTROL must defined in this file"
28#endif
29#include "GuestSessionImpl.h"
30#include "GuestSessionImplTasks.h"
31#include "GuestCtrlImplPrivate.h"
32#include "VirtualBoxErrorInfoImpl.h"
33
34#include "Global.h"
35#include "AutoCaller.h"
36#include "ProgressImpl.h"
37#include "VBoxEvents.h"
38#include "VMMDev.h"
39#include "ThreadTask.h"
40
41#include <memory> /* For auto_ptr. */
42
43#include <iprt/cpp/utils.h> /* For unconst(). */
44#include <iprt/env.h>
45#include <iprt/file.h> /* For CopyTo/From. */
46#include <iprt/path.h>
47
48#include <VBox/com/array.h>
49#include <VBox/com/listeners.h>
50#include <VBox/version.h>
51
52
53/**
54 * Base class representing an internal
55 * asynchronous session task.
56 */
57class GuestSessionTaskInternal : public ThreadTask
58{
59public:
60
61 GuestSessionTaskInternal(GuestSession *pSession)
62 : ThreadTask("GenericGuestSessionTaskInternal")
63 , mSession(pSession)
64 , mRC(VINF_SUCCESS) { }
65
66 virtual ~GuestSessionTaskInternal(void) { }
67
68 int rc(void) const { return mRC; }
69 bool isOk(void) const { return RT_SUCCESS(mRC); }
70 const ComObjPtr<GuestSession> &Session(void) const { return mSession; }
71
72protected:
73
74 const ComObjPtr<GuestSession> mSession;
75 int mRC;
76};
77
78/**
79 * Class for asynchronously opening a guest session.
80 */
81class GuestSessionTaskInternalOpen : public GuestSessionTaskInternal
82{
83public:
84
85 GuestSessionTaskInternalOpen(GuestSession *pSession)
86 : GuestSessionTaskInternal(pSession)
87 {
88 m_strTaskName = "gctlSesStart";
89 }
90
91 void handler()
92 {
93 GuestSession::i_startSessionThreadTask(this);
94 }
95};
96
97/**
98 * Internal listener class to serve events in an
99 * active manner, e.g. without polling delays.
100 */
101class GuestSessionListener
102{
103public:
104
105 GuestSessionListener(void)
106 {
107 }
108
109 virtual ~GuestSessionListener(void)
110 {
111 }
112
113 HRESULT init(GuestSession *pSession)
114 {
115 AssertPtrReturn(pSession, E_POINTER);
116 mSession = pSession;
117 return S_OK;
118 }
119
120 void uninit(void)
121 {
122 mSession = NULL;
123 }
124
125 STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent *aEvent)
126 {
127 switch (aType)
128 {
129 case VBoxEventType_OnGuestSessionStateChanged:
130 {
131 AssertPtrReturn(mSession, E_POINTER);
132 int rc2 = mSession->signalWaitEvent(aType, aEvent);
133 RT_NOREF(rc2);
134#ifdef DEBUG_andy
135 LogFlowFunc(("Signalling events of type=%RU32, session=%p resulted in rc=%Rrc\n",
136 aType, mSession, rc2));
137#endif
138 break;
139 }
140
141 default:
142 AssertMsgFailed(("Unhandled event %RU32\n", aType));
143 break;
144 }
145
146 return S_OK;
147 }
148
149private:
150
151 GuestSession *mSession;
152};
153typedef ListenerImpl<GuestSessionListener, GuestSession*> GuestSessionListenerImpl;
154
155VBOX_LISTENER_DECLARE(GuestSessionListenerImpl)
156
157// constructor / destructor
158/////////////////////////////////////////////////////////////////////////////
159
160DEFINE_EMPTY_CTOR_DTOR(GuestSession)
161
162HRESULT GuestSession::FinalConstruct(void)
163{
164 LogFlowThisFuncEnter();
165 return BaseFinalConstruct();
166}
167
168void GuestSession::FinalRelease(void)
169{
170 LogFlowThisFuncEnter();
171 uninit();
172 BaseFinalRelease();
173 LogFlowThisFuncLeave();
174}
175
176// public initializer/uninitializer for internal purposes only
177/////////////////////////////////////////////////////////////////////////////
178
179/**
180 * Initializes a guest session but does *not* open in on the guest side
181 * yet. This needs to be done via the openSession() / openSessionAsync calls.
182 *
183 * @return IPRT status code.
184 ** @todo Docs!
185 */
186int GuestSession::init(Guest *pGuest, const GuestSessionStartupInfo &ssInfo,
187 const GuestCredentials &guestCreds)
188{
189 LogFlowThisFunc(("pGuest=%p, ssInfo=%p, guestCreds=%p\n",
190 pGuest, &ssInfo, &guestCreds));
191
192 /* Enclose the state transition NotReady->InInit->Ready. */
193 AutoInitSpan autoInitSpan(this);
194 AssertReturn(autoInitSpan.isOk(), VERR_OBJECT_DESTROYED);
195
196 AssertPtrReturn(pGuest, VERR_INVALID_POINTER);
197
198 /*
199 * Initialize our data members from the input.
200 */
201 mParent = pGuest;
202
203 /* Copy over startup info. */
204 /** @todo Use an overloaded copy operator. Later. */
205 mData.mSession.mID = ssInfo.mID;
206 mData.mSession.mIsInternal = ssInfo.mIsInternal;
207 mData.mSession.mName = ssInfo.mName;
208 mData.mSession.mOpenFlags = ssInfo.mOpenFlags;
209 mData.mSession.mOpenTimeoutMS = ssInfo.mOpenTimeoutMS;
210
211 /* Copy over session credentials. */
212 /** @todo Use an overloaded copy operator. Later. */
213 mData.mCredentials.mUser = guestCreds.mUser;
214 mData.mCredentials.mPassword = guestCreds.mPassword;
215 mData.mCredentials.mDomain = guestCreds.mDomain;
216
217 /* Initialize the remainder of the data. */
218 mData.mRC = VINF_SUCCESS;
219 mData.mStatus = GuestSessionStatus_Undefined;
220 mData.mpBaseEnvironment = NULL;
221
222 /*
223 * Register an object for the session itself to clearly
224 * distinguish callbacks which are for this session directly, or for
225 * objects (like files, directories, ...) which are bound to this session.
226 */
227 int rc = i_objectRegister(SESSIONOBJECTTYPE_SESSION, &mData.mObjectID);
228 if (RT_SUCCESS(rc))
229 {
230 rc = mData.mEnvironmentChanges.initChangeRecord();
231 if (RT_SUCCESS(rc))
232 {
233 rc = RTCritSectInit(&mWaitEventCritSect);
234 AssertRC(rc);
235 }
236 }
237
238 if (RT_SUCCESS(rc))
239 rc = i_determineProtocolVersion();
240
241 if (RT_SUCCESS(rc))
242 {
243 /*
244 * <Replace this if you figure out what the code is doing.>
245 */
246 HRESULT hr = unconst(mEventSource).createObject();
247 if (SUCCEEDED(hr))
248 hr = mEventSource->init();
249 if (SUCCEEDED(hr))
250 {
251 try
252 {
253 GuestSessionListener *pListener = new GuestSessionListener();
254 ComObjPtr<GuestSessionListenerImpl> thisListener;
255 hr = thisListener.createObject();
256 if (SUCCEEDED(hr))
257 hr = thisListener->init(pListener, this); /* thisListener takes ownership of pListener. */
258 if (SUCCEEDED(hr))
259 {
260 com::SafeArray <VBoxEventType_T> eventTypes;
261 eventTypes.push_back(VBoxEventType_OnGuestSessionStateChanged);
262 hr = mEventSource->RegisterListener(thisListener,
263 ComSafeArrayAsInParam(eventTypes),
264 TRUE /* Active listener */);
265 if (SUCCEEDED(hr))
266 {
267 mLocalListener = thisListener;
268
269 /*
270 * Mark this object as operational and return success.
271 */
272 autoInitSpan.setSucceeded();
273 LogFlowThisFunc(("mName=%s mID=%RU32 mIsInternal=%RTbool rc=VINF_SUCCESS\n",
274 mData.mSession.mName.c_str(), mData.mSession.mID, mData.mSession.mIsInternal));
275 return VINF_SUCCESS;
276 }
277 }
278 }
279 catch (std::bad_alloc &)
280 {
281 hr = E_OUTOFMEMORY;
282 }
283 }
284 rc = Global::vboxStatusCodeFromCOM(hr);
285 }
286
287 autoInitSpan.setFailed();
288 LogThisFunc(("Failed! mName=%s mID=%RU32 mIsInternal=%RTbool => rc=%Rrc\n",
289 mData.mSession.mName.c_str(), mData.mSession.mID, mData.mSession.mIsInternal, rc));
290 return rc;
291}
292
293/**
294 * Uninitializes the instance.
295 * Called from FinalRelease().
296 */
297void GuestSession::uninit(void)
298{
299 /* Enclose the state transition Ready->InUninit->NotReady. */
300 AutoUninitSpan autoUninitSpan(this);
301 if (autoUninitSpan.uninitDone())
302 return;
303
304 LogFlowThisFuncEnter();
305
306 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
307
308 LogFlowThisFunc(("Closing directories (%zu total)\n",
309 mData.mDirectories.size()));
310 for (SessionDirectories::iterator itDirs = mData.mDirectories.begin();
311 itDirs != mData.mDirectories.end(); ++itDirs)
312 {
313 itDirs->second->i_onRemove();
314 itDirs->second->uninit();
315 }
316 mData.mDirectories.clear();
317
318 LogFlowThisFunc(("Closing files (%zu total)\n",
319 mData.mFiles.size()));
320 for (SessionFiles::iterator itFiles = mData.mFiles.begin();
321 itFiles != mData.mFiles.end(); ++itFiles)
322 {
323 itFiles->second->i_onRemove();
324 itFiles->second->uninit();
325 }
326 mData.mFiles.clear();
327
328 LogFlowThisFunc(("Closing processes (%zu total)\n",
329 mData.mProcesses.size()));
330 for (SessionProcesses::iterator itProcs = mData.mProcesses.begin();
331 itProcs != mData.mProcesses.end(); ++itProcs)
332 {
333 itProcs->second->i_onRemove();
334 itProcs->second->uninit();
335 }
336 mData.mProcesses.clear();
337
338 /* Unregister the session's object ID. */
339 i_objectUnregister(mData.mObjectID);
340
341 mData.mObjects.clear();
342 mData.mObjectsFree.clear();
343
344 mData.mEnvironmentChanges.reset();
345
346 if (mData.mpBaseEnvironment)
347 {
348 mData.mpBaseEnvironment->releaseConst();
349 mData.mpBaseEnvironment = NULL;
350 }
351
352 /* Unitialize our local listener. */
353 mLocalListener.setNull();
354
355 baseUninit();
356
357 LogFlowFuncLeave();
358}
359
360// implementation of public getters/setters for attributes
361/////////////////////////////////////////////////////////////////////////////
362
363HRESULT GuestSession::getUser(com::Utf8Str &aUser)
364{
365 LogFlowThisFuncEnter();
366
367 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
368
369 aUser = mData.mCredentials.mUser;
370
371 LogFlowThisFuncLeave();
372 return S_OK;
373}
374
375HRESULT GuestSession::getDomain(com::Utf8Str &aDomain)
376{
377 LogFlowThisFuncEnter();
378
379 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
380
381 aDomain = mData.mCredentials.mDomain;
382
383 LogFlowThisFuncLeave();
384 return S_OK;
385}
386
387HRESULT GuestSession::getName(com::Utf8Str &aName)
388{
389 LogFlowThisFuncEnter();
390
391 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
392
393 aName = mData.mSession.mName;
394
395 LogFlowThisFuncLeave();
396 return S_OK;
397}
398
399HRESULT GuestSession::getId(ULONG *aId)
400{
401 LogFlowThisFuncEnter();
402
403 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
404
405 *aId = mData.mSession.mID;
406
407 LogFlowThisFuncLeave();
408 return S_OK;
409}
410
411HRESULT GuestSession::getStatus(GuestSessionStatus_T *aStatus)
412{
413 LogFlowThisFuncEnter();
414
415 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
416
417 *aStatus = mData.mStatus;
418
419 LogFlowThisFuncLeave();
420 return S_OK;
421}
422
423HRESULT GuestSession::getTimeout(ULONG *aTimeout)
424{
425 LogFlowThisFuncEnter();
426
427 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
428
429 *aTimeout = mData.mTimeout;
430
431 LogFlowThisFuncLeave();
432 return S_OK;
433}
434
435HRESULT GuestSession::setTimeout(ULONG aTimeout)
436{
437 LogFlowThisFuncEnter();
438
439 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
440
441 mData.mTimeout = aTimeout;
442
443 LogFlowThisFuncLeave();
444 return S_OK;
445}
446
447HRESULT GuestSession::getProtocolVersion(ULONG *aProtocolVersion)
448{
449 LogFlowThisFuncEnter();
450
451 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
452
453 *aProtocolVersion = mData.mProtocolVersion;
454
455 LogFlowThisFuncLeave();
456 return S_OK;
457}
458
459HRESULT GuestSession::getEnvironmentChanges(std::vector<com::Utf8Str> &aEnvironmentChanges)
460{
461 LogFlowThisFuncEnter();
462
463 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
464
465 int vrc = mData.mEnvironmentChanges.queryPutEnvArray(&aEnvironmentChanges);
466
467 LogFlowFuncLeaveRC(vrc);
468 return Global::vboxStatusCodeToCOM(vrc);
469}
470
471HRESULT GuestSession::setEnvironmentChanges(const std::vector<com::Utf8Str> &aEnvironmentChanges)
472{
473 LogFlowThisFuncEnter();
474
475 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
476
477 mData.mEnvironmentChanges.reset();
478 int vrc = mData.mEnvironmentChanges.applyPutEnvArray(aEnvironmentChanges);
479
480 LogFlowFuncLeaveRC(vrc);
481 return Global::vboxStatusCodeToCOM(vrc);
482}
483
484HRESULT GuestSession::getEnvironmentBase(std::vector<com::Utf8Str> &aEnvironmentBase)
485{
486 LogFlowThisFuncEnter();
487
488 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
489 HRESULT hrc;
490 if (mData.mpBaseEnvironment)
491 {
492 int vrc = mData.mpBaseEnvironment->queryPutEnvArray(&aEnvironmentBase);
493 hrc = Global::vboxStatusCodeToCOM(vrc);
494 }
495 else if (mData.mProtocolVersion < 99999)
496 hrc = setError(VBOX_E_NOT_SUPPORTED, tr("The base environment feature is not supported by the guest additions"));
497 else
498 hrc = setError(VBOX_E_INVALID_OBJECT_STATE, tr("The base environment has not yet been reported by the guest"));
499
500 LogFlowFuncLeave();
501 return hrc;
502}
503
504HRESULT GuestSession::getProcesses(std::vector<ComPtr<IGuestProcess> > &aProcesses)
505{
506 LogFlowThisFuncEnter();
507
508 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
509
510 aProcesses.resize(mData.mProcesses.size());
511 size_t i = 0;
512 for(SessionProcesses::iterator it = mData.mProcesses.begin();
513 it != mData.mProcesses.end();
514 ++it, ++i)
515 {
516 it->second.queryInterfaceTo(aProcesses[i].asOutParam());
517 }
518
519 LogFlowFunc(("mProcesses=%zu\n", aProcesses.size()));
520 return S_OK;
521}
522
523HRESULT GuestSession::getPathStyle(PathStyle_T *aPathStyle)
524{
525 *aPathStyle = i_getPathStyle();
526 return S_OK;
527}
528
529HRESULT GuestSession::getCurrentDirectory(com::Utf8Str &aCurrentDirectory)
530{
531 RT_NOREF(aCurrentDirectory);
532 ReturnComNotImplemented();
533}
534
535HRESULT GuestSession::setCurrentDirectory(const com::Utf8Str &aCurrentDirectory)
536{
537 RT_NOREF(aCurrentDirectory);
538 ReturnComNotImplemented();
539}
540
541HRESULT GuestSession::getUserHome(com::Utf8Str &aUserHome)
542{
543 HRESULT hr = i_isReadyExternal();
544 if (FAILED(hr))
545 return hr;
546
547 int rcGuest;
548 int vrc = i_pathUserHome(aUserHome, &rcGuest);
549 if (RT_FAILURE(vrc))
550 {
551 switch (vrc)
552 {
553 case VERR_GSTCTL_GUEST_ERROR:
554 {
555 switch (rcGuest)
556 {
557 case VERR_NOT_SUPPORTED:
558 hr = setError(VBOX_E_IPRT_ERROR, tr("Getting the user's home path is not supported by installed Guest Additions"));
559 break;
560
561 default:
562 hr = setError(VBOX_E_IPRT_ERROR, tr("Getting the user's home path failed on the guest: %Rrc"), rcGuest);
563 break;
564 }
565 break;
566 }
567
568 default:
569 hr = setError(VBOX_E_IPRT_ERROR, tr("Getting the user's home path failed: %Rrc"), vrc);
570 break;
571 }
572 }
573
574 return hr;
575}
576
577HRESULT GuestSession::getUserDocuments(com::Utf8Str &aUserDocuments)
578{
579 HRESULT hr = i_isReadyExternal();
580 if (FAILED(hr))
581 return hr;
582
583 int rcGuest;
584 int vrc = i_pathUserDocuments(aUserDocuments, &rcGuest);
585 if (RT_FAILURE(vrc))
586 {
587 switch (vrc)
588 {
589 case VERR_GSTCTL_GUEST_ERROR:
590 {
591 switch (rcGuest)
592 {
593 case VERR_NOT_SUPPORTED:
594 hr = setError(VBOX_E_IPRT_ERROR, tr("Getting the user's documents path is not supported by installed Guest Additions"));
595 break;
596
597 default:
598 hr = setError(VBOX_E_IPRT_ERROR, tr("Getting the user's documents path failed on the guest: %Rrc"), rcGuest);
599 break;
600 }
601 break;
602 }
603
604 default:
605 hr = setError(VBOX_E_IPRT_ERROR, tr("Getting the user's documents path failed: %Rrc"), vrc);
606 break;
607 }
608 }
609
610 return hr;
611}
612
613HRESULT GuestSession::getDirectories(std::vector<ComPtr<IGuestDirectory> > &aDirectories)
614{
615 LogFlowThisFuncEnter();
616
617 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
618
619 aDirectories.resize(mData.mDirectories.size());
620 size_t i = 0;
621 for(SessionDirectories::iterator it = mData.mDirectories.begin();
622 it != mData.mDirectories.end();
623 ++it, ++i)
624 {
625 it->second.queryInterfaceTo(aDirectories[i].asOutParam());
626 }
627
628 LogFlowFunc(("mDirectories=%zu\n", aDirectories.size()));
629 return S_OK;
630}
631
632HRESULT GuestSession::getFiles(std::vector<ComPtr<IGuestFile> > &aFiles)
633{
634 LogFlowThisFuncEnter();
635
636 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
637
638 aFiles.resize(mData.mFiles.size());
639 size_t i = 0;
640 for(SessionFiles::iterator it = mData.mFiles.begin(); it != mData.mFiles.end(); ++it, ++i)
641 it->second.queryInterfaceTo(aFiles[i].asOutParam());
642
643 LogFlowFunc(("mDirectories=%zu\n", aFiles.size()));
644
645 return S_OK;
646}
647
648HRESULT GuestSession::getEventSource(ComPtr<IEventSource> &aEventSource)
649{
650 LogFlowThisFuncEnter();
651
652 // no need to lock - lifetime constant
653 mEventSource.queryInterfaceTo(aEventSource.asOutParam());
654
655 LogFlowThisFuncLeave();
656 return S_OK;
657}
658
659// private methods
660///////////////////////////////////////////////////////////////////////////////
661
662int GuestSession::i_closeSession(uint32_t uFlags, uint32_t uTimeoutMS, int *prcGuest)
663{
664 AssertPtrReturn(prcGuest, VERR_INVALID_POINTER);
665
666 LogFlowThisFunc(("uFlags=%x, uTimeoutMS=%RU32\n", uFlags, uTimeoutMS));
667
668 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
669
670 /* Guest Additions < 4.3 don't support closing dedicated
671 guest sessions, skip. */
672 if (mData.mProtocolVersion < 2)
673 {
674 LogFlowThisFunc(("Installed Guest Additions don't support closing dedicated sessions, skipping\n"));
675 return VINF_SUCCESS;
676 }
677
678 /** @todo uFlags validation. */
679
680 if (mData.mStatus != GuestSessionStatus_Started)
681 {
682 LogFlowThisFunc(("Session ID=%RU32 not started (anymore), status now is: %RU32\n",
683 mData.mSession.mID, mData.mStatus));
684 return VINF_SUCCESS;
685 }
686
687 int vrc;
688
689 GuestWaitEvent *pEvent = NULL;
690 GuestEventTypes eventTypes;
691 try
692 {
693 eventTypes.push_back(VBoxEventType_OnGuestSessionStateChanged);
694
695 vrc = registerWaitEventEx(mData.mSession.mID, mData.mObjectID, eventTypes, &pEvent);
696 }
697 catch (std::bad_alloc)
698 {
699 vrc = VERR_NO_MEMORY;
700 }
701
702 if (RT_FAILURE(vrc))
703 return vrc;
704
705 LogFlowThisFunc(("Sending closing request to guest session ID=%RU32, uFlags=%x\n",
706 mData.mSession.mID, uFlags));
707
708 VBOXHGCMSVCPARM paParms[4];
709 int i = 0;
710 paParms[i++].setUInt32(pEvent->ContextID());
711 paParms[i++].setUInt32(uFlags);
712
713 alock.release(); /* Drop the write lock before waiting. */
714
715 vrc = i_sendCommand(HOST_SESSION_CLOSE, i, paParms);
716 if (RT_SUCCESS(vrc))
717 vrc = i_waitForStatusChange(pEvent, GuestSessionWaitForFlag_Terminate, uTimeoutMS,
718 NULL /* Session status */, prcGuest);
719
720 unregisterWaitEvent(pEvent);
721
722 LogFlowFuncLeaveRC(vrc);
723 return vrc;
724}
725
726/**
727 * Internal worker function for public APIs that handle copying elements from
728 * guest to the host.
729 *
730 * @return HRESULT
731 * @param SourceSet Source set specifying what to copy.
732 * @param strDestination Destination path on the host. Host path style.
733 * @param pProgress Progress object returned to the caller.
734 */
735HRESULT GuestSession::i_copyFromGuest(const GuestSessionFsSourceSet &SourceSet,
736 const com::Utf8Str &strDestination, ComPtr<IProgress> &pProgress)
737{
738 HRESULT hrc = i_isReadyExternal();
739 if (FAILED(hrc))
740 return hrc;
741
742 LogFlowThisFuncEnter();
743
744 /* Validate stuff. */
745 if (RT_UNLIKELY(SourceSet.size() == 0 || *(SourceSet[0].strSource.c_str()) == '\0')) /* At least one source must be present. */
746 return setError(E_INVALIDARG, tr("No source(s) specified"));
747 if (RT_UNLIKELY((strDestination.c_str()) == NULL || *(strDestination.c_str()) == '\0'))
748 return setError(E_INVALIDARG, tr("No destination specified"));
749
750 GuestSessionFsSourceSet::const_iterator itSource = SourceSet.begin();
751 while (itSource != SourceSet.end())
752 {
753 if (itSource->enmType == FsObjType_Directory)
754 {
755 if (itSource->Type.Dir.fCopyFlags)
756 {
757 if (!(itSource->Type.Dir.fCopyFlags & DirectoryCopyFlag_CopyIntoExisting))
758 return setError(E_INVALIDARG, tr("Invalid / not (yet) implemented directory copy flags specified"));
759 }
760 }
761 else if (itSource->enmType == FsObjType_File)
762 {
763 if (itSource->Type.File.fCopyFlags)
764 {
765 if ( !(itSource->Type.File.fCopyFlags & FileCopyFlag_NoReplace)
766 && !(itSource->Type.File.fCopyFlags & FileCopyFlag_FollowLinks)
767 && !(itSource->Type.File.fCopyFlags & FileCopyFlag_Update))
768 {
769 return setError(E_NOTIMPL, tr("Invalid / not (yet) implemented file copy flag(s) specified"));
770 }
771 }
772 }
773 else
774 return setError(E_NOTIMPL, tr("Source type %RU32 not implemented"), itSource->enmType);
775
776 itSource++;
777 }
778
779 try
780 {
781 GuestSessionTaskCopyFrom *pTask = NULL;
782 ComObjPtr<Progress> pProgressObj;
783 try
784 {
785 pTask = new GuestSessionTaskCopyFrom(this /* GuestSession */, SourceSet, strDestination);
786 }
787 catch(...)
788 {
789 hrc = setError(VBOX_E_IPRT_ERROR, tr("Failed to create SessionTaskCopyFrom object"));
790 throw;
791 }
792
793 hrc = pTask->Init(Utf8StrFmt(tr("Copying to \"%s\" on the host"), strDestination.c_str()));
794 if (FAILED(hrc))
795 {
796 delete pTask;
797 hrc = setError(VBOX_E_IPRT_ERROR,
798 tr("Creating progress object for SessionTaskCopyFrom object failed"));
799 throw hrc;
800 }
801
802 hrc = pTask->createThreadWithType(RTTHREADTYPE_MAIN_HEAVY_WORKER);
803 if (SUCCEEDED(hrc))
804 {
805 /* Return progress to the caller. */
806 pProgressObj = pTask->GetProgressObject();
807 hrc = pProgressObj.queryInterfaceTo(pProgress.asOutParam());
808 }
809 else
810 hrc = setError(VBOX_E_IPRT_ERROR,
811 tr("Starting thread for copying from guest to \"%s\" on the host failed"), strDestination.c_str());
812
813 }
814 catch (std::bad_alloc &)
815 {
816 hrc = E_OUTOFMEMORY;
817 }
818 catch (HRESULT eHR)
819 {
820 hrc = eHR;
821 }
822
823 LogFlowFunc(("Returning %Rhrc\n", hrc));
824 return hrc;
825}
826
827/**
828 * Internal worker function for public APIs that handle copying elements from
829 * host to the guest.
830 *
831 * @return HRESULT
832 * @param SourceSet Source set specifying what to copy.
833 * @param strDestination Destination path on the guest. Guest path style.
834 * @param pProgress Progress object returned to the caller.
835 */
836HRESULT GuestSession::i_copyToGuest(const GuestSessionFsSourceSet &SourceSet,
837 const com::Utf8Str &strDestination, ComPtr<IProgress> &pProgress)
838{
839 HRESULT hrc = i_isReadyExternal();
840 if (FAILED(hrc))
841 return hrc;
842
843 LogFlowThisFuncEnter();
844
845 /* Validate stuff. */
846 if (RT_UNLIKELY(SourceSet.size() == 0 || *(SourceSet[0].strSource.c_str()) == '\0')) /* At least one source must be present. */
847 return setError(E_INVALIDARG, tr("No source(s) specified"));
848 if (RT_UNLIKELY((strDestination.c_str()) == NULL || *(strDestination.c_str()) == '\0'))
849 return setError(E_INVALIDARG, tr("No destination specified"));
850
851 GuestSessionFsSourceSet::const_iterator itSource = SourceSet.begin();
852 while (itSource != SourceSet.end())
853 {
854 if (itSource->enmType == FsObjType_Directory)
855 {
856 if (itSource->Type.Dir.fCopyFlags)
857 {
858 if (!(itSource->Type.Dir.fCopyFlags & DirectoryCopyFlag_CopyIntoExisting))
859 return setError(E_INVALIDARG, tr("Invalid / not (yet) implemented directory copy flags specified"));
860 }
861 }
862 else if (itSource->enmType == FsObjType_File)
863 {
864 if (itSource->Type.File.fCopyFlags)
865 {
866 if ( !(itSource->Type.File.fCopyFlags & FileCopyFlag_NoReplace)
867 && !(itSource->Type.File.fCopyFlags & FileCopyFlag_FollowLinks)
868 && !(itSource->Type.File.fCopyFlags & FileCopyFlag_Update))
869 {
870 return setError(E_NOTIMPL, tr("Invalid / not (yet) implemented file copy flag(s) specified"));
871 }
872 }
873 }
874 else
875 return setError(E_NOTIMPL, tr("Source type %RU32 not implemented"), itSource->enmType);
876
877 itSource++;
878 }
879
880 try
881 {
882 GuestSessionTaskCopyTo *pTask = NULL;
883 ComObjPtr<Progress> pProgressObj;
884 try
885 {
886 pTask = new GuestSessionTaskCopyTo(this /* GuestSession */, SourceSet, strDestination);
887 }
888 catch(...)
889 {
890 hrc = setError(VBOX_E_IPRT_ERROR, tr("Failed to create SessionTaskCopyTo object"));
891 throw;
892 }
893
894 hrc = pTask->Init(Utf8StrFmt(tr("Copying to \"%s\" on the guest"), strDestination.c_str()));
895 if (FAILED(hrc))
896 {
897 delete pTask;
898 hrc = setError(VBOX_E_IPRT_ERROR,
899 tr("Creating progress object for SessionTaskCopyTo object failed"));
900 throw hrc;
901 }
902
903 hrc = pTask->createThreadWithType(RTTHREADTYPE_MAIN_HEAVY_WORKER);
904 if (SUCCEEDED(hrc))
905 {
906 /* Return progress to the caller. */
907 pProgressObj = pTask->GetProgressObject();
908 hrc = pProgressObj.queryInterfaceTo(pProgress.asOutParam());
909 }
910 else
911 hrc = setError(VBOX_E_IPRT_ERROR,
912 tr("Starting thread for copying from host to \"%s\" on the guest failed"), strDestination.c_str());
913
914 }
915 catch (std::bad_alloc &)
916 {
917 hrc = E_OUTOFMEMORY;
918 }
919 catch (HRESULT eHR)
920 {
921 hrc = eHR;
922 }
923
924 LogFlowFunc(("Returning %Rhrc\n", hrc));
925 return hrc;
926}
927
928int GuestSession::i_directoryCreate(const Utf8Str &strPath, uint32_t uMode,
929 uint32_t uFlags, int *prcGuest)
930{
931 AssertPtrReturn(prcGuest, VERR_INVALID_POINTER);
932
933 LogFlowThisFunc(("strPath=%s, uMode=%x, uFlags=%x\n", strPath.c_str(), uMode, uFlags));
934
935 int vrc = VINF_SUCCESS;
936
937 GuestProcessStartupInfo procInfo;
938 procInfo.mFlags = ProcessCreateFlag_Hidden;
939 procInfo.mExecutable = Utf8Str(VBOXSERVICE_TOOL_MKDIR);
940
941 try
942 {
943 procInfo.mArguments.push_back(procInfo.mExecutable); /* Set argv0. */
944
945 /* Construct arguments. */
946 if (uFlags)
947 {
948 if (uFlags & DirectoryCreateFlag_Parents)
949 procInfo.mArguments.push_back(Utf8Str("--parents")); /* We also want to create the parent directories. */
950 else
951 vrc = VERR_INVALID_PARAMETER;
952 }
953
954 if ( RT_SUCCESS(vrc)
955 && uMode)
956 {
957 procInfo.mArguments.push_back(Utf8Str("--mode")); /* Set the creation mode. */
958
959 char szMode[16];
960 if (RTStrPrintf(szMode, sizeof(szMode), "%o", uMode))
961 {
962 procInfo.mArguments.push_back(Utf8Str(szMode));
963 }
964 else
965 vrc = VERR_BUFFER_OVERFLOW;
966 }
967
968 procInfo.mArguments.push_back("--"); /* '--version' is a valid directory name. */
969 procInfo.mArguments.push_back(strPath); /* The directory we want to create. */
970 }
971 catch (std::bad_alloc)
972 {
973 vrc = VERR_NO_MEMORY;
974 }
975
976 if (RT_SUCCESS(vrc))
977 vrc = GuestProcessTool::run(this, procInfo, prcGuest);
978
979 LogFlowFuncLeaveRC(vrc);
980 return vrc;
981}
982
983inline bool GuestSession::i_directoryExists(uint32_t uDirID, ComObjPtr<GuestDirectory> *pDir)
984{
985 SessionDirectories::const_iterator it = mData.mDirectories.find(uDirID);
986 if (it != mData.mDirectories.end())
987 {
988 if (pDir)
989 *pDir = it->second;
990 return true;
991 }
992 return false;
993}
994
995int GuestSession::i_directoryQueryInfo(const Utf8Str &strPath, bool fFollowSymlinks,
996 GuestFsObjData &objData, int *prcGuest)
997{
998 AssertPtrReturn(prcGuest, VERR_INVALID_POINTER);
999
1000 LogFlowThisFunc(("strPath=%s, fFollowSymlinks=%RTbool\n", strPath.c_str(), fFollowSymlinks));
1001
1002 int vrc = i_fsQueryInfo(strPath, fFollowSymlinks, objData, prcGuest);
1003 if (RT_SUCCESS(vrc))
1004 {
1005 vrc = objData.mType == FsObjType_Directory
1006 ? VINF_SUCCESS : VERR_NOT_A_DIRECTORY;
1007 }
1008
1009 LogFlowFuncLeaveRC(vrc);
1010 return vrc;
1011}
1012
1013/**
1014 * Unregisters a directory object from a session.
1015 *
1016 * @return VBox status code. VERR_NOT_FOUND if the directory is not registered (anymore).
1017 * @param pDirectory Directory object to unregister from session.
1018 */
1019int GuestSession::i_directoryUnregister(GuestDirectory *pDirectory)
1020{
1021 AssertPtrReturn(pDirectory, VERR_INVALID_POINTER);
1022
1023 LogFlowThisFunc(("pDirectory=%p\n", pDirectory));
1024
1025 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1026
1027 const uint32_t uObjectID = pDirectory->getObjectID();
1028
1029 LogFlowFunc(("Removing directory (objectID=%RU32) ...\n", uObjectID));
1030
1031 int rc = i_objectUnregister(uObjectID);
1032 if (RT_FAILURE(rc))
1033 return rc;
1034
1035 SessionDirectories::iterator itDirs = mData.mDirectories.find(uObjectID);
1036 AssertReturn(itDirs != mData.mDirectories.end(), VERR_NOT_FOUND);
1037
1038 /* Make sure to consume the pointer before the one of the iterator gets released. */
1039 ComObjPtr<GuestDirectory> pDirConsumed = pDirectory;
1040
1041 LogFlowFunc(("Removing directory ID=%RU32 (session %RU32, now total %zu directories)\n",
1042 uObjectID, mData.mSession.mID, mData.mDirectories.size()));
1043
1044 rc = pDirConsumed->i_onRemove();
1045 AssertRCReturn(rc, rc);
1046
1047 mData.mDirectories.erase(itDirs);
1048
1049 alock.release(); /* Release lock before firing off event. */
1050
1051// fireGuestDirectoryRegisteredEvent(mEventSource, this /* Session */, pDirConsumed, false /* Process unregistered */);
1052
1053 pDirConsumed.setNull();
1054
1055 LogFlowFuncLeaveRC(rc);
1056 return rc;
1057}
1058
1059int GuestSession::i_directoryRemove(const Utf8Str &strPath, uint32_t uFlags, int *prcGuest)
1060{
1061 AssertReturn(!(uFlags & ~DIRREMOVE_FLAG_VALID_MASK), VERR_INVALID_PARAMETER);
1062 AssertPtrReturn(prcGuest, VERR_INVALID_POINTER);
1063
1064 LogFlowThisFunc(("strPath=%s, uFlags=0x%x\n", strPath.c_str(), uFlags));
1065
1066 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1067
1068 GuestWaitEvent *pEvent = NULL;
1069 int vrc = registerWaitEvent(mData.mSession.mID, mData.mObjectID, &pEvent);
1070 if (RT_FAILURE(vrc))
1071 return vrc;
1072
1073 /* Prepare HGCM call. */
1074 VBOXHGCMSVCPARM paParms[8];
1075 int i = 0;
1076 paParms[i++].setUInt32(pEvent->ContextID());
1077 paParms[i++].setPointer((void*)strPath.c_str(),
1078 (ULONG)strPath.length() + 1);
1079 paParms[i++].setUInt32(uFlags);
1080
1081 alock.release(); /* Drop write lock before sending. */
1082
1083 vrc = i_sendCommand(HOST_DIR_REMOVE, i, paParms);
1084 if (RT_SUCCESS(vrc))
1085 {
1086 vrc = pEvent->Wait(30 * 1000);
1087 if ( vrc == VERR_GSTCTL_GUEST_ERROR
1088 && prcGuest)
1089 *prcGuest = pEvent->GuestResult();
1090 }
1091
1092 unregisterWaitEvent(pEvent);
1093
1094 LogFlowFuncLeaveRC(vrc);
1095 return vrc;
1096}
1097
1098int GuestSession::i_fsCreateTemp(const Utf8Str &strTemplate, const Utf8Str &strPath, bool fDirectory, Utf8Str &strName,
1099 int *prcGuest)
1100{
1101 AssertPtrReturn(prcGuest, VERR_INVALID_POINTER);
1102
1103 LogFlowThisFunc(("strTemplate=%s, strPath=%s, fDirectory=%RTbool\n",
1104 strTemplate.c_str(), strPath.c_str(), fDirectory));
1105
1106 GuestProcessStartupInfo procInfo;
1107 procInfo.mFlags = ProcessCreateFlag_WaitForStdOut;
1108 try
1109 {
1110 procInfo.mExecutable = Utf8Str(VBOXSERVICE_TOOL_MKTEMP);
1111 procInfo.mArguments.push_back(procInfo.mExecutable); /* Set argv0. */
1112 procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
1113 if (fDirectory)
1114 procInfo.mArguments.push_back(Utf8Str("-d"));
1115 if (strPath.length()) /* Otherwise use /tmp or equivalent. */
1116 {
1117 procInfo.mArguments.push_back(Utf8Str("-t"));
1118 procInfo.mArguments.push_back(strPath);
1119 }
1120 procInfo.mArguments.push_back("--"); /* strTemplate could be '--help'. */
1121 procInfo.mArguments.push_back(strTemplate);
1122 }
1123 catch (std::bad_alloc)
1124 {
1125 Log(("Out of memory!\n"));
1126 return VERR_NO_MEMORY;
1127 }
1128
1129 /** @todo Use an internal HGCM command for this operation, since
1130 * we now can run in a user-dedicated session. */
1131 int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
1132 GuestCtrlStreamObjects stdOut;
1133 int vrc = GuestProcessTool::runEx(this, procInfo, &stdOut, 1 /* cStrmOutObjects */, &vrcGuest);
1134 if (!GuestProcess::i_isGuestError(vrc))
1135 {
1136 GuestFsObjData objData;
1137 if (!stdOut.empty())
1138 {
1139 vrc = objData.FromMkTemp(stdOut.at(0));
1140 if (RT_FAILURE(vrc))
1141 {
1142 vrcGuest = vrc;
1143 if (prcGuest)
1144 *prcGuest = vrc;
1145 vrc = VERR_GSTCTL_GUEST_ERROR;
1146 }
1147 }
1148 else
1149 vrc = VERR_BROKEN_PIPE;
1150
1151 if (RT_SUCCESS(vrc))
1152 strName = objData.mName;
1153 }
1154 else if (prcGuest)
1155 *prcGuest = vrcGuest;
1156
1157 LogFlowThisFunc(("Returning vrc=%Rrc, vrcGuest=%Rrc\n", vrc, vrcGuest));
1158 return vrc;
1159}
1160
1161int GuestSession::i_directoryOpen(const GuestDirectoryOpenInfo &openInfo,
1162 ComObjPtr<GuestDirectory> &pDirectory, int *prcGuest)
1163{
1164 AssertPtrReturn(prcGuest, VERR_INVALID_POINTER);
1165
1166 LogFlowThisFunc(("strPath=%s, strPath=%s, uFlags=%x\n",
1167 openInfo.mPath.c_str(), openInfo.mFilter.c_str(), openInfo.mFlags));
1168
1169 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1170
1171 /* Register a new object ID. */
1172 uint32_t uObjectID;
1173 int rc = i_objectRegister(SESSIONOBJECTTYPE_DIRECTORY, &uObjectID);
1174 if (RT_FAILURE(rc))
1175 return rc;
1176
1177 /* Create the directory object. */
1178 HRESULT hr = pDirectory.createObject();
1179 if (FAILED(hr))
1180 return VERR_COM_UNEXPECTED;
1181
1182 Console *pConsole = mParent->i_getConsole();
1183 AssertPtr(pConsole);
1184
1185 int vrc = pDirectory->init(pConsole, this /* Parent */, uObjectID, openInfo);
1186 if (RT_FAILURE(vrc))
1187 return vrc;
1188
1189 /*
1190 * Since this is a synchronous guest call we have to
1191 * register the file object first, releasing the session's
1192 * lock and then proceed with the actual opening command
1193 * -- otherwise the file's opening callback would hang
1194 * because the session's lock still is in place.
1195 */
1196 try
1197 {
1198 /* Add the created directory to our map. */
1199 mData.mDirectories[uObjectID] = pDirectory;
1200
1201 LogFlowFunc(("Added new guest directory \"%s\" (Session: %RU32) (now total %zu directories)\n",
1202 openInfo.mPath.c_str(), mData.mSession.mID, mData.mDirectories.size()));
1203
1204 alock.release(); /* Release lock before firing off event. */
1205
1206 /** @todo Fire off a VBoxEventType_OnGuestDirectoryRegistered event? */
1207 }
1208 catch (std::bad_alloc &)
1209 {
1210 rc = VERR_NO_MEMORY;
1211 }
1212
1213 if (RT_SUCCESS(rc))
1214 {
1215 /* Nothing further to do here yet. */
1216 if (prcGuest)
1217 *prcGuest = VINF_SUCCESS;
1218 }
1219
1220 LogFlowFuncLeaveRC(vrc);
1221 return vrc;
1222}
1223
1224/**
1225 * Dispatches a host callback to its corresponding object.
1226 *
1227 * @return VBox status code. VERR_NOT_FOUND if no corresponding object was found.
1228 * @param pCtxCb Host callback context.
1229 * @param pSvcCb Service callback data.
1230 */
1231int GuestSession::i_dispatchToObject(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
1232{
1233 LogFlowFunc(("pCtxCb=%p, pSvcCb=%p\n", pCtxCb, pSvcCb));
1234
1235 AssertPtrReturn(pCtxCb, VERR_INVALID_POINTER);
1236 AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
1237
1238 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1239
1240 const uint32_t uObjectID = VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(pCtxCb->uContextID);
1241
1242 int rc = VERR_NOT_FOUND;
1243
1244 SessionObjects::const_iterator itObjs = mData.mObjects.find(uObjectID);
1245
1246 if (itObjs == mData.mObjects.end())
1247 return rc;
1248
1249 /* Set protocol version so that pSvcCb can be interpreted right. */
1250 pCtxCb->uProtocol = mData.mProtocolVersion;
1251
1252 switch (itObjs->second.enmType)
1253 {
1254 case SESSIONOBJECTTYPE_ANONYMOUS:
1255 rc = VERR_NOT_SUPPORTED;
1256 break;
1257
1258 case SESSIONOBJECTTYPE_SESSION:
1259 {
1260 alock.release();
1261
1262 rc = i_dispatchToThis(pCtxCb, pSvcCb);
1263 break;
1264 }
1265 case SESSIONOBJECTTYPE_DIRECTORY:
1266 {
1267 SessionDirectories::const_iterator itDir = mData.mDirectories.find(uObjectID);
1268 if (itDir != mData.mDirectories.end())
1269 {
1270 ComObjPtr<GuestDirectory> pDirectory(itDir->second);
1271 Assert(!pDirectory.isNull());
1272
1273 alock.release();
1274
1275 rc = pDirectory->i_callbackDispatcher(pCtxCb, pSvcCb);
1276 }
1277 break;
1278 }
1279 case SESSIONOBJECTTYPE_FILE:
1280 {
1281 SessionFiles::const_iterator itFile = mData.mFiles.find(uObjectID);
1282 if (itFile != mData.mFiles.end())
1283 {
1284 ComObjPtr<GuestFile> pFile(itFile->second);
1285 Assert(!pFile.isNull());
1286
1287 alock.release();
1288
1289 rc = pFile->i_callbackDispatcher(pCtxCb, pSvcCb);
1290 }
1291 break;
1292 }
1293 case SESSIONOBJECTTYPE_PROCESS:
1294 {
1295 SessionProcesses::const_iterator itProc = mData.mProcesses.find(uObjectID);
1296 if (itProc != mData.mProcesses.end())
1297 {
1298 ComObjPtr<GuestProcess> pProcess(itProc->second);
1299 Assert(!pProcess.isNull());
1300
1301 alock.release();
1302
1303 rc = pProcess->i_callbackDispatcher(pCtxCb, pSvcCb);
1304 }
1305 break;
1306 }
1307 default:
1308 AssertFailed();
1309 break;
1310 }
1311
1312 LogFlowFuncLeaveRC(rc);
1313 return rc;
1314}
1315
1316int GuestSession::i_dispatchToThis(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
1317{
1318 AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
1319 AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
1320
1321 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1322
1323 LogFlowThisFunc(("sessionID=%RU32, CID=%RU32, uFunction=%RU32, pSvcCb=%p\n",
1324 mData.mSession.mID, pCbCtx->uContextID, pCbCtx->uFunction, pSvcCb));
1325 int rc;
1326 switch (pCbCtx->uFunction)
1327 {
1328 case GUEST_DISCONNECTED:
1329 /** @todo Handle closing all guest objects. */
1330 rc = VERR_INTERNAL_ERROR;
1331 break;
1332
1333 case GUEST_SESSION_NOTIFY: /* Guest Additions >= 4.3.0. */
1334 {
1335 rc = i_onSessionStatusChange(pCbCtx, pSvcCb);
1336 break;
1337 }
1338
1339 default:
1340 rc = dispatchGeneric(pCbCtx, pSvcCb);
1341 break;
1342 }
1343
1344 LogFlowFuncLeaveRC(rc);
1345 return rc;
1346}
1347
1348inline bool GuestSession::i_fileExists(uint32_t uFileID, ComObjPtr<GuestFile> *pFile)
1349{
1350 SessionFiles::const_iterator it = mData.mFiles.find(uFileID);
1351 if (it != mData.mFiles.end())
1352 {
1353 if (pFile)
1354 *pFile = it->second;
1355 return true;
1356 }
1357 return false;
1358}
1359
1360/**
1361 * Unregisters a file object from a session.
1362 *
1363 * @return VBox status code. VERR_NOT_FOUND if the file is not registered (anymore).
1364 * @param pFile File object to unregister from session.
1365 */
1366int GuestSession::i_fileUnregister(GuestFile *pFile)
1367{
1368 AssertPtrReturn(pFile, VERR_INVALID_POINTER);
1369
1370 LogFlowThisFunc(("pFile=%p\n", pFile));
1371
1372 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1373
1374 const uint32_t uObjectID = pFile->getObjectID();
1375
1376 LogFlowFunc(("Removing file (objectID=%RU32) ...\n", uObjectID));
1377
1378 int rc = i_objectUnregister(uObjectID);
1379 if (RT_FAILURE(rc))
1380 return rc;
1381
1382 SessionFiles::iterator itFiles = mData.mFiles.find(uObjectID);
1383 AssertReturn(itFiles != mData.mFiles.end(), VERR_NOT_FOUND);
1384
1385 /* Make sure to consume the pointer before the one of the iterator gets released. */
1386 ComObjPtr<GuestFile> pFileConsumed = pFile;
1387
1388 LogFlowFunc(("Removing file ID=%RU32 (session %RU32, now total %zu files)\n",
1389 pFileConsumed->getObjectID(), mData.mSession.mID, mData.mFiles.size()));
1390
1391 rc = pFileConsumed->i_onRemove();
1392 AssertRCReturn(rc, rc);
1393
1394 mData.mFiles.erase(itFiles);
1395
1396 alock.release(); /* Release lock before firing off event. */
1397
1398 fireGuestFileRegisteredEvent(mEventSource, this, pFileConsumed, false /* Unregistered */);
1399
1400 pFileConsumed.setNull();
1401
1402 LogFlowFuncLeaveRC(rc);
1403 return rc;
1404}
1405
1406int GuestSession::i_fileRemove(const Utf8Str &strPath, int *prcGuest)
1407{
1408 LogFlowThisFunc(("strPath=%s\n", strPath.c_str()));
1409
1410 int vrc = VINF_SUCCESS;
1411
1412 GuestProcessStartupInfo procInfo;
1413 GuestProcessStream streamOut;
1414
1415 procInfo.mFlags = ProcessCreateFlag_WaitForStdOut;
1416 procInfo.mExecutable = Utf8Str(VBOXSERVICE_TOOL_RM);
1417
1418 try
1419 {
1420 procInfo.mArguments.push_back(procInfo.mExecutable); /* Set argv0. */
1421 procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
1422 procInfo.mArguments.push_back("--"); /* strPath could be '--help', which is a valid filename. */
1423 procInfo.mArguments.push_back(strPath); /* The file we want to remove. */
1424 }
1425 catch (std::bad_alloc)
1426 {
1427 vrc = VERR_NO_MEMORY;
1428 }
1429
1430 if (RT_SUCCESS(vrc))
1431 vrc = GuestProcessTool::run(this, procInfo, prcGuest);
1432
1433 LogFlowFuncLeaveRC(vrc);
1434 return vrc;
1435}
1436
1437int GuestSession::i_fileOpenEx(const com::Utf8Str &aPath, FileAccessMode_T aAccessMode, FileOpenAction_T aOpenAction,
1438 FileSharingMode_T aSharingMode, ULONG aCreationMode, const std::vector<FileOpenExFlag_T> &aFlags,
1439 ComObjPtr<GuestFile> &pFile, int *prcGuest)
1440{
1441 GuestFileOpenInfo openInfo;
1442 RT_ZERO(openInfo);
1443
1444 openInfo.mFileName = aPath;
1445 openInfo.mCreationMode = aCreationMode;
1446 openInfo.mAccessMode = aAccessMode;
1447 openInfo.mOpenAction = aOpenAction;
1448 openInfo.mSharingMode = aSharingMode;
1449
1450 /* Combine and validate flags. */
1451 uint32_t fOpenEx = 0;
1452 for (size_t i = 0; i < aFlags.size(); i++)
1453 fOpenEx = aFlags[i];
1454 if (fOpenEx)
1455 return VERR_INVALID_PARAMETER; /* FileOpenExFlag not implemented yet. */
1456 openInfo.mfOpenEx = fOpenEx;
1457
1458 return i_fileOpen(openInfo, pFile, prcGuest);
1459}
1460
1461int GuestSession::i_fileOpen(const GuestFileOpenInfo &openInfo, ComObjPtr<GuestFile> &pFile, int *prcGuest)
1462{
1463 LogFlowThisFunc(("strFile=%s, enmAccessMode=0x%x, enmOpenAction=0x%x, uCreationMode=%RU32, mfOpenEx=%RU32\n",
1464 openInfo.mFileName.c_str(), openInfo.mAccessMode, openInfo.mOpenAction, openInfo.mCreationMode,
1465 openInfo.mfOpenEx));
1466
1467 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1468
1469 /* Guest Additions < 4.3 don't support handling guest files, skip. */
1470 if (mData.mProtocolVersion < 2)
1471 {
1472 if (prcGuest)
1473 *prcGuest = VERR_NOT_SUPPORTED;
1474 return VERR_GSTCTL_GUEST_ERROR;
1475 }
1476
1477 /* Register a new object ID. */
1478 uint32_t uObjectID;
1479 int rc = i_objectRegister(SESSIONOBJECTTYPE_FILE, &uObjectID);
1480 if (RT_FAILURE(rc))
1481 return rc;
1482
1483 /* Create the directory object. */
1484 HRESULT hr = pFile.createObject();
1485 if (FAILED(hr))
1486 return VERR_COM_UNEXPECTED;
1487
1488 Console *pConsole = mParent->i_getConsole();
1489 AssertPtr(pConsole);
1490
1491 rc = pFile->init(pConsole, this /* GuestSession */, uObjectID, openInfo);
1492 if (RT_FAILURE(rc))
1493 return rc;
1494
1495 /*
1496 * Since this is a synchronous guest call we have to
1497 * register the file object first, releasing the session's
1498 * lock and then proceed with the actual opening command
1499 * -- otherwise the file's opening callback would hang
1500 * because the session's lock still is in place.
1501 */
1502 try
1503 {
1504 /* Add the created file to our vector. */
1505 mData.mFiles[uObjectID] = pFile;
1506
1507 LogFlowFunc(("Added new guest file \"%s\" (Session: %RU32) (now total %zu files)\n",
1508 openInfo.mFileName.c_str(), mData.mSession.mID, mData.mFiles.size()));
1509
1510 alock.release(); /* Release lock before firing off event. */
1511
1512 fireGuestFileRegisteredEvent(mEventSource, this, pFile, true /* Registered */);
1513 }
1514 catch (std::bad_alloc &)
1515 {
1516 rc = VERR_NO_MEMORY;
1517 }
1518
1519 if (RT_SUCCESS(rc))
1520 {
1521 int rcGuest;
1522 rc = pFile->i_openFile(30 * 1000 /* 30s timeout */, &rcGuest);
1523 if ( rc == VERR_GSTCTL_GUEST_ERROR
1524 && prcGuest)
1525 {
1526 *prcGuest = rcGuest;
1527 }
1528 }
1529
1530 LogFlowFuncLeaveRC(rc);
1531 return rc;
1532}
1533
1534int GuestSession::i_fileQueryInfo(const Utf8Str &strPath, bool fFollowSymlinks, GuestFsObjData &objData, int *prcGuest)
1535{
1536 LogFlowThisFunc(("strPath=%s fFollowSymlinks=%RTbool\n", strPath.c_str(), fFollowSymlinks));
1537
1538 int vrc = i_fsQueryInfo(strPath, fFollowSymlinks, objData, prcGuest);
1539 if (RT_SUCCESS(vrc))
1540 {
1541 vrc = objData.mType == FsObjType_File
1542 ? VINF_SUCCESS : VERR_NOT_A_FILE;
1543 }
1544
1545 LogFlowFuncLeaveRC(vrc);
1546 return vrc;
1547}
1548
1549int GuestSession::i_fileQuerySize(const Utf8Str &strPath, bool fFollowSymlinks, int64_t *pllSize, int *prcGuest)
1550{
1551 AssertPtrReturn(pllSize, VERR_INVALID_POINTER);
1552
1553 GuestFsObjData objData;
1554 int vrc = i_fileQueryInfo(strPath, fFollowSymlinks, objData, prcGuest);
1555 if (RT_SUCCESS(vrc))
1556 *pllSize = objData.mObjectSize;
1557
1558 return vrc;
1559}
1560
1561/**
1562 * Queries information of a file system object (file, directory, ...).
1563 *
1564 * @return IPRT status code.
1565 * @param strPath Path to file system object to query information for.
1566 * @param fFollowSymlinks Whether to follow symbolic links or not.
1567 * @param objData Where to return the file system object data, if found.
1568 * @param prcGuest Guest rc, when returning VERR_GSTCTL_GUEST_ERROR.
1569 * Any other return code indicates some host side error.
1570 */
1571int GuestSession::i_fsQueryInfo(const Utf8Str &strPath, bool fFollowSymlinks, GuestFsObjData &objData, int *prcGuest)
1572{
1573 LogFlowThisFunc(("strPath=%s\n", strPath.c_str()));
1574
1575 /** @todo Merge this with IGuestFile::queryInfo(). */
1576 GuestProcessStartupInfo procInfo;
1577 procInfo.mFlags = ProcessCreateFlag_WaitForStdOut;
1578 try
1579 {
1580 procInfo.mExecutable = Utf8Str(VBOXSERVICE_TOOL_STAT);
1581 procInfo.mArguments.push_back(procInfo.mExecutable); /* Set argv0. */
1582 procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
1583 if (fFollowSymlinks)
1584 procInfo.mArguments.push_back(Utf8Str("-L"));
1585 procInfo.mArguments.push_back("--"); /* strPath could be '--help', which is a valid filename. */
1586 procInfo.mArguments.push_back(strPath);
1587 }
1588 catch (std::bad_alloc)
1589 {
1590 Log(("Out of memory!\n"));
1591 return VERR_NO_MEMORY;
1592 }
1593
1594 int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
1595 GuestCtrlStreamObjects stdOut;
1596 int vrc = GuestProcessTool::runEx(this, procInfo,
1597 &stdOut, 1 /* cStrmOutObjects */,
1598 &vrcGuest);
1599 if (!GuestProcess::i_isGuestError(vrc))
1600 {
1601 if (!stdOut.empty())
1602 {
1603 vrc = objData.FromStat(stdOut.at(0));
1604 if (RT_FAILURE(vrc))
1605 {
1606 vrcGuest = vrc;
1607 if (prcGuest)
1608 *prcGuest = vrc;
1609 vrc = VERR_GSTCTL_GUEST_ERROR;
1610 }
1611 }
1612 else
1613 vrc = VERR_BROKEN_PIPE;
1614 }
1615 else if (prcGuest)
1616 *prcGuest = vrcGuest;
1617
1618 LogFlowThisFunc(("Returning vrc=%Rrc, vrcGuest=%Rrc\n", vrc, vrcGuest));
1619 return vrc;
1620}
1621
1622const GuestCredentials& GuestSession::i_getCredentials(void)
1623{
1624 return mData.mCredentials;
1625}
1626
1627Utf8Str GuestSession::i_getName(void)
1628{
1629 return mData.mSession.mName;
1630}
1631
1632/* static */
1633Utf8Str GuestSession::i_guestErrorToString(int rcGuest)
1634{
1635 Utf8Str strError;
1636
1637 /** @todo pData->u32Flags: int vs. uint32 -- IPRT errors are *negative* !!! */
1638 switch (rcGuest)
1639 {
1640 case VERR_INVALID_VM_HANDLE:
1641 strError += Utf8StrFmt(tr("VMM device is not available (is the VM running?)"));
1642 break;
1643
1644 case VERR_HGCM_SERVICE_NOT_FOUND:
1645 strError += Utf8StrFmt(tr("The guest execution service is not available"));
1646 break;
1647
1648 case VERR_ACCOUNT_RESTRICTED:
1649 strError += Utf8StrFmt(tr("The specified user account on the guest is restricted and can't be used to logon"));
1650 break;
1651
1652 case VERR_AUTHENTICATION_FAILURE:
1653 strError += Utf8StrFmt(tr("The specified user was not able to logon on guest"));
1654 break;
1655
1656 case VERR_TIMEOUT:
1657 strError += Utf8StrFmt(tr("The guest did not respond within time"));
1658 break;
1659
1660 case VERR_CANCELLED:
1661 strError += Utf8StrFmt(tr("The session operation was canceled"));
1662 break;
1663
1664 case VERR_PERMISSION_DENIED: /** @todo r=bird: This is probably completely and utterly misleading. VERR_AUTHENTICATION_FAILURE could have this message. */
1665 strError += Utf8StrFmt(tr("Invalid user/password credentials"));
1666 break;
1667
1668 case VERR_GSTCTL_MAX_OBJECTS_REACHED:
1669 strError += Utf8StrFmt(tr("Maximum number of concurrent guest processes has been reached"));
1670 break;
1671
1672 case VERR_NOT_FOUND:
1673 strError += Utf8StrFmt(tr("The guest execution service is not ready (yet)"));
1674 break;
1675
1676 default:
1677 strError += Utf8StrFmt("%Rrc", rcGuest);
1678 break;
1679 }
1680
1681 return strError;
1682}
1683
1684/**
1685 * Checks if this session is ready state where it can handle
1686 * all session-bound actions (like guest processes, guest files).
1687 * Only used by official API methods. Will set an external
1688 * error when not ready.
1689 */
1690HRESULT GuestSession::i_isReadyExternal(void)
1691{
1692 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1693
1694 /** @todo Be a bit more informative. */
1695 if (mData.mStatus != GuestSessionStatus_Started)
1696 return setError(E_UNEXPECTED, tr("Session is not in started state"));
1697
1698 return S_OK;
1699}
1700
1701/**
1702 * Called by IGuest right before this session gets removed from
1703 * the public session list.
1704 */
1705int GuestSession::i_onRemove(void)
1706{
1707 LogFlowThisFuncEnter();
1708
1709 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1710
1711 int vrc = VINF_SUCCESS;
1712
1713 /*
1714 * Note: The event source stuff holds references to this object,
1715 * so make sure that this is cleaned up *before* calling uninit.
1716 */
1717 if (!mEventSource.isNull())
1718 {
1719 mEventSource->UnregisterListener(mLocalListener);
1720
1721 mLocalListener.setNull();
1722 unconst(mEventSource).setNull();
1723 }
1724
1725 LogFlowFuncLeaveRC(vrc);
1726 return vrc;
1727}
1728
1729/** No locking! */
1730int GuestSession::i_onSessionStatusChange(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
1731{
1732 AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
1733 /* pCallback is optional. */
1734 AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
1735
1736 if (pSvcCbData->mParms < 3)
1737 return VERR_INVALID_PARAMETER;
1738
1739 CALLBACKDATA_SESSION_NOTIFY dataCb;
1740 /* pSvcCb->mpaParms[0] always contains the context ID. */
1741 int vrc = pSvcCbData->mpaParms[1].getUInt32(&dataCb.uType);
1742 AssertRCReturn(vrc, vrc);
1743 vrc = pSvcCbData->mpaParms[2].getUInt32(&dataCb.uResult);
1744 AssertRCReturn(vrc, vrc);
1745
1746 LogFlowThisFunc(("ID=%RU32, uType=%RU32, rcGuest=%Rrc\n",
1747 mData.mSession.mID, dataCb.uType, dataCb.uResult));
1748
1749 GuestSessionStatus_T sessionStatus = GuestSessionStatus_Undefined;
1750
1751 int rcGuest = dataCb.uResult; /** @todo uint32_t vs. int. */
1752 switch (dataCb.uType)
1753 {
1754 case GUEST_SESSION_NOTIFYTYPE_ERROR:
1755 sessionStatus = GuestSessionStatus_Error;
1756 break;
1757
1758 case GUEST_SESSION_NOTIFYTYPE_STARTED:
1759 sessionStatus = GuestSessionStatus_Started;
1760#if 0 /** @todo If we get some environment stuff along with this kind notification: */
1761 const char *pszzEnvBlock = ...;
1762 uint32_t cbEnvBlock = ...;
1763 if (!mData.mpBaseEnvironment)
1764 {
1765 GuestEnvironment *pBaseEnv;
1766 try { pBaseEnv = new GuestEnvironment(); } catch (std::bad_alloc &) { pBaseEnv = NULL; }
1767 if (pBaseEnv)
1768 {
1769 int vrc = pBaseEnv->initNormal();
1770 if (RT_SUCCESS(vrc))
1771 vrc = pBaseEnv->copyUtf8Block(pszzEnvBlock, cbEnvBlock);
1772 if (RT_SUCCESS(vrc))
1773 mData.mpBaseEnvironment = pBaseEnv;
1774 else
1775 pBaseEnv->release();
1776 }
1777 }
1778#endif
1779 break;
1780
1781 case GUEST_SESSION_NOTIFYTYPE_TEN:
1782 case GUEST_SESSION_NOTIFYTYPE_TES:
1783 case GUEST_SESSION_NOTIFYTYPE_TEA:
1784 sessionStatus = GuestSessionStatus_Terminated;
1785 break;
1786
1787 case GUEST_SESSION_NOTIFYTYPE_TOK:
1788 sessionStatus = GuestSessionStatus_TimedOutKilled;
1789 break;
1790
1791 case GUEST_SESSION_NOTIFYTYPE_TOA:
1792 sessionStatus = GuestSessionStatus_TimedOutAbnormally;
1793 break;
1794
1795 case GUEST_SESSION_NOTIFYTYPE_DWN:
1796 sessionStatus = GuestSessionStatus_Down;
1797 break;
1798
1799 case GUEST_SESSION_NOTIFYTYPE_UNDEFINED:
1800 default:
1801 vrc = VERR_NOT_SUPPORTED;
1802 break;
1803 }
1804
1805 if (RT_SUCCESS(vrc))
1806 {
1807 if (RT_FAILURE(rcGuest))
1808 sessionStatus = GuestSessionStatus_Error;
1809 }
1810
1811 /* Set the session status. */
1812 if (RT_SUCCESS(vrc))
1813 vrc = i_setSessionStatus(sessionStatus, rcGuest);
1814
1815 LogFlowThisFunc(("ID=%RU32, rcGuest=%Rrc\n", mData.mSession.mID, rcGuest));
1816
1817 LogFlowFuncLeaveRC(vrc);
1818 return vrc;
1819}
1820
1821PathStyle_T GuestSession::i_getPathStyle(void)
1822{
1823 PathStyle_T enmPathStyle;
1824
1825 VBOXOSTYPE enmOsType = mParent->i_getGuestOSType();
1826 if (enmOsType < VBOXOSTYPE_DOS)
1827 {
1828 LogFlowFunc(("returns PathStyle_Unknown\n"));
1829 enmPathStyle = PathStyle_Unknown;
1830 }
1831 else if (enmOsType < VBOXOSTYPE_Linux)
1832 {
1833 LogFlowFunc(("returns PathStyle_DOS\n"));
1834 enmPathStyle = PathStyle_DOS;
1835 }
1836 else
1837 {
1838 LogFlowFunc(("returns PathStyle_UNIX\n"));
1839 enmPathStyle = PathStyle_UNIX;
1840 }
1841
1842 return enmPathStyle;
1843}
1844
1845int GuestSession::i_startSession(int *prcGuest)
1846{
1847 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1848
1849 LogFlowThisFunc(("mID=%RU32, mName=%s, uProtocolVersion=%RU32, openFlags=%x, openTimeoutMS=%RU32\n",
1850 mData.mSession.mID, mData.mSession.mName.c_str(), mData.mProtocolVersion,
1851 mData.mSession.mOpenFlags, mData.mSession.mOpenTimeoutMS));
1852
1853 /* Guest Additions < 4.3 don't support opening dedicated
1854 guest sessions. Simply return success here. */
1855 if (mData.mProtocolVersion < 2)
1856 {
1857 mData.mStatus = GuestSessionStatus_Started;
1858
1859 LogFlowThisFunc(("Installed Guest Additions don't support opening dedicated sessions, skipping\n"));
1860 return VINF_SUCCESS;
1861 }
1862
1863 if (mData.mStatus != GuestSessionStatus_Undefined)
1864 return VINF_SUCCESS;
1865
1866 /** @todo mData.mSession.uFlags validation. */
1867
1868 /* Set current session status. */
1869 mData.mStatus = GuestSessionStatus_Starting;
1870 mData.mRC = VINF_SUCCESS; /* Clear previous error, if any. */
1871
1872 int vrc;
1873
1874 GuestWaitEvent *pEvent = NULL;
1875 GuestEventTypes eventTypes;
1876 try
1877 {
1878 eventTypes.push_back(VBoxEventType_OnGuestSessionStateChanged);
1879
1880 vrc = registerWaitEventEx(mData.mSession.mID, mData.mObjectID, eventTypes, &pEvent);
1881 }
1882 catch (std::bad_alloc)
1883 {
1884 vrc = VERR_NO_MEMORY;
1885 }
1886
1887 if (RT_FAILURE(vrc))
1888 return vrc;
1889
1890 VBOXHGCMSVCPARM paParms[8];
1891
1892 int i = 0;
1893 paParms[i++].setUInt32(pEvent->ContextID());
1894 paParms[i++].setUInt32(mData.mProtocolVersion);
1895 paParms[i++].setPointer((void*)mData.mCredentials.mUser.c_str(),
1896 (ULONG)mData.mCredentials.mUser.length() + 1);
1897 paParms[i++].setPointer((void*)mData.mCredentials.mPassword.c_str(),
1898 (ULONG)mData.mCredentials.mPassword.length() + 1);
1899 paParms[i++].setPointer((void*)mData.mCredentials.mDomain.c_str(),
1900 (ULONG)mData.mCredentials.mDomain.length() + 1);
1901 paParms[i++].setUInt32(mData.mSession.mOpenFlags);
1902
1903 alock.release(); /* Drop write lock before sending. */
1904
1905 vrc = i_sendCommand(HOST_SESSION_CREATE, i, paParms);
1906 if (RT_SUCCESS(vrc))
1907 {
1908 vrc = i_waitForStatusChange(pEvent, GuestSessionWaitForFlag_Start,
1909 30 * 1000 /* 30s timeout */,
1910 NULL /* Session status */, prcGuest);
1911 }
1912 else
1913 {
1914 /*
1915 * Unable to start guest session - update its current state.
1916 * Since there is no (official API) way to recover a failed guest session
1917 * this also marks the end state. Internally just calling this
1918 * same function again will work though.
1919 */
1920 mData.mStatus = GuestSessionStatus_Error;
1921 mData.mRC = vrc;
1922 }
1923
1924 unregisterWaitEvent(pEvent);
1925
1926 LogFlowFuncLeaveRC(vrc);
1927 return vrc;
1928}
1929
1930int GuestSession::i_startSessionAsync(void)
1931{
1932 LogFlowThisFuncEnter();
1933
1934 int vrc;
1935 GuestSessionTaskInternalOpen* pTask = NULL;
1936 try
1937 {
1938 pTask = new GuestSessionTaskInternalOpen(this);
1939 if (!pTask->isOk())
1940 {
1941 delete pTask;
1942 LogFlow(("GuestSession: Could not create GuestSessionTaskInternalOpen object \n"));
1943 throw VERR_MEMOBJ_INIT_FAILED;
1944 }
1945
1946 /* Asynchronously open the session on the guest by kicking off a
1947 * worker thread. */
1948 //this function delete pTask in case of exceptions, so there is no need in the call of delete operator
1949 HRESULT hrc = pTask->createThread();
1950 vrc = Global::vboxStatusCodeFromCOM(hrc);
1951 }
1952 catch(std::bad_alloc &)
1953 {
1954 vrc = VERR_NO_MEMORY;
1955 }
1956 catch(int eVRC)
1957 {
1958 vrc = eVRC;
1959 LogFlow(("GuestSession: Could not create thread for GuestSessionTaskInternalOpen task %Rrc\n", vrc));
1960 }
1961
1962 LogFlowFuncLeaveRC(vrc);
1963 return vrc;
1964}
1965
1966/* static */
1967void GuestSession::i_startSessionThreadTask(GuestSessionTaskInternalOpen *pTask)
1968{
1969 LogFlowFunc(("pTask=%p\n", pTask));
1970 AssertPtr(pTask);
1971
1972 const ComObjPtr<GuestSession> pSession(pTask->Session());
1973 Assert(!pSession.isNull());
1974
1975 AutoCaller autoCaller(pSession);
1976 if (FAILED(autoCaller.rc()))
1977 return;
1978
1979 int vrc = pSession->i_startSession(NULL /* Guest rc, ignored */);
1980/** @todo
1981 *
1982 * r=bird: Is it okay to ignore @a vrc here?
1983 *
1984 */
1985
1986 /* Nothing to do here anymore. */
1987
1988 LogFlowFuncLeaveRC(vrc);
1989 NOREF(vrc);
1990}
1991
1992/**
1993 * Registers an object to a session.
1994 *
1995 * @return VBox status code.
1996 * @param enmType Session object type to register.
1997 * @param puObjectID Returns registered object ID on success. Optional.
1998 */
1999int GuestSession::i_objectRegister(SESSIONOBJECTTYPE enmType, uint32_t *puObjectID)
2000{
2001 return i_objectRegisterEx(enmType, 0 /* fFlags */, puObjectID);
2002}
2003
2004/**
2005 * Registers an object to a session, extended version.
2006 *
2007 * @return VBox status code. VERR_GSTCTL_MAX_OBJECTS_REACHED if the maximum of concurrent objects is reached.
2008 * @param enmType Session object type to register.
2009 * @param fFlags Registration flags. Not used yet and must be 0.
2010 * @param puObjectID Returns registered object ID on success. Optional.
2011 */
2012int GuestSession::i_objectRegisterEx(SESSIONOBJECTTYPE enmType, uint32_t fFlags, uint32_t *puObjectID)
2013{
2014 RT_NOREF(fFlags);
2015 AssertReturn(fFlags == 0, VERR_INVALID_PARAMETER);
2016
2017 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2018
2019 int rc = VINF_SUCCESS;
2020
2021 uint32_t uObjectID = 0; /* Shut up MSVC. */
2022
2023 if (mData.mObjects.size() < VBOX_GUESTCTRL_MAX_OBJECTS - 1 /* Minus 1 for the session itself */)
2024 {
2025 SessionObjects::reverse_iterator itRend = mData.mObjects.rbegin();
2026 if (itRend != mData.mObjects.rend())
2027 uObjectID = itRend->first + 1; /* Last key plus 1. */
2028 else
2029 uObjectID = 0;
2030 }
2031 else
2032 {
2033 /* Utilize our "free list" to get the next free object ID in the map. */
2034 if (mData.mObjectsFree.size())
2035 {
2036 /* Always re-use the oldest object ID to avoid trouble. */
2037 uObjectID = mData.mObjectsFree.front();
2038 mData.mObjectsFree.pop_front();
2039 }
2040 else
2041 rc = VERR_GSTCTL_MAX_OBJECTS_REACHED;
2042 }
2043
2044 Log2Func(("enmType=%RU32, fFlags=%RU32 -> uObjectID=%RU32 (%zu objects, %zu on free list), rc=%Rrc\n",
2045 enmType, fFlags, uObjectID, mData.mObjects.size(), mData.mObjectsFree.size(), rc));
2046
2047 if (RT_SUCCESS(rc))
2048 {
2049 mData.mObjects[uObjectID].enmType = enmType;
2050 mData.mObjects[uObjectID].tsCreatedMs = RTTimeMilliTS();
2051
2052 if (puObjectID)
2053 *puObjectID = uObjectID;
2054 }
2055
2056 return rc;
2057}
2058
2059/**
2060 * Unregisters a formerly registered object from a session.
2061 *
2062 * @return VBox status code. VERR_NOT_FOUND if object to unregister was not found.
2063 * @param uObjectID Object ID to unregister.
2064 */
2065int GuestSession::i_objectUnregister(uint32_t uObjectID)
2066{
2067 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2068
2069 SessionObjects::const_iterator itObj = mData.mObjects.find(uObjectID);
2070 if (itObj != mData.mObjects.end())
2071 {
2072 Log2Func(("uObjectID=%RU32 (now %zu objects in free list)\n", uObjectID, mData.mObjectsFree.size()));
2073
2074 /* Note: Do not remove object from object list (mData.mObjects) here, as we continue operating
2075 * on the free list (mData.mObjectsFree) if we reached the object list's maximum. */
2076
2077 mData.mObjectsFree.push_back(uObjectID);
2078 Assert(mData.mObjectsFree.size() <= VBOX_GUESTCTRL_MAX_OBJECTS);
2079 return VINF_SUCCESS;
2080 }
2081
2082 AssertFailed();
2083 return VERR_NOT_FOUND;
2084}
2085
2086int GuestSession::i_pathRename(const Utf8Str &strSource, const Utf8Str &strDest, uint32_t uFlags, int *prcGuest)
2087{
2088 AssertReturn(!(uFlags & ~PATHRENAME_FLAG_VALID_MASK), VERR_INVALID_PARAMETER);
2089
2090 LogFlowThisFunc(("strSource=%s, strDest=%s, uFlags=0x%x\n",
2091 strSource.c_str(), strDest.c_str(), uFlags));
2092
2093 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2094
2095 GuestWaitEvent *pEvent = NULL;
2096 int vrc = registerWaitEvent(mData.mSession.mID, mData.mObjectID, &pEvent);
2097 if (RT_FAILURE(vrc))
2098 return vrc;
2099
2100 /* Prepare HGCM call. */
2101 VBOXHGCMSVCPARM paParms[8];
2102 int i = 0;
2103 paParms[i++].setUInt32(pEvent->ContextID());
2104 paParms[i++].setPointer((void*)strSource.c_str(),
2105 (ULONG)strSource.length() + 1);
2106 paParms[i++].setPointer((void*)strDest.c_str(),
2107 (ULONG)strDest.length() + 1);
2108 paParms[i++].setUInt32(uFlags);
2109
2110 alock.release(); /* Drop write lock before sending. */
2111
2112 vrc = i_sendCommand(HOST_PATH_RENAME, i, paParms);
2113 if (RT_SUCCESS(vrc))
2114 {
2115 vrc = pEvent->Wait(30 * 1000);
2116 if ( vrc == VERR_GSTCTL_GUEST_ERROR
2117 && prcGuest)
2118 *prcGuest = pEvent->GuestResult();
2119 }
2120
2121 unregisterWaitEvent(pEvent);
2122
2123 LogFlowFuncLeaveRC(vrc);
2124 return vrc;
2125}
2126
2127/**
2128 * Returns the user's absolute documents path, if any.
2129 *
2130 * @return VBox status code.
2131 * @param strPath Where to store the user's document path.
2132 * @param prcGuest Guest rc, when returning VERR_GSTCTL_GUEST_ERROR.
2133 * Any other return code indicates some host side error.
2134 */
2135int GuestSession::i_pathUserDocuments(Utf8Str &strPath, int *prcGuest)
2136{
2137 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2138
2139 /** @todo Cache the user's document path? */
2140
2141 GuestWaitEvent *pEvent = NULL;
2142 int vrc = registerWaitEvent(mData.mSession.mID, mData.mObjectID, &pEvent);
2143 if (RT_FAILURE(vrc))
2144 return vrc;
2145
2146 /* Prepare HGCM call. */
2147 VBOXHGCMSVCPARM paParms[2];
2148 int i = 0;
2149 paParms[i++].setUInt32(pEvent->ContextID());
2150
2151 alock.release(); /* Drop write lock before sending. */
2152
2153 vrc = i_sendCommand(HOST_PATH_USER_DOCUMENTS, i, paParms);
2154 if (RT_SUCCESS(vrc))
2155 {
2156 vrc = pEvent->Wait(30 * 1000);
2157 if (RT_SUCCESS(vrc))
2158 {
2159 strPath = pEvent->Payload().ToString();
2160 }
2161 else
2162 {
2163 if (vrc == VERR_GSTCTL_GUEST_ERROR)
2164 {
2165 if (prcGuest)
2166 *prcGuest = pEvent->GuestResult();
2167 }
2168 }
2169 }
2170
2171 unregisterWaitEvent(pEvent);
2172
2173 LogFlowFuncLeaveRC(vrc);
2174 return vrc;
2175}
2176
2177/**
2178 * Returns the user's absolute home path, if any.
2179 *
2180 * @return VBox status code.
2181 * @param strPath Where to store the user's home path.
2182 * @param prcGuest Guest rc, when returning VERR_GSTCTL_GUEST_ERROR.
2183 * Any other return code indicates some host side error.
2184 */
2185int GuestSession::i_pathUserHome(Utf8Str &strPath, int *prcGuest)
2186{
2187 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2188
2189 /** @todo Cache the user's home path? */
2190
2191 GuestWaitEvent *pEvent = NULL;
2192 int vrc = registerWaitEvent(mData.mSession.mID, mData.mObjectID, &pEvent);
2193 if (RT_FAILURE(vrc))
2194 return vrc;
2195
2196 /* Prepare HGCM call. */
2197 VBOXHGCMSVCPARM paParms[2];
2198 int i = 0;
2199 paParms[i++].setUInt32(pEvent->ContextID());
2200
2201 alock.release(); /* Drop write lock before sending. */
2202
2203 vrc = i_sendCommand(HOST_PATH_USER_HOME, i, paParms);
2204 if (RT_SUCCESS(vrc))
2205 {
2206 vrc = pEvent->Wait(30 * 1000);
2207 if (RT_SUCCESS(vrc))
2208 {
2209 strPath = pEvent->Payload().ToString();
2210 }
2211 else
2212 {
2213 if (vrc == VERR_GSTCTL_GUEST_ERROR)
2214 {
2215 if (prcGuest)
2216 *prcGuest = pEvent->GuestResult();
2217 }
2218 }
2219 }
2220
2221 unregisterWaitEvent(pEvent);
2222
2223 LogFlowFuncLeaveRC(vrc);
2224 return vrc;
2225}
2226
2227/**
2228 * Unregisters a process object from a session.
2229 *
2230 * @return VBox status code. VERR_NOT_FOUND if the process is not registered (anymore).
2231 * @param pProcess Process object to unregister from session.
2232 */
2233int GuestSession::i_processUnregister(GuestProcess *pProcess)
2234{
2235 AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
2236
2237 LogFlowThisFunc(("pProcess=%p\n", pProcess));
2238
2239 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2240
2241 const uint32_t uObjectID = pProcess->getObjectID();
2242
2243 LogFlowFunc(("Removing process (objectID=%RU32) ...\n", uObjectID));
2244
2245 int rc = i_objectUnregister(uObjectID);
2246 if (RT_FAILURE(rc))
2247 return rc;
2248
2249 SessionProcesses::iterator itProcs = mData.mProcesses.find(uObjectID);
2250 AssertReturn(itProcs != mData.mProcesses.end(), VERR_NOT_FOUND);
2251
2252 /* Make sure to consume the pointer before the one of the iterator gets released. */
2253 ComObjPtr<GuestProcess> pProc = pProcess;
2254
2255 ULONG uPID;
2256 HRESULT hr = pProc->COMGETTER(PID)(&uPID);
2257 ComAssertComRC(hr);
2258
2259 LogFlowFunc(("Removing process ID=%RU32 (session %RU32, guest PID %RU32, now total %zu processes)\n",
2260 uObjectID, mData.mSession.mID, uPID, mData.mProcesses.size()));
2261
2262 rc = pProcess->i_onRemove();
2263 AssertRCReturn(rc, rc);
2264
2265 mData.mProcesses.erase(itProcs);
2266
2267 alock.release(); /* Release lock before firing off event. */
2268
2269 fireGuestProcessRegisteredEvent(mEventSource, this /* Session */, pProc, uPID, false /* Process unregistered */);
2270
2271 pProc.setNull();
2272
2273 LogFlowFuncLeaveRC(rc);
2274 return rc;
2275}
2276
2277/**
2278 * Creates but does *not* start the process yet.
2279 *
2280 * See GuestProcess::startProcess() or GuestProcess::startProcessAsync() for
2281 * starting the process.
2282 *
2283 * @return IPRT status code.
2284 * @param procInfo
2285 * @param pProcess
2286 */
2287int GuestSession::i_processCreateEx(GuestProcessStartupInfo &procInfo, ComObjPtr<GuestProcess> &pProcess)
2288{
2289 LogFlowFunc(("mExe=%s, mFlags=%x, mTimeoutMS=%RU32\n",
2290 procInfo.mExecutable.c_str(), procInfo.mFlags, procInfo.mTimeoutMS));
2291#ifdef DEBUG
2292 if (procInfo.mArguments.size())
2293 {
2294 LogFlowFunc(("Arguments:"));
2295 ProcessArguments::const_iterator it = procInfo.mArguments.begin();
2296 while (it != procInfo.mArguments.end())
2297 {
2298 LogFlow((" %s", (*it).c_str()));
2299 ++it;
2300 }
2301 LogFlow(("\n"));
2302 }
2303#endif
2304
2305 /* Validate flags. */
2306 if (procInfo.mFlags)
2307 {
2308 if ( !(procInfo.mFlags & ProcessCreateFlag_IgnoreOrphanedProcesses)
2309 && !(procInfo.mFlags & ProcessCreateFlag_WaitForProcessStartOnly)
2310 && !(procInfo.mFlags & ProcessCreateFlag_Hidden)
2311 && !(procInfo.mFlags & ProcessCreateFlag_Profile)
2312 && !(procInfo.mFlags & ProcessCreateFlag_WaitForStdOut)
2313 && !(procInfo.mFlags & ProcessCreateFlag_WaitForStdErr))
2314 {
2315 return VERR_INVALID_PARAMETER;
2316 }
2317 }
2318
2319 if ( (procInfo.mFlags & ProcessCreateFlag_WaitForProcessStartOnly)
2320 && ( (procInfo.mFlags & ProcessCreateFlag_WaitForStdOut)
2321 || (procInfo.mFlags & ProcessCreateFlag_WaitForStdErr)
2322 )
2323 )
2324 {
2325 return VERR_INVALID_PARAMETER;
2326 }
2327
2328 /* Adjust timeout.
2329 * If set to 0, we define an infinite timeout (unlimited process run time). */
2330 if (procInfo.mTimeoutMS == 0)
2331 procInfo.mTimeoutMS = UINT32_MAX;
2332
2333 /** @todo Implement process priority + affinity. */
2334
2335 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2336
2337 /* Register a new object ID. */
2338 uint32_t uObjectID;
2339 int rc = i_objectRegister(SESSIONOBJECTTYPE_PROCESS, &uObjectID);
2340 if (RT_FAILURE(rc))
2341 return rc;
2342
2343 /* Create the process object. */
2344 HRESULT hr = pProcess.createObject();
2345 if (FAILED(hr))
2346 return VERR_COM_UNEXPECTED;
2347
2348 rc = pProcess->init(mParent->i_getConsole() /* Console */, this /* Session */, uObjectID,
2349 procInfo, mData.mpBaseEnvironment);
2350 if (RT_FAILURE(rc))
2351 return rc;
2352
2353 /* Add the created process to our map. */
2354 try
2355 {
2356 mData.mProcesses[uObjectID] = pProcess;
2357
2358 LogFlowFunc(("Added new process (Session: %RU32) with process ID=%RU32 (now total %zu processes)\n",
2359 mData.mSession.mID, uObjectID, mData.mProcesses.size()));
2360
2361 alock.release(); /* Release lock before firing off event. */
2362
2363 fireGuestProcessRegisteredEvent(mEventSource, this /* Session */, pProcess, 0 /* PID */, true /* Process registered */);
2364 }
2365 catch (std::bad_alloc &)
2366 {
2367 rc = VERR_NO_MEMORY;
2368 }
2369
2370 return rc;
2371}
2372
2373inline bool GuestSession::i_processExists(uint32_t uProcessID, ComObjPtr<GuestProcess> *pProcess)
2374{
2375 SessionProcesses::const_iterator it = mData.mProcesses.find(uProcessID);
2376 if (it != mData.mProcesses.end())
2377 {
2378 if (pProcess)
2379 *pProcess = it->second;
2380 return true;
2381 }
2382 return false;
2383}
2384
2385inline int GuestSession::i_processGetByPID(ULONG uPID, ComObjPtr<GuestProcess> *pProcess)
2386{
2387 AssertReturn(uPID, false);
2388 /* pProcess is optional. */
2389
2390 SessionProcesses::iterator itProcs = mData.mProcesses.begin();
2391 for (; itProcs != mData.mProcesses.end(); ++itProcs)
2392 {
2393 ComObjPtr<GuestProcess> pCurProc = itProcs->second;
2394 AutoCaller procCaller(pCurProc);
2395 if (procCaller.rc())
2396 return VERR_COM_INVALID_OBJECT_STATE;
2397
2398 ULONG uCurPID;
2399 HRESULT hr = pCurProc->COMGETTER(PID)(&uCurPID);
2400 ComAssertComRC(hr);
2401
2402 if (uCurPID == uPID)
2403 {
2404 if (pProcess)
2405 *pProcess = pCurProc;
2406 return VINF_SUCCESS;
2407 }
2408 }
2409
2410 return VERR_NOT_FOUND;
2411}
2412
2413int GuestSession::i_sendCommand(uint32_t uFunction,
2414 uint32_t uParms, PVBOXHGCMSVCPARM paParms)
2415{
2416 LogFlowThisFuncEnter();
2417
2418#ifndef VBOX_GUESTCTRL_TEST_CASE
2419 ComObjPtr<Console> pConsole = mParent->i_getConsole();
2420 Assert(!pConsole.isNull());
2421
2422 /* Forward the information to the VMM device. */
2423 VMMDev *pVMMDev = pConsole->i_getVMMDev();
2424 AssertPtr(pVMMDev);
2425
2426 LogFlowThisFunc(("uFunction=%RU32, uParms=%RU32\n", uFunction, uParms));
2427 int vrc = pVMMDev->hgcmHostCall(HGCMSERVICE_NAME, uFunction, uParms, paParms);
2428 if (RT_FAILURE(vrc))
2429 {
2430 /** @todo What to do here? */
2431 }
2432#else
2433 /* Not needed within testcases. */
2434 int vrc = VINF_SUCCESS;
2435#endif
2436 LogFlowFuncLeaveRC(vrc);
2437 return vrc;
2438}
2439
2440/* static */
2441HRESULT GuestSession::i_setErrorExternal(VirtualBoxBase *pInterface, int rcGuest)
2442{
2443 AssertPtr(pInterface);
2444 AssertMsg(RT_FAILURE(rcGuest), ("Guest rc does not indicate a failure when setting error\n"));
2445
2446 return pInterface->setError(VBOX_E_IPRT_ERROR, GuestSession::i_guestErrorToString(rcGuest).c_str());
2447}
2448
2449/* Does not do locking; caller is responsible for that! */
2450int GuestSession::i_setSessionStatus(GuestSessionStatus_T sessionStatus, int sessionRc)
2451{
2452 LogFlowThisFunc(("oldStatus=%RU32, newStatus=%RU32, sessionRc=%Rrc\n",
2453 mData.mStatus, sessionStatus, sessionRc));
2454
2455 if (sessionStatus == GuestSessionStatus_Error)
2456 {
2457 AssertMsg(RT_FAILURE(sessionRc), ("Guest rc must be an error (%Rrc)\n", sessionRc));
2458 /* Do not allow overwriting an already set error. If this happens
2459 * this means we forgot some error checking/locking somewhere. */
2460 AssertMsg(RT_SUCCESS(mData.mRC), ("Guest rc already set (to %Rrc)\n", mData.mRC));
2461 }
2462 else
2463 AssertMsg(RT_SUCCESS(sessionRc), ("Guest rc must not be an error (%Rrc)\n", sessionRc));
2464
2465 if (mData.mStatus != sessionStatus)
2466 {
2467 mData.mStatus = sessionStatus;
2468 mData.mRC = sessionRc;
2469
2470 ComObjPtr<VirtualBoxErrorInfo> errorInfo;
2471 HRESULT hr = errorInfo.createObject();
2472 ComAssertComRC(hr);
2473 int rc2 = errorInfo->initEx(VBOX_E_IPRT_ERROR, sessionRc,
2474 COM_IIDOF(IGuestSession), getComponentName(),
2475 i_guestErrorToString(sessionRc));
2476 AssertRC(rc2);
2477
2478 fireGuestSessionStateChangedEvent(mEventSource, this,
2479 mData.mSession.mID, sessionStatus, errorInfo);
2480 }
2481
2482 return VINF_SUCCESS;
2483}
2484
2485int GuestSession::i_signalWaiters(GuestSessionWaitResult_T enmWaitResult, int rc /*= VINF_SUCCESS */)
2486{
2487 RT_NOREF(enmWaitResult, rc);
2488
2489 /*LogFlowThisFunc(("enmWaitResult=%d, rc=%Rrc, mWaitCount=%RU32, mWaitEvent=%p\n",
2490 enmWaitResult, rc, mData.mWaitCount, mData.mWaitEvent));*/
2491
2492 /* Note: No write locking here -- already done in the caller. */
2493
2494 int vrc = VINF_SUCCESS;
2495 /*if (mData.mWaitEvent)
2496 vrc = mData.mWaitEvent->Signal(enmWaitResult, rc);*/
2497 LogFlowFuncLeaveRC(vrc);
2498 return vrc;
2499}
2500
2501/**
2502 * Determines the protocol version (sets mData.mProtocolVersion).
2503 *
2504 * This is called from the init method prior to to establishing a guest
2505 * session.
2506 *
2507 * @return IPRT status code.
2508 */
2509int GuestSession::i_determineProtocolVersion(void)
2510{
2511 /*
2512 * We currently do this based on the reported guest additions version,
2513 * ASSUMING that VBoxService and VBoxDrv are at the same version.
2514 */
2515 ComObjPtr<Guest> pGuest = mParent;
2516 AssertReturn(!pGuest.isNull(), VERR_NOT_SUPPORTED);
2517 uint32_t uGaVersion = pGuest->i_getAdditionsVersion();
2518
2519 /* Everyone supports version one, if they support anything at all. */
2520 mData.mProtocolVersion = 1;
2521
2522 /* Guest control 2.0 was introduced with 4.3.0. */
2523 if (uGaVersion >= VBOX_FULL_VERSION_MAKE(4,3,0))
2524 mData.mProtocolVersion = 2; /* Guest control 2.0. */
2525
2526 LogFlowThisFunc(("uGaVersion=%u.%u.%u => mProtocolVersion=%u\n",
2527 VBOX_FULL_VERSION_GET_MAJOR(uGaVersion), VBOX_FULL_VERSION_GET_MINOR(uGaVersion),
2528 VBOX_FULL_VERSION_GET_BUILD(uGaVersion), mData.mProtocolVersion));
2529
2530 /*
2531 * Inform the user about outdated guest additions (VM release log).
2532 */
2533 if (mData.mProtocolVersion < 2)
2534 LogRelMax(3, (tr("Warning: Guest Additions v%u.%u.%u only supports the older guest control protocol version %u.\n"
2535 " Please upgrade GAs to the current version to get full guest control capabilities.\n"),
2536 VBOX_FULL_VERSION_GET_MAJOR(uGaVersion), VBOX_FULL_VERSION_GET_MINOR(uGaVersion),
2537 VBOX_FULL_VERSION_GET_BUILD(uGaVersion), mData.mProtocolVersion));
2538
2539 return VINF_SUCCESS;
2540}
2541
2542int GuestSession::i_waitFor(uint32_t fWaitFlags, ULONG uTimeoutMS, GuestSessionWaitResult_T &waitResult, int *prcGuest)
2543{
2544 LogFlowThisFuncEnter();
2545
2546 AssertReturn(fWaitFlags, VERR_INVALID_PARAMETER);
2547
2548 /*LogFlowThisFunc(("fWaitFlags=0x%x, uTimeoutMS=%RU32, mStatus=%RU32, mWaitCount=%RU32, mWaitEvent=%p, prcGuest=%p\n",
2549 fWaitFlags, uTimeoutMS, mData.mStatus, mData.mWaitCount, mData.mWaitEvent, prcGuest));*/
2550
2551 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2552
2553 /* Did some error occur before? Then skip waiting and return. */
2554 if (mData.mStatus == GuestSessionStatus_Error)
2555 {
2556 waitResult = GuestSessionWaitResult_Error;
2557 AssertMsg(RT_FAILURE(mData.mRC), ("No error rc (%Rrc) set when guest session indicated an error\n", mData.mRC));
2558 if (prcGuest)
2559 *prcGuest = mData.mRC; /* Return last set error. */
2560 return VERR_GSTCTL_GUEST_ERROR;
2561 }
2562
2563 /* Guest Additions < 4.3 don't support session handling, skip. */
2564 if (mData.mProtocolVersion < 2)
2565 {
2566 waitResult = GuestSessionWaitResult_WaitFlagNotSupported;
2567
2568 LogFlowThisFunc(("Installed Guest Additions don't support waiting for dedicated sessions, skipping\n"));
2569 return VINF_SUCCESS;
2570 }
2571
2572 waitResult = GuestSessionWaitResult_None;
2573 if (fWaitFlags & GuestSessionWaitForFlag_Terminate)
2574 {
2575 switch (mData.mStatus)
2576 {
2577 case GuestSessionStatus_Terminated:
2578 case GuestSessionStatus_Down:
2579 waitResult = GuestSessionWaitResult_Terminate;
2580 break;
2581
2582 case GuestSessionStatus_TimedOutKilled:
2583 case GuestSessionStatus_TimedOutAbnormally:
2584 waitResult = GuestSessionWaitResult_Timeout;
2585 break;
2586
2587 case GuestSessionStatus_Error:
2588 /* Handled above. */
2589 break;
2590
2591 case GuestSessionStatus_Started:
2592 waitResult = GuestSessionWaitResult_Start;
2593 break;
2594
2595 case GuestSessionStatus_Undefined:
2596 case GuestSessionStatus_Starting:
2597 /* Do the waiting below. */
2598 break;
2599
2600 default:
2601 AssertMsgFailed(("Unhandled session status %RU32\n", mData.mStatus));
2602 return VERR_NOT_IMPLEMENTED;
2603 }
2604 }
2605 else if (fWaitFlags & GuestSessionWaitForFlag_Start)
2606 {
2607 switch (mData.mStatus)
2608 {
2609 case GuestSessionStatus_Started:
2610 case GuestSessionStatus_Terminating:
2611 case GuestSessionStatus_Terminated:
2612 case GuestSessionStatus_Down:
2613 waitResult = GuestSessionWaitResult_Start;
2614 break;
2615
2616 case GuestSessionStatus_Error:
2617 waitResult = GuestSessionWaitResult_Error;
2618 break;
2619
2620 case GuestSessionStatus_TimedOutKilled:
2621 case GuestSessionStatus_TimedOutAbnormally:
2622 waitResult = GuestSessionWaitResult_Timeout;
2623 break;
2624
2625 case GuestSessionStatus_Undefined:
2626 case GuestSessionStatus_Starting:
2627 /* Do the waiting below. */
2628 break;
2629
2630 default:
2631 AssertMsgFailed(("Unhandled session status %RU32\n", mData.mStatus));
2632 return VERR_NOT_IMPLEMENTED;
2633 }
2634 }
2635
2636 LogFlowThisFunc(("sessionStatus=%RU32, sessionRc=%Rrc, waitResult=%RU32\n",
2637 mData.mStatus, mData.mRC, waitResult));
2638
2639 /* No waiting needed? Return immediately using the last set error. */
2640 if (waitResult != GuestSessionWaitResult_None)
2641 {
2642 if (prcGuest)
2643 *prcGuest = mData.mRC; /* Return last set error (if any). */
2644 return RT_SUCCESS(mData.mRC) ? VINF_SUCCESS : VERR_GSTCTL_GUEST_ERROR;
2645 }
2646
2647 int vrc;
2648
2649 GuestWaitEvent *pEvent = NULL;
2650 GuestEventTypes eventTypes;
2651 try
2652 {
2653 eventTypes.push_back(VBoxEventType_OnGuestSessionStateChanged);
2654
2655 vrc = registerWaitEventEx(mData.mSession.mID, mData.mObjectID, eventTypes, &pEvent);
2656 }
2657 catch (std::bad_alloc)
2658 {
2659 vrc = VERR_NO_MEMORY;
2660 }
2661
2662 if (RT_FAILURE(vrc))
2663 return vrc;
2664
2665 alock.release(); /* Release lock before waiting. */
2666
2667 GuestSessionStatus_T sessionStatus;
2668 vrc = i_waitForStatusChange(pEvent, fWaitFlags,
2669 uTimeoutMS, &sessionStatus, prcGuest);
2670 if (RT_SUCCESS(vrc))
2671 {
2672 switch (sessionStatus)
2673 {
2674 case GuestSessionStatus_Started:
2675 waitResult = GuestSessionWaitResult_Start;
2676 break;
2677
2678 case GuestSessionStatus_Terminated:
2679 waitResult = GuestSessionWaitResult_Terminate;
2680 break;
2681
2682 case GuestSessionStatus_TimedOutKilled:
2683 case GuestSessionStatus_TimedOutAbnormally:
2684 waitResult = GuestSessionWaitResult_Timeout;
2685 break;
2686
2687 case GuestSessionStatus_Down:
2688 waitResult = GuestSessionWaitResult_Terminate;
2689 break;
2690
2691 case GuestSessionStatus_Error:
2692 waitResult = GuestSessionWaitResult_Error;
2693 break;
2694
2695 default:
2696 waitResult = GuestSessionWaitResult_Status;
2697 break;
2698 }
2699 }
2700
2701 unregisterWaitEvent(pEvent);
2702
2703 LogFlowFuncLeaveRC(vrc);
2704 return vrc;
2705}
2706
2707int GuestSession::i_waitForStatusChange(GuestWaitEvent *pEvent, uint32_t fWaitFlags, uint32_t uTimeoutMS,
2708 GuestSessionStatus_T *pSessionStatus, int *prcGuest)
2709{
2710 RT_NOREF(fWaitFlags);
2711 AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
2712
2713 VBoxEventType_T evtType;
2714 ComPtr<IEvent> pIEvent;
2715 int vrc = waitForEvent(pEvent, uTimeoutMS,
2716 &evtType, pIEvent.asOutParam());
2717 if (RT_SUCCESS(vrc))
2718 {
2719 Assert(evtType == VBoxEventType_OnGuestSessionStateChanged);
2720
2721 ComPtr<IGuestSessionStateChangedEvent> pChangedEvent = pIEvent;
2722 Assert(!pChangedEvent.isNull());
2723
2724 GuestSessionStatus_T sessionStatus;
2725 pChangedEvent->COMGETTER(Status)(&sessionStatus);
2726 if (pSessionStatus)
2727 *pSessionStatus = sessionStatus;
2728
2729 ComPtr<IVirtualBoxErrorInfo> errorInfo;
2730 HRESULT hr = pChangedEvent->COMGETTER(Error)(errorInfo.asOutParam());
2731 ComAssertComRC(hr);
2732
2733 LONG lGuestRc;
2734 hr = errorInfo->COMGETTER(ResultDetail)(&lGuestRc);
2735 ComAssertComRC(hr);
2736 if (RT_FAILURE((int)lGuestRc))
2737 vrc = VERR_GSTCTL_GUEST_ERROR;
2738 if (prcGuest)
2739 *prcGuest = (int)lGuestRc;
2740
2741 LogFlowThisFunc(("Status changed event for session ID=%RU32, new status is: %RU32 (%Rrc)\n",
2742 mData.mSession.mID, sessionStatus,
2743 RT_SUCCESS((int)lGuestRc) ? VINF_SUCCESS : (int)lGuestRc));
2744 }
2745
2746 LogFlowFuncLeaveRC(vrc);
2747 return vrc;
2748}
2749
2750// implementation of public methods
2751/////////////////////////////////////////////////////////////////////////////
2752
2753HRESULT GuestSession::close()
2754{
2755 AutoCaller autoCaller(this);
2756 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2757
2758 LogFlowThisFuncEnter();
2759
2760 /* Note: Don't check if the session is ready via i_isReadyExternal() here;
2761 * the session (already) could be in a stopped / aborted state. */
2762
2763 /* Close session on guest. */
2764 int rcGuest = VINF_SUCCESS;
2765 int rc = i_closeSession(0 /* Flags */, 30 * 1000 /* Timeout */, &rcGuest);
2766 /* On failure don't return here, instead do all the cleanup
2767 * work first and then return an error. */
2768
2769 /* Remove ourselves from the session list. */
2770 AssertPtr(mParent);
2771 int rc2 = mParent->i_sessionRemove(mData.mSession.mID);
2772 if (rc2 == VERR_NOT_FOUND) /* Not finding the session anymore isn't critical. */
2773 rc2 = VINF_SUCCESS;
2774
2775 if (RT_SUCCESS(rc))
2776 rc = rc2;
2777
2778 LogFlowThisFunc(("Returning rc=%Rrc, rcGuest=%Rrc\n", rc, rcGuest));
2779
2780 if (RT_FAILURE(rc))
2781 {
2782 if (rc == VERR_GSTCTL_GUEST_ERROR)
2783 return GuestSession::i_setErrorExternal(this, rcGuest);
2784
2785 return setError(VBOX_E_IPRT_ERROR,
2786 tr("Closing guest session failed with %Rrc"), rc);
2787 }
2788
2789 return S_OK;
2790}
2791
2792HRESULT GuestSession::fileCopy(const com::Utf8Str &aSource, const com::Utf8Str &aDestination,
2793 const std::vector<FileCopyFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
2794{
2795 RT_NOREF(aSource, aDestination, aFlags, aProgress);
2796 ReturnComNotImplemented();
2797}
2798
2799HRESULT GuestSession::fileCopyFromGuest(const com::Utf8Str &aSource, const com::Utf8Str &aDestination,
2800 const std::vector<FileCopyFlag_T> &aFlags,
2801 ComPtr<IProgress> &aProgress)
2802{
2803 AutoCaller autoCaller(this);
2804 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2805
2806 uint32_t fFlags = FileCopyFlag_None;
2807 if (aFlags.size())
2808 {
2809 for (size_t i = 0; i < aFlags.size(); i++)
2810 fFlags |= aFlags[i];
2811 }
2812
2813 GuestSessionFsSourceSet SourceSet;
2814
2815 GuestSessionFsSourceSpec source;
2816 source.strSource = aSource;
2817 source.enmType = FsObjType_File;
2818 source.enmPathStyle = i_getPathStyle();
2819 source.Type.File.fCopyFlags = (FileCopyFlag_T)fFlags;
2820
2821 SourceSet.push_back(source);
2822
2823 return i_copyFromGuest(SourceSet, aDestination, aProgress);
2824}
2825
2826HRESULT GuestSession::fileCopyToGuest(const com::Utf8Str &aSource, const com::Utf8Str &aDestination,
2827 const std::vector<FileCopyFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
2828{
2829 AutoCaller autoCaller(this);
2830 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2831
2832 uint32_t fFlags = FileCopyFlag_None;
2833 if (aFlags.size())
2834 {
2835 for (size_t i = 0; i < aFlags.size(); i++)
2836 fFlags |= aFlags[i];
2837 }
2838
2839 GuestSessionFsSourceSet SourceSet;
2840
2841 GuestSessionFsSourceSpec source;
2842 source.strSource = aSource;
2843 source.enmType = FsObjType_File;
2844 source.enmPathStyle = i_getPathStyle();
2845 source.Type.File.fCopyFlags = (FileCopyFlag_T)fFlags;
2846
2847 SourceSet.push_back(source);
2848
2849 return i_copyToGuest(SourceSet, aDestination, aProgress);
2850}
2851
2852HRESULT GuestSession::copyFromGuest(const std::vector<com::Utf8Str> &aSources, const std::vector<com::Utf8Str> &aFilters,
2853 const std::vector<FsObjType_T> &aTypes, const std::vector<GuestCopyFlag_T> &aFlags,
2854 const com::Utf8Str &aDestination, ComPtr<IProgress> &aProgress)
2855{
2856 AutoCaller autoCaller(this);
2857 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2858
2859 const size_t cSources = aSources.size();
2860 if ( aFilters.size() != cSources
2861 || aTypes.size() != cSources
2862 || aFlags.size() != cSources)
2863 {
2864 return setError(E_INVALIDARG, tr("Parameter array sizes don't match to the number of sources specified"));
2865 }
2866
2867 GuestSessionFsSourceSet SourceSet;
2868
2869 std::vector<com::Utf8Str>::const_iterator itSource = aSources.begin();
2870 std::vector<com::Utf8Str>::const_iterator itFilter = aFilters.begin();
2871 std::vector<FsObjType_T>::const_iterator itType = aTypes.begin();
2872 std::vector<GuestCopyFlag_T>::const_iterator itFlag = aFlags.begin();
2873
2874 while (itSource != aSources.end())
2875 {
2876 GuestSessionFsSourceSpec source;
2877 source.strSource = *itSource;
2878 source.strFilter = *itFilter;
2879 source.enmType = *itType;
2880 source.enmPathStyle = i_getPathStyle();
2881
2882 if (*itType == FsObjType_Directory)
2883 {
2884 source.Type.Dir.fCopyFlags = (DirectoryCopyFlag_T)*itFlag;
2885 source.Type.Dir.fRecursive = true; /* Implicit. */
2886 }
2887 else
2888 {
2889 source.Type.File.fCopyFlags = (FileCopyFlag_T)*itFlag;
2890 }
2891
2892 SourceSet.push_back(source);
2893
2894 ++itSource;
2895 ++itFilter;
2896 ++itType;
2897 ++itFlag;
2898 }
2899
2900 return i_copyFromGuest(SourceSet, aDestination, aProgress);
2901}
2902
2903HRESULT GuestSession::copyToGuest(const std::vector<com::Utf8Str> &aSources, const std::vector<com::Utf8Str> &aFilters,
2904 const std::vector<FsObjType_T> &aTypes, const std::vector<GuestCopyFlag_T> &aFlags,
2905 const com::Utf8Str &aDestination, ComPtr<IProgress> &aProgress)
2906{
2907 AutoCaller autoCaller(this);
2908 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2909
2910 const size_t cSources = aSources.size();
2911 if ( aFilters.size() != cSources
2912 || aTypes.size() != cSources
2913 || aFlags.size() != cSources)
2914 {
2915 return setError(E_INVALIDARG, tr("Parameter array sizes don't match to the number of sources specified"));
2916 }
2917
2918 GuestSessionFsSourceSet SourceSet;
2919
2920 std::vector<com::Utf8Str>::const_iterator itSource = aSources.begin();
2921 std::vector<com::Utf8Str>::const_iterator itFilter = aFilters.begin();
2922 std::vector<FsObjType_T>::const_iterator itType = aTypes.begin();
2923 std::vector<GuestCopyFlag_T>::const_iterator itFlag = aFlags.begin();
2924
2925 while (itSource != aSources.end())
2926 {
2927
2928 GuestSessionFsSourceSpec source;
2929 source.strSource = *itSource;
2930 source.strFilter = *itFilter;
2931 source.enmType = *itType;
2932 source.enmPathStyle = i_getPathStyle();
2933
2934 if (*itType == FsObjType_Directory)
2935 {
2936 source.Type.Dir.fCopyFlags = (DirectoryCopyFlag_T)*itFlag;
2937 source.Type.Dir.fRecursive = true; /* Implicit. */
2938 }
2939 else
2940 source.Type.File.fCopyFlags = (FileCopyFlag_T)*itFlag;
2941
2942 SourceSet.push_back(source);
2943
2944 ++itSource;
2945 ++itFilter;
2946 ++itType;
2947 ++itFlag;
2948 }
2949
2950 return i_copyToGuest(SourceSet, aDestination, aProgress);
2951}
2952
2953HRESULT GuestSession::directoryCopy(const com::Utf8Str &aSource, const com::Utf8Str &aDestination,
2954 const std::vector<DirectoryCopyFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
2955{
2956 RT_NOREF(aSource, aDestination, aFlags, aProgress);
2957 ReturnComNotImplemented();
2958}
2959
2960HRESULT GuestSession::directoryCopyFromGuest(const com::Utf8Str &aSource, const com::Utf8Str &aDestination,
2961 const std::vector<DirectoryCopyFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
2962{
2963 AutoCaller autoCaller(this);
2964 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2965
2966 uint32_t fFlags = DirectoryCopyFlag_None;
2967 if (aFlags.size())
2968 {
2969 for (size_t i = 0; i < aFlags.size(); i++)
2970 fFlags |= aFlags[i];
2971 }
2972
2973 GuestSessionFsSourceSet SourceSet;
2974
2975 GuestSessionFsSourceSpec source;
2976 source.strSource = aSource;
2977 source.enmType = FsObjType_Directory;
2978 source.enmPathStyle = i_getPathStyle();
2979 source.Type.Dir.fCopyFlags = (DirectoryCopyFlag_T)fFlags;
2980 source.Type.Dir.fRecursive = true; /* Implicit. */
2981
2982 SourceSet.push_back(source);
2983
2984 return i_copyFromGuest(SourceSet, aDestination, aProgress);
2985}
2986
2987HRESULT GuestSession::directoryCopyToGuest(const com::Utf8Str &aSource, const com::Utf8Str &aDestination,
2988 const std::vector<DirectoryCopyFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
2989{
2990 AutoCaller autoCaller(this);
2991 if (FAILED(autoCaller.rc())) return autoCaller.rc();
2992
2993 uint32_t fFlags = DirectoryCopyFlag_None;
2994 if (aFlags.size())
2995 {
2996 for (size_t i = 0; i < aFlags.size(); i++)
2997 fFlags |= aFlags[i];
2998 }
2999
3000 GuestSessionFsSourceSet SourceSet;
3001
3002 GuestSessionFsSourceSpec source;
3003 source.strSource = aSource;
3004 source.enmType = FsObjType_Directory;
3005 source.enmPathStyle = i_getPathStyle();
3006 source.Type.Dir.fCopyFlags = (DirectoryCopyFlag_T)fFlags;
3007 source.Type.Dir.fRecursive = true; /* Implicit. */
3008
3009 SourceSet.push_back(source);
3010
3011 return i_copyToGuest(SourceSet, aDestination, aProgress);
3012}
3013
3014HRESULT GuestSession::directoryCreate(const com::Utf8Str &aPath, ULONG aMode,
3015 const std::vector<DirectoryCreateFlag_T> &aFlags)
3016{
3017 AutoCaller autoCaller(this);
3018 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3019
3020 if (RT_UNLIKELY((aPath.c_str()) == NULL || *(aPath.c_str()) == '\0'))
3021 return setError(E_INVALIDARG, tr("No directory to create specified"));
3022
3023 uint32_t fFlags = DirectoryCreateFlag_None;
3024 if (aFlags.size())
3025 {
3026 for (size_t i = 0; i < aFlags.size(); i++)
3027 fFlags |= aFlags[i];
3028
3029 if (fFlags)
3030 if (!(fFlags & DirectoryCreateFlag_Parents))
3031 return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), fFlags);
3032 }
3033
3034 HRESULT hrc = i_isReadyExternal();
3035 if (FAILED(hrc))
3036 return hrc;
3037
3038 LogFlowThisFuncEnter();
3039
3040 ComObjPtr <GuestDirectory> pDirectory; int rcGuest;
3041 int rc = i_directoryCreate(aPath, (uint32_t)aMode, fFlags, &rcGuest);
3042 if (RT_FAILURE(rc))
3043 {
3044 if (GuestProcess::i_isGuestError(rc))
3045 {
3046 hrc = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: %s"),
3047 GuestDirectory::i_guestErrorToString(rcGuest).c_str());
3048 }
3049 else
3050 {
3051 switch (rc)
3052 {
3053 case VERR_INVALID_PARAMETER:
3054 hrc = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: Invalid parameters given"));
3055 break;
3056
3057 case VERR_BROKEN_PIPE:
3058 hrc = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: Unexpectedly aborted"));
3059 break;
3060
3061 default:
3062 hrc = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: %Rrc"), rc);
3063 break;
3064 }
3065 }
3066 }
3067
3068 return hrc;
3069}
3070
3071HRESULT GuestSession::directoryCreateTemp(const com::Utf8Str &aTemplateName, ULONG aMode, const com::Utf8Str &aPath,
3072 BOOL aSecure, com::Utf8Str &aDirectory)
3073{
3074 RT_NOREF(aMode, aSecure);
3075
3076 AutoCaller autoCaller(this);
3077 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3078
3079 if (RT_UNLIKELY((aTemplateName.c_str()) == NULL || *(aTemplateName.c_str()) == '\0'))
3080 return setError(E_INVALIDARG, tr("No template specified"));
3081 if (RT_UNLIKELY((aPath.c_str()) == NULL || *(aPath.c_str()) == '\0'))
3082 return setError(E_INVALIDARG, tr("No directory name specified"));
3083
3084 HRESULT hrc = i_isReadyExternal();
3085 if (FAILED(hrc))
3086 return hrc;
3087
3088 LogFlowThisFuncEnter();
3089
3090 int rcGuest;
3091 int rc = i_fsCreateTemp(aTemplateName, aPath, true /* Directory */, aDirectory, &rcGuest);
3092 if (!RT_SUCCESS(rc))
3093 {
3094 switch (rc)
3095 {
3096 case VERR_GSTCTL_GUEST_ERROR:
3097 hrc = GuestProcess::i_setErrorExternal(this, rcGuest);
3098 break;
3099
3100 default:
3101 hrc = setError(VBOX_E_IPRT_ERROR, tr("Temporary directory creation \"%s\" with template \"%s\" failed: %Rrc"),
3102 aPath.c_str(), aTemplateName.c_str(), rc);
3103 break;
3104 }
3105 }
3106
3107 return hrc;
3108}
3109
3110HRESULT GuestSession::directoryExists(const com::Utf8Str &aPath, BOOL aFollowSymlinks, BOOL *aExists)
3111{
3112 AutoCaller autoCaller(this);
3113 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3114
3115 if (RT_UNLIKELY((aPath.c_str()) == NULL || *(aPath.c_str()) == '\0'))
3116 return setError(E_INVALIDARG, tr("No directory to check existence for specified"));
3117
3118 HRESULT hrc = i_isReadyExternal();
3119 if (FAILED(hrc))
3120 return hrc;
3121
3122 LogFlowThisFuncEnter();
3123
3124 GuestFsObjData objData; int rcGuest;
3125 int rc = i_directoryQueryInfo(aPath, aFollowSymlinks != FALSE, objData, &rcGuest);
3126 if (RT_SUCCESS(rc))
3127 *aExists = objData.mType == FsObjType_Directory;
3128 else
3129 {
3130 switch (rc)
3131 {
3132 case VERR_GSTCTL_GUEST_ERROR:
3133 {
3134 switch (rcGuest)
3135 {
3136 case VERR_PATH_NOT_FOUND:
3137 *aExists = FALSE;
3138 break;
3139 default:
3140 hrc = setError(VBOX_E_IPRT_ERROR, tr("Querying directory existence \"%s\" failed: %s"),
3141 aPath.c_str(), GuestProcess::i_guestErrorToString(rcGuest).c_str());
3142 break;
3143 }
3144 break;
3145 }
3146
3147 default:
3148 hrc = setError(VBOX_E_IPRT_ERROR, tr("Querying directory existence \"%s\" failed: %Rrc"),
3149 aPath.c_str(), rc);
3150 break;
3151 }
3152 }
3153
3154 return hrc;
3155}
3156
3157HRESULT GuestSession::directoryOpen(const com::Utf8Str &aPath, const com::Utf8Str &aFilter,
3158 const std::vector<DirectoryOpenFlag_T> &aFlags, ComPtr<IGuestDirectory> &aDirectory)
3159{
3160 AutoCaller autoCaller(this);
3161 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3162
3163 if (RT_UNLIKELY((aPath.c_str()) == NULL || *(aPath.c_str()) == '\0'))
3164 return setError(E_INVALIDARG, tr("No directory to open specified"));
3165 if (RT_UNLIKELY((aFilter.c_str()) != NULL && *(aFilter.c_str()) != '\0'))
3166 return setError(E_INVALIDARG, tr("Directory filters are not implemented yet"));
3167
3168 uint32_t fFlags = DirectoryOpenFlag_None;
3169 if (aFlags.size())
3170 {
3171 for (size_t i = 0; i < aFlags.size(); i++)
3172 fFlags |= aFlags[i];
3173
3174 if (fFlags)
3175 return setError(E_INVALIDARG, tr("Open flags (%#x) not implemented yet"), fFlags);
3176 }
3177
3178 HRESULT hrc = i_isReadyExternal();
3179 if (FAILED(hrc))
3180 return hrc;
3181
3182 LogFlowThisFuncEnter();
3183
3184 GuestDirectoryOpenInfo openInfo;
3185 openInfo.mPath = aPath;
3186 openInfo.mFilter = aFilter;
3187 openInfo.mFlags = fFlags;
3188
3189 ComObjPtr <GuestDirectory> pDirectory; int rcGuest;
3190 int rc = i_directoryOpen(openInfo, pDirectory, &rcGuest);
3191 if (RT_SUCCESS(rc))
3192 {
3193 /* Return directory object to the caller. */
3194 hrc = pDirectory.queryInterfaceTo(aDirectory.asOutParam());
3195 }
3196 else
3197 {
3198 switch (rc)
3199 {
3200 case VERR_INVALID_PARAMETER:
3201 hrc = setError(VBOX_E_IPRT_ERROR, tr("Opening directory \"%s\" failed; invalid parameters given"),
3202 aPath.c_str());
3203 break;
3204
3205 case VERR_GSTCTL_GUEST_ERROR:
3206 hrc = GuestDirectory::i_setErrorExternal(this, rcGuest);
3207 break;
3208
3209 default:
3210 hrc = setError(VBOX_E_IPRT_ERROR, tr("Opening directory \"%s\" failed: %Rrc"),
3211 aPath.c_str(),rc);
3212 break;
3213 }
3214 }
3215
3216 return hrc;
3217}
3218
3219HRESULT GuestSession::directoryRemove(const com::Utf8Str &aPath)
3220{
3221 AutoCaller autoCaller(this);
3222 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3223
3224 if (RT_UNLIKELY((aPath.c_str()) == NULL || *(aPath.c_str()) == '\0'))
3225 return setError(E_INVALIDARG, tr("No directory to remove specified"));
3226
3227 HRESULT hrc = i_isReadyExternal();
3228 if (FAILED(hrc))
3229 return hrc;
3230
3231 LogFlowThisFuncEnter();
3232
3233 /* No flags; only remove the directory when empty. */
3234 uint32_t uFlags = 0;
3235
3236 int rcGuest;
3237 int vrc = i_directoryRemove(aPath, uFlags, &rcGuest);
3238 if (RT_FAILURE(vrc))
3239 {
3240 switch (vrc)
3241 {
3242 case VERR_NOT_SUPPORTED:
3243 hrc = setError(VBOX_E_IPRT_ERROR,
3244 tr("Handling removing guest directories not supported by installed Guest Additions"));
3245 break;
3246
3247 case VERR_GSTCTL_GUEST_ERROR:
3248 hrc = GuestDirectory::i_setErrorExternal(this, rcGuest);
3249 break;
3250
3251 default:
3252 hrc = setError(VBOX_E_IPRT_ERROR, tr("Removing guest directory \"%s\" failed: %Rrc"),
3253 aPath.c_str(), vrc);
3254 break;
3255 }
3256 }
3257
3258 return hrc;
3259}
3260
3261HRESULT GuestSession::directoryRemoveRecursive(const com::Utf8Str &aPath, const std::vector<DirectoryRemoveRecFlag_T> &aFlags,
3262 ComPtr<IProgress> &aProgress)
3263{
3264 RT_NOREF(aFlags);
3265
3266 AutoCaller autoCaller(this);
3267 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3268
3269 if (RT_UNLIKELY((aPath.c_str()) == NULL || *(aPath.c_str()) == '\0'))
3270 return setError(E_INVALIDARG, tr("No directory to remove recursively specified"));
3271
3272/** @todo r=bird: Must check that the flags matches the hardcoded behavior
3273 * further down!! */
3274
3275 HRESULT hrc = i_isReadyExternal();
3276 if (FAILED(hrc))
3277 return hrc;
3278
3279 LogFlowThisFuncEnter();
3280
3281 ComObjPtr<Progress> pProgress;
3282 hrc = pProgress.createObject();
3283 if (SUCCEEDED(hrc))
3284 hrc = pProgress->init(static_cast<IGuestSession *>(this),
3285 Bstr(tr("Removing guest directory")).raw(),
3286 TRUE /*aCancelable*/);
3287 if (FAILED(hrc))
3288 return hrc;
3289
3290 /* Note: At the moment we don't supply progress information while
3291 * deleting a guest directory recursively. So just complete
3292 * the progress object right now. */
3293 /** @todo Implement progress reporting on guest directory deletion! */
3294 hrc = pProgress->i_notifyComplete(S_OK);
3295 if (FAILED(hrc))
3296 return hrc;
3297
3298 /* Remove the directory + all its contents. */
3299 uint32_t uFlags = DIRREMOVE_FLAG_RECURSIVE
3300 | DIRREMOVE_FLAG_CONTENT_AND_DIR;
3301 int rcGuest;
3302 int vrc = i_directoryRemove(aPath, uFlags, &rcGuest);
3303 if (RT_FAILURE(vrc))
3304 {
3305 switch (vrc)
3306 {
3307 case VERR_NOT_SUPPORTED:
3308 hrc = setError(VBOX_E_IPRT_ERROR,
3309 tr("Handling removing guest directories recursively not supported by installed Guest Additions"));
3310 break;
3311
3312 case VERR_GSTCTL_GUEST_ERROR:
3313 hrc = GuestFile::i_setErrorExternal(this, rcGuest);
3314 break;
3315
3316 default:
3317 hrc = setError(VBOX_E_IPRT_ERROR, tr("Recursively removing guest directory \"%s\" failed: %Rrc"),
3318 aPath.c_str(), vrc);
3319 break;
3320 }
3321 }
3322 else
3323 {
3324 pProgress.queryInterfaceTo(aProgress.asOutParam());
3325 }
3326
3327 return hrc;
3328}
3329
3330HRESULT GuestSession::environmentScheduleSet(const com::Utf8Str &aName, const com::Utf8Str &aValue)
3331{
3332 AutoCaller autoCaller(this);
3333 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3334
3335 HRESULT hrc;
3336 if (RT_LIKELY(aName.isNotEmpty()))
3337 {
3338 if (RT_LIKELY(strchr(aName.c_str(), '=') == NULL))
3339 {
3340 LogFlowThisFuncEnter();
3341
3342 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3343 int vrc = mData.mEnvironmentChanges.setVariable(aName, aValue);
3344 if (RT_SUCCESS(vrc))
3345 hrc = S_OK;
3346 else
3347 hrc = setErrorVrc(vrc);
3348 }
3349 else
3350 hrc = setError(E_INVALIDARG, tr("The equal char is not allowed in environment variable names"));
3351 }
3352 else
3353 hrc = setError(E_INVALIDARG, tr("No variable name specified"));
3354
3355 LogFlowThisFuncLeave();
3356 return hrc;
3357}
3358
3359HRESULT GuestSession::environmentScheduleUnset(const com::Utf8Str &aName)
3360{
3361 AutoCaller autoCaller(this);
3362 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3363
3364 HRESULT hrc;
3365 if (RT_LIKELY(aName.isNotEmpty()))
3366 {
3367 if (RT_LIKELY(strchr(aName.c_str(), '=') == NULL))
3368 {
3369 LogFlowThisFuncEnter();
3370
3371 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3372 int vrc = mData.mEnvironmentChanges.unsetVariable(aName);
3373 if (RT_SUCCESS(vrc))
3374 hrc = S_OK;
3375 else
3376 hrc = setErrorVrc(vrc);
3377 }
3378 else
3379 hrc = setError(E_INVALIDARG, tr("The equal char is not allowed in environment variable names"));
3380 }
3381 else
3382 hrc = setError(E_INVALIDARG, tr("No variable name specified"));
3383
3384 LogFlowThisFuncLeave();
3385 return hrc;
3386}
3387
3388HRESULT GuestSession::environmentGetBaseVariable(const com::Utf8Str &aName, com::Utf8Str &aValue)
3389{
3390 AutoCaller autoCaller(this);
3391 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3392
3393 HRESULT hrc;
3394 if (RT_LIKELY(aName.isNotEmpty()))
3395 {
3396 if (RT_LIKELY(strchr(aName.c_str(), '=') == NULL))
3397 {
3398 LogFlowThisFuncEnter();
3399
3400 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3401 if (mData.mpBaseEnvironment)
3402 {
3403 int vrc = mData.mpBaseEnvironment->getVariable(aName, &aValue);
3404 if (RT_SUCCESS(vrc))
3405 hrc = S_OK;
3406 else
3407 hrc = setErrorVrc(vrc);
3408 }
3409 else if (mData.mProtocolVersion < 99999)
3410 hrc = setError(VBOX_E_NOT_SUPPORTED, tr("The base environment feature is not supported by the guest additions"));
3411 else
3412 hrc = setError(VBOX_E_INVALID_OBJECT_STATE, tr("The base environment has not yet been reported by the guest"));
3413 }
3414 else
3415 hrc = setError(E_INVALIDARG, tr("The equal char is not allowed in environment variable names"));
3416 }
3417 else
3418 hrc = setError(E_INVALIDARG, tr("No variable name specified"));
3419
3420 LogFlowThisFuncLeave();
3421 return hrc;
3422}
3423
3424HRESULT GuestSession::environmentDoesBaseVariableExist(const com::Utf8Str &aName, BOOL *aExists)
3425{
3426 AutoCaller autoCaller(this);
3427 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3428
3429 *aExists = FALSE;
3430
3431 HRESULT hrc;
3432 if (RT_LIKELY(aName.isNotEmpty()))
3433 {
3434 if (RT_LIKELY(strchr(aName.c_str(), '=') == NULL))
3435 {
3436 LogFlowThisFuncEnter();
3437
3438 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3439 if (mData.mpBaseEnvironment)
3440 {
3441 hrc = S_OK;
3442 *aExists = mData.mpBaseEnvironment->doesVariableExist(aName);
3443 }
3444 else if (mData.mProtocolVersion < 99999)
3445 hrc = setError(VBOX_E_NOT_SUPPORTED, tr("The base environment feature is not supported by the guest additions"));
3446 else
3447 hrc = setError(VBOX_E_INVALID_OBJECT_STATE, tr("The base environment has not yet been reported by the guest"));
3448 }
3449 else
3450 hrc = setError(E_INVALIDARG, tr("The equal char is not allowed in environment variable names"));
3451 }
3452 else
3453 hrc = setError(E_INVALIDARG, tr("No variable name specified"));
3454
3455 LogFlowThisFuncLeave();
3456 return hrc;
3457}
3458
3459HRESULT GuestSession::fileCreateTemp(const com::Utf8Str &aTemplateName, ULONG aMode, const com::Utf8Str &aPath, BOOL aSecure,
3460 ComPtr<IGuestFile> &aFile)
3461{
3462 RT_NOREF(aTemplateName, aMode, aPath, aSecure, aFile);
3463 ReturnComNotImplemented();
3464}
3465
3466HRESULT GuestSession::fileExists(const com::Utf8Str &aPath, BOOL aFollowSymlinks, BOOL *aExists)
3467{
3468 AutoCaller autoCaller(this);
3469 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3470
3471 if (RT_UNLIKELY((aPath.c_str()) == NULL || *(aPath.c_str()) == '\0'))
3472 {
3473 *aExists = FALSE;
3474 return S_OK;
3475 }
3476
3477 HRESULT hrc = i_isReadyExternal();
3478 if (FAILED(hrc))
3479 return hrc;
3480
3481 LogFlowThisFuncEnter();
3482
3483 GuestFsObjData objData; int rcGuest;
3484 int vrc = i_fileQueryInfo(aPath, aFollowSymlinks != FALSE, objData, &rcGuest);
3485 if (RT_SUCCESS(vrc))
3486 {
3487 *aExists = TRUE;
3488 return S_OK;
3489 }
3490
3491 switch (vrc)
3492 {
3493 case VERR_GSTCTL_GUEST_ERROR:
3494 hrc = GuestProcess::i_setErrorExternal(this, rcGuest);
3495 break;
3496
3497/** @todo r=bird: what about VERR_PATH_NOT_FOUND and VERR_FILE_NOT_FOUND?
3498 * Where does that get converted to *aExists = FALSE? */
3499 case VERR_NOT_A_FILE:
3500 *aExists = FALSE;
3501 break;
3502
3503 default:
3504 hrc = setError(VBOX_E_IPRT_ERROR, tr("Querying file information for \"%s\" failed: %Rrc"),
3505 aPath.c_str(), vrc);
3506 break;
3507 }
3508
3509 return hrc;
3510}
3511
3512HRESULT GuestSession::fileOpen(const com::Utf8Str &aPath, FileAccessMode_T aAccessMode, FileOpenAction_T aOpenAction,
3513 ULONG aCreationMode, ComPtr<IGuestFile> &aFile)
3514{
3515 LogFlowThisFuncEnter();
3516
3517 const std::vector<FileOpenExFlag_T> EmptyFlags;
3518 return fileOpenEx(aPath, aAccessMode, aOpenAction, FileSharingMode_All, aCreationMode, EmptyFlags, aFile);
3519}
3520
3521HRESULT GuestSession::fileOpenEx(const com::Utf8Str &aPath, FileAccessMode_T aAccessMode, FileOpenAction_T aOpenAction,
3522 FileSharingMode_T aSharingMode, ULONG aCreationMode,
3523 const std::vector<FileOpenExFlag_T> &aFlags, ComPtr<IGuestFile> &aFile)
3524{
3525 AutoCaller autoCaller(this);
3526 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3527
3528 if (RT_UNLIKELY((aPath.c_str()) == NULL || *(aPath.c_str()) == '\0'))
3529 return setError(E_INVALIDARG, tr("No file to open specified"));
3530
3531 HRESULT hrc = i_isReadyExternal();
3532 if (FAILED(hrc))
3533 return hrc;
3534
3535 LogFlowThisFuncEnter();
3536
3537 GuestFileOpenInfo openInfo;
3538 openInfo.mFileName = aPath;
3539 openInfo.mCreationMode = aCreationMode;
3540
3541 /* Validate aAccessMode. */
3542 switch (aAccessMode)
3543 {
3544 case (FileAccessMode_T)FileAccessMode_ReadOnly:
3545 RT_FALL_THRU();
3546 case (FileAccessMode_T)FileAccessMode_WriteOnly:
3547 RT_FALL_THRU();
3548 case (FileAccessMode_T)FileAccessMode_ReadWrite:
3549 openInfo.mAccessMode = aAccessMode;
3550 break;
3551 case (FileAccessMode_T)FileAccessMode_AppendOnly:
3552 RT_FALL_THRU();
3553 case (FileAccessMode_T)FileAccessMode_AppendRead:
3554 return setError(E_NOTIMPL, tr("Append access modes are not yet implemented"));
3555 default:
3556 return setError(E_INVALIDARG, tr("Unknown FileAccessMode value %u (%#x)"), aAccessMode, aAccessMode);
3557 }
3558
3559 /* Validate aOpenAction to the old format. */
3560 switch (aOpenAction)
3561 {
3562 case (FileOpenAction_T)FileOpenAction_OpenExisting:
3563 RT_FALL_THRU();
3564 case (FileOpenAction_T)FileOpenAction_OpenOrCreate:
3565 RT_FALL_THRU();
3566 case (FileOpenAction_T)FileOpenAction_CreateNew:
3567 RT_FALL_THRU();
3568 case (FileOpenAction_T)FileOpenAction_CreateOrReplace:
3569 RT_FALL_THRU();
3570 case (FileOpenAction_T)FileOpenAction_OpenExistingTruncated:
3571 RT_FALL_THRU();
3572 case (FileOpenAction_T)FileOpenAction_AppendOrCreate:
3573 openInfo.mOpenAction = aOpenAction;
3574 break;
3575 default:
3576 return setError(E_INVALIDARG, tr("Unknown FileOpenAction value %u (%#x)"), aAccessMode, aAccessMode);
3577 }
3578
3579 /* Validate aSharingMode. */
3580 switch (aSharingMode)
3581 {
3582 case (FileSharingMode_T)FileSharingMode_All:
3583 openInfo.mSharingMode = aSharingMode;
3584 break;
3585 case (FileSharingMode_T)FileSharingMode_Read:
3586 case (FileSharingMode_T)FileSharingMode_Write:
3587 case (FileSharingMode_T)FileSharingMode_ReadWrite:
3588 case (FileSharingMode_T)FileSharingMode_Delete:
3589 case (FileSharingMode_T)FileSharingMode_ReadDelete:
3590 case (FileSharingMode_T)FileSharingMode_WriteDelete:
3591 return setError(E_NOTIMPL, tr("Only FileSharingMode_All is currently implemented"));
3592
3593 default:
3594 return setError(E_INVALIDARG, tr("Unknown FileOpenAction value %u (%#x)"), aAccessMode, aAccessMode);
3595 }
3596
3597 /* Combine and validate flags. */
3598 uint32_t fOpenEx = 0;
3599 for (size_t i = 0; i < aFlags.size(); i++)
3600 fOpenEx = aFlags[i];
3601 if (fOpenEx)
3602 return setError(E_INVALIDARG, tr("Unsupported FileOpenExFlag value(s) in aFlags (%#x)"), fOpenEx);
3603 openInfo.mfOpenEx = fOpenEx;
3604
3605 ComObjPtr <GuestFile> pFile;
3606 int rcGuest;
3607 int vrc = i_fileOpenEx(aPath, aAccessMode, aOpenAction, aSharingMode, aCreationMode, aFlags, pFile, &rcGuest);
3608 if (RT_SUCCESS(vrc))
3609 /* Return directory object to the caller. */
3610 hrc = pFile.queryInterfaceTo(aFile.asOutParam());
3611 else
3612 {
3613 switch (vrc)
3614 {
3615 case VERR_NOT_SUPPORTED:
3616 hrc = setError(VBOX_E_IPRT_ERROR,
3617 tr("Handling guest files not supported by installed Guest Additions"));
3618 break;
3619
3620 case VERR_GSTCTL_GUEST_ERROR:
3621 hrc = GuestFile::i_setErrorExternal(this, rcGuest);
3622 break;
3623
3624 default:
3625 hrc = setError(VBOX_E_IPRT_ERROR, tr("Opening guest file \"%s\" failed: %Rrc"),
3626 aPath.c_str(), vrc);
3627 break;
3628 }
3629 }
3630
3631 return hrc;
3632}
3633
3634HRESULT GuestSession::fileQuerySize(const com::Utf8Str &aPath, BOOL aFollowSymlinks, LONG64 *aSize)
3635{
3636 AutoCaller autoCaller(this);
3637 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3638
3639 if (aPath.isEmpty())
3640 return setError(E_INVALIDARG, tr("No path specified"));
3641
3642 HRESULT hrc = i_isReadyExternal();
3643 if (FAILED(hrc))
3644 return hrc;
3645
3646 int64_t llSize; int rcGuest;
3647 int vrc = i_fileQuerySize(aPath, aFollowSymlinks != FALSE, &llSize, &rcGuest);
3648 if (RT_SUCCESS(vrc))
3649 {
3650 *aSize = llSize;
3651 }
3652 else
3653 {
3654 if (GuestProcess::i_isGuestError(vrc))
3655 {
3656 hrc = GuestProcess::i_setErrorExternal(this, rcGuest);
3657 }
3658 else
3659 hrc = setError(VBOX_E_IPRT_ERROR, tr("Querying file size failed: %Rrc"), vrc);
3660 }
3661
3662 return hrc;
3663}
3664
3665HRESULT GuestSession::fsObjExists(const com::Utf8Str &aPath, BOOL aFollowSymlinks, BOOL *aExists)
3666{
3667 AutoCaller autoCaller(this);
3668 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3669
3670 if (aPath.isEmpty())
3671 return setError(E_INVALIDARG, tr("No path specified"));
3672
3673 HRESULT hrc = i_isReadyExternal();
3674 if (FAILED(hrc))
3675 return hrc;
3676
3677 LogFlowThisFunc(("aPath=%s, aFollowSymlinks=%RTbool\n", aPath.c_str(), RT_BOOL(aFollowSymlinks)));
3678
3679 *aExists = false;
3680
3681 GuestFsObjData objData;
3682 int rcGuest;
3683 int vrc = i_fsQueryInfo(aPath, aFollowSymlinks != FALSE, objData, &rcGuest);
3684 if (RT_SUCCESS(vrc))
3685 {
3686 *aExists = TRUE;
3687 }
3688 else
3689 {
3690 if (GuestProcess::i_isGuestError(vrc))
3691 {
3692 if ( rcGuest == VERR_NOT_A_FILE
3693 || rcGuest == VERR_PATH_NOT_FOUND
3694 || rcGuest == VERR_FILE_NOT_FOUND
3695 || rcGuest == VERR_INVALID_NAME)
3696 {
3697 hrc = S_OK; /* Ignore these vrc values. */
3698 }
3699 else
3700 hrc = GuestProcess::i_setErrorExternal(this, rcGuest);
3701 }
3702 else
3703 hrc = setErrorVrc(vrc, tr("Querying file information for \"%s\" failed: %Rrc"), aPath.c_str(), vrc);
3704 }
3705
3706 return hrc;
3707}
3708
3709HRESULT GuestSession::fsObjQueryInfo(const com::Utf8Str &aPath, BOOL aFollowSymlinks, ComPtr<IGuestFsObjInfo> &aInfo)
3710{
3711 AutoCaller autoCaller(this);
3712 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3713
3714 if (aPath.isEmpty())
3715 return setError(E_INVALIDARG, tr("No path specified"));
3716
3717 HRESULT hrc = i_isReadyExternal();
3718 if (FAILED(hrc))
3719 return hrc;
3720
3721 LogFlowThisFunc(("aPath=%s, aFollowSymlinks=%RTbool\n", aPath.c_str(), RT_BOOL(aFollowSymlinks)));
3722
3723 GuestFsObjData Info; int rcGuest;
3724 int vrc = i_fsQueryInfo(aPath, aFollowSymlinks != FALSE, Info, &rcGuest);
3725 if (RT_SUCCESS(vrc))
3726 {
3727 ComObjPtr<GuestFsObjInfo> ptrFsObjInfo;
3728 hrc = ptrFsObjInfo.createObject();
3729 if (SUCCEEDED(hrc))
3730 {
3731 vrc = ptrFsObjInfo->init(Info);
3732 if (RT_SUCCESS(vrc))
3733 hrc = ptrFsObjInfo.queryInterfaceTo(aInfo.asOutParam());
3734 else
3735 hrc = setErrorVrc(vrc);
3736 }
3737 }
3738 else
3739 {
3740 if (GuestProcess::i_isGuestError(vrc))
3741 {
3742 hrc = GuestProcess::i_setErrorExternal(this, rcGuest);
3743 }
3744 else
3745 hrc = setErrorVrc(vrc, tr("Querying file information for \"%s\" failed: %Rrc"), aPath.c_str(), vrc);
3746 }
3747
3748 return hrc;
3749}
3750
3751HRESULT GuestSession::fsObjRemove(const com::Utf8Str &aPath)
3752{
3753 AutoCaller autoCaller(this);
3754 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3755
3756 if (RT_UNLIKELY(aPath.isEmpty()))
3757 return setError(E_INVALIDARG, tr("No path specified"));
3758
3759 HRESULT hrc = i_isReadyExternal();
3760 if (FAILED(hrc))
3761 return hrc;
3762
3763 LogFlowThisFunc(("aPath=%s\n", aPath.c_str()));
3764
3765 int rcGuest;
3766 int vrc = i_fileRemove(aPath, &rcGuest);
3767 if (RT_FAILURE(vrc))
3768 {
3769 if (GuestProcess::i_isGuestError(vrc))
3770 {
3771 hrc = GuestProcess::i_setErrorExternal(this, rcGuest);
3772 }
3773 else
3774 hrc = setError(VBOX_E_IPRT_ERROR, tr("Removing file \"%s\" failed: %Rrc"), aPath.c_str(), vrc);
3775 }
3776
3777 return hrc;
3778}
3779
3780HRESULT GuestSession::fsObjRename(const com::Utf8Str &aSource,
3781 const com::Utf8Str &aDestination,
3782 const std::vector<FsObjRenameFlag_T> &aFlags)
3783{
3784 AutoCaller autoCaller(this);
3785 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3786
3787 if (RT_UNLIKELY(aSource.isEmpty()))
3788 return setError(E_INVALIDARG, tr("No source path specified"));
3789
3790 if (RT_UNLIKELY(aDestination.isEmpty()))
3791 return setError(E_INVALIDARG, tr("No destination path specified"));
3792
3793 HRESULT hrc = i_isReadyExternal();
3794 if (FAILED(hrc))
3795 return hrc;
3796
3797 /* Combine, validate and convert flags. */
3798 uint32_t fApiFlags = 0;
3799 for (size_t i = 0; i < aFlags.size(); i++)
3800 fApiFlags |= aFlags[i];
3801 if (fApiFlags & ~((uint32_t)FsObjRenameFlag_NoReplace | (uint32_t)FsObjRenameFlag_Replace))
3802 return setError(E_INVALIDARG, tr("Unknown rename flag: %#x"), fApiFlags);
3803
3804 LogFlowThisFunc(("aSource=%s, aDestination=%s\n", aSource.c_str(), aDestination.c_str()));
3805
3806 AssertCompile(FsObjRenameFlag_NoReplace == 0);
3807 AssertCompile(FsObjRenameFlag_Replace != 0);
3808 uint32_t fBackend;
3809 if ((fApiFlags & ((uint32_t)FsObjRenameFlag_NoReplace | (uint32_t)FsObjRenameFlag_Replace)) == FsObjRenameFlag_Replace)
3810 fBackend = PATHRENAME_FLAG_REPLACE;
3811 else
3812 fBackend = PATHRENAME_FLAG_NO_REPLACE;
3813
3814 /* Call worker to do the job. */
3815 int rcGuest;
3816 int vrc = i_pathRename(aSource, aDestination, fBackend, &rcGuest);
3817 if (RT_FAILURE(vrc))
3818 {
3819 switch (vrc)
3820 {
3821 case VERR_NOT_SUPPORTED:
3822 hrc = setError(VBOX_E_IPRT_ERROR,
3823 tr("Handling renaming guest directories not supported by installed Guest Additions"));
3824 break;
3825
3826 case VERR_GSTCTL_GUEST_ERROR:
3827 hrc = setError(VBOX_E_IPRT_ERROR,
3828 tr("Renaming guest directory failed: %Rrc"), rcGuest);
3829 break;
3830
3831 default:
3832 hrc = setError(VBOX_E_IPRT_ERROR, tr("Renaming guest directory \"%s\" failed: %Rrc"),
3833 aSource.c_str(), vrc);
3834 break;
3835 }
3836 }
3837
3838 return hrc;
3839}
3840
3841HRESULT GuestSession::fsObjMove(const com::Utf8Str &aSource, const com::Utf8Str &aDestination,
3842 const std::vector<FsObjMoveFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
3843{
3844 RT_NOREF(aSource, aDestination, aFlags, aProgress);
3845 ReturnComNotImplemented();
3846}
3847
3848HRESULT GuestSession::fsObjSetACL(const com::Utf8Str &aPath, BOOL aFollowSymlinks, const com::Utf8Str &aAcl, ULONG aMode)
3849{
3850 RT_NOREF(aPath, aFollowSymlinks, aAcl, aMode);
3851 ReturnComNotImplemented();
3852}
3853
3854
3855HRESULT GuestSession::processCreate(const com::Utf8Str &aExecutable, const std::vector<com::Utf8Str> &aArguments,
3856 const std::vector<com::Utf8Str> &aEnvironment,
3857 const std::vector<ProcessCreateFlag_T> &aFlags,
3858 ULONG aTimeoutMS, ComPtr<IGuestProcess> &aGuestProcess)
3859{
3860 LogFlowThisFuncEnter();
3861
3862 std::vector<LONG> affinityIgnored;
3863 return processCreateEx(aExecutable, aArguments, aEnvironment, aFlags, aTimeoutMS, ProcessPriority_Default,
3864 affinityIgnored, aGuestProcess);
3865}
3866
3867HRESULT GuestSession::processCreateEx(const com::Utf8Str &aExecutable, const std::vector<com::Utf8Str> &aArguments,
3868 const std::vector<com::Utf8Str> &aEnvironment,
3869 const std::vector<ProcessCreateFlag_T> &aFlags, ULONG aTimeoutMS,
3870 ProcessPriority_T aPriority, const std::vector<LONG> &aAffinity,
3871 ComPtr<IGuestProcess> &aGuestProcess)
3872{
3873 AutoCaller autoCaller(this);
3874 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3875
3876 HRESULT hr = i_isReadyExternal();
3877 if (FAILED(hr))
3878 return hr;
3879
3880 /** @todo r=bird: Check input better? aPriority is passed on to the guest
3881 * without any validation. Flags not existing in this vbox version are
3882 * ignored, potentially doing something entirely different than what the
3883 * caller had in mind. */
3884
3885 /*
3886 * Must have an executable to execute. If none is given, we try use the
3887 * zero'th argument.
3888 */
3889 const char *pszExecutable = aExecutable.c_str();
3890 if (RT_UNLIKELY(pszExecutable == NULL || *pszExecutable == '\0'))
3891 {
3892 if (aArguments.size() > 0)
3893 pszExecutable = aArguments[0].c_str();
3894 if (pszExecutable == NULL || *pszExecutable == '\0')
3895 return setError(E_INVALIDARG, tr("No command to execute specified"));
3896 }
3897
3898 LogFlowThisFuncEnter();
3899
3900 /*
3901 * Build the process startup info.
3902 */
3903 GuestProcessStartupInfo procInfo;
3904
3905 /* Executable and arguments. */
3906 procInfo.mExecutable = pszExecutable;
3907 if (aArguments.size())
3908 for (size_t i = 0; i < aArguments.size(); i++)
3909 procInfo.mArguments.push_back(aArguments[i]);
3910
3911 /* Combine the environment changes associated with the ones passed in by
3912 the caller, giving priority to the latter. The changes are putenv style
3913 and will be applied to the standard environment for the guest user. */
3914 int vrc = procInfo.mEnvironmentChanges.copy(mData.mEnvironmentChanges);
3915 if (RT_SUCCESS(vrc))
3916 vrc = procInfo.mEnvironmentChanges.applyPutEnvArray(aEnvironment);
3917 if (RT_SUCCESS(vrc))
3918 {
3919 /* Convert the flag array into a mask. */
3920 if (aFlags.size())
3921 for (size_t i = 0; i < aFlags.size(); i++)
3922 procInfo.mFlags |= aFlags[i];
3923
3924 procInfo.mTimeoutMS = aTimeoutMS;
3925
3926 /** @todo use RTCPUSET instead of archaic 64-bit variables! */
3927 if (aAffinity.size())
3928 for (size_t i = 0; i < aAffinity.size(); i++)
3929 if (aAffinity[i])
3930 procInfo.mAffinity |= (uint64_t)1 << i;
3931
3932 procInfo.mPriority = aPriority;
3933
3934 /*
3935 * Create a guest process object.
3936 */
3937 ComObjPtr<GuestProcess> pProcess;
3938 vrc = i_processCreateEx(procInfo, pProcess);
3939 if (RT_SUCCESS(vrc))
3940 {
3941 ComPtr<IGuestProcess> pIProcess;
3942 hr = pProcess.queryInterfaceTo(pIProcess.asOutParam());
3943 if (SUCCEEDED(hr))
3944 {
3945 /*
3946 * Start the process.
3947 */
3948 vrc = pProcess->i_startProcessAsync();
3949 if (RT_SUCCESS(vrc))
3950 {
3951 aGuestProcess = pIProcess;
3952
3953 LogFlowFuncLeaveRC(vrc);
3954 return S_OK;
3955 }
3956
3957 hr = setErrorVrc(vrc, tr("Failed to start guest process: %Rrc"), vrc);
3958 }
3959 }
3960 else if (vrc == VERR_GSTCTL_MAX_OBJECTS_REACHED)
3961 hr = setErrorVrc(vrc, tr("Maximum number of concurrent guest processes per session (%u) reached"),
3962 VBOX_GUESTCTRL_MAX_OBJECTS);
3963 else
3964 hr = setErrorVrc(vrc, tr("Failed to create guest process object: %Rrc"), vrc);
3965 }
3966 else
3967 hr = setErrorVrc(vrc, tr("Failed to set up the environment: %Rrc"), vrc);
3968
3969 LogFlowFuncLeaveRC(vrc);
3970 return hr;
3971}
3972
3973HRESULT GuestSession::processGet(ULONG aPid, ComPtr<IGuestProcess> &aGuestProcess)
3974
3975{
3976 AutoCaller autoCaller(this);
3977 if (FAILED(autoCaller.rc())) return autoCaller.rc();
3978
3979 if (aPid == 0)
3980 return setError(E_INVALIDARG, tr("No valid process ID (PID) specified"));
3981
3982 LogFlowThisFunc(("PID=%RU32\n", aPid));
3983
3984 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
3985
3986 HRESULT hr = S_OK;
3987
3988 ComObjPtr<GuestProcess> pProcess;
3989 int rc = i_processGetByPID(aPid, &pProcess);
3990 if (RT_FAILURE(rc))
3991 hr = setError(E_INVALIDARG, tr("No process with PID %RU32 found"), aPid);
3992
3993 /* This will set (*aProcess) to NULL if pProgress is NULL. */
3994 HRESULT hr2 = pProcess.queryInterfaceTo(aGuestProcess.asOutParam());
3995 if (SUCCEEDED(hr))
3996 hr = hr2;
3997
3998 LogFlowThisFunc(("aProcess=%p, hr=%Rhrc\n", (IGuestProcess*)aGuestProcess, hr));
3999 return hr;
4000}
4001
4002HRESULT GuestSession::symlinkCreate(const com::Utf8Str &aSource, const com::Utf8Str &aTarget, SymlinkType_T aType)
4003{
4004 RT_NOREF(aSource, aTarget, aType);
4005 ReturnComNotImplemented();
4006}
4007
4008HRESULT GuestSession::symlinkExists(const com::Utf8Str &aSymlink, BOOL *aExists)
4009
4010{
4011 RT_NOREF(aSymlink, aExists);
4012 ReturnComNotImplemented();
4013}
4014
4015HRESULT GuestSession::symlinkRead(const com::Utf8Str &aSymlink, const std::vector<SymlinkReadFlag_T> &aFlags,
4016 com::Utf8Str &aTarget)
4017{
4018 RT_NOREF(aSymlink, aFlags, aTarget);
4019 ReturnComNotImplemented();
4020}
4021
4022HRESULT GuestSession::waitFor(ULONG aWaitFor, ULONG aTimeoutMS, GuestSessionWaitResult_T *aReason)
4023{
4024 AutoCaller autoCaller(this);
4025 if (FAILED(autoCaller.rc())) return autoCaller.rc();
4026
4027 /* Note: No call to i_isReadyExternal() needed here, as the session might not has been started (yet). */
4028
4029 LogFlowThisFuncEnter();
4030
4031 HRESULT hrc = S_OK;
4032
4033 /*
4034 * Note: Do not hold any locks here while waiting!
4035 */
4036 int rcGuest; GuestSessionWaitResult_T waitResult;
4037 int vrc = i_waitFor(aWaitFor, aTimeoutMS, waitResult, &rcGuest);
4038 if (RT_SUCCESS(vrc))
4039 *aReason = waitResult;
4040 else
4041 {
4042 switch (vrc)
4043 {
4044 case VERR_GSTCTL_GUEST_ERROR:
4045 hrc = GuestSession::i_setErrorExternal(this, rcGuest);
4046 break;
4047
4048 case VERR_TIMEOUT:
4049 *aReason = GuestSessionWaitResult_Timeout;
4050 break;
4051
4052 default:
4053 {
4054 const char *pszSessionName = mData.mSession.mName.c_str();
4055 hrc = setError(VBOX_E_IPRT_ERROR,
4056 tr("Waiting for guest session \"%s\" failed: %Rrc"),
4057 pszSessionName ? pszSessionName : tr("Unnamed"), vrc);
4058 break;
4059 }
4060 }
4061 }
4062
4063 LogFlowFuncLeaveRC(vrc);
4064 return hrc;
4065}
4066
4067HRESULT GuestSession::waitForArray(const std::vector<GuestSessionWaitForFlag_T> &aWaitFor, ULONG aTimeoutMS,
4068 GuestSessionWaitResult_T *aReason)
4069{
4070 AutoCaller autoCaller(this);
4071 if (FAILED(autoCaller.rc())) return autoCaller.rc();
4072
4073 /* Note: No call to i_isReadyExternal() needed here, as the session might not has been started (yet). */
4074
4075 LogFlowThisFuncEnter();
4076
4077 /*
4078 * Note: Do not hold any locks here while waiting!
4079 */
4080 uint32_t fWaitFor = GuestSessionWaitForFlag_None;
4081 for (size_t i = 0; i < aWaitFor.size(); i++)
4082 fWaitFor |= aWaitFor[i];
4083
4084 return WaitFor(fWaitFor, aTimeoutMS, aReason);
4085}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette