VirtualBox

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

Last change on this file since 91516 was 91516, checked in by vboxsync, 3 years ago

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