VirtualBox

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

Last change on this file since 60490 was 60490, checked in by vboxsync, 9 years ago

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

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