831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync#include "GuestImpl.h"

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync#include "GuestSessionImpl.h"

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync#include "GuestCtrlImplPrivate.h"

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync#include "Global.h"

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync#include "AutoCaller.h"

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync#include "ProgressImpl.h"

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync#include <memory> /* For auto_ptr. */

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync#include <iprt/env.h>

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync#include <iprt/file.h> /* For CopyTo/From. */

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync#include <VBox/com/array.h>

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync#include <VBox/version.h>

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsyncDEFINE_EMPTY_CTOR_DTOR(GuestSession)

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsyncHRESULT GuestSession::FinalConstruct(void)

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync{

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync LogFlowThisFunc(("\n"));

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync return BaseFinalConstruct();

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync}

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsyncvoid GuestSession::FinalRelease(void)

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync{

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync LogFlowThisFuncEnter();

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync uninit();

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync BaseFinalRelease();

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync LogFlowThisFuncLeave();

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync}

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsyncGuestSessionTask::GuestSessionTask(GuestSession *pSession, Progress *pProgress)

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync{

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync mSession = pSession;

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync mProgress = pProgress;

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync}

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsyncGuestSessionTask::~GuestSessionTask(void)

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync{

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync}

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsyncint GuestSessionTask::setProgress(unsigned uPercent)

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync{

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync BOOL fCanceled;

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync mProgress->COMGETTER(Canceled)(&fCanceled);

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync if (fCanceled)

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync return VERR_CANCELLED;

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync mProgress->SetCurrentOperationProgress(uPercent);

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync return VINF_SUCCESS;

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync}

831b4c533723665e3a004ca13c9f413f4221ffbbvboxsync

int GuestSessionTask::setProgressSuccess(void)

{

BOOL fCanceled;

BOOL fCompleted;

if ( SUCCEEDED(mProgress->COMGETTER(Canceled(&fCanceled)))

&& !fCanceled

&& SUCCEEDED(mProgress->COMGETTER(Completed(&fCompleted)))

&& !fCompleted)

{

HRESULT hr = mProgress->notifyComplete(S_OK);

if (FAILED(hr))

return VERR_COM_UNEXPECTED; /** @todo Find a better rc. */

}

return VINF_SUCCESS;

}

int GuestSessionTask::setProgressErrorMsg(HRESULT hr, const Utf8Str &strMsg)

{

BOOL fCanceled;

BOOL fCompleted;

if ( SUCCEEDED(mProgress->COMGETTER(Canceled(&fCanceled)))

&& !fCanceled

&& SUCCEEDED(mProgress->COMGETTER(Completed(&fCompleted)))

&& !fCompleted)

{

HRESULT hr2 = mProgress->notifyComplete(hr,

COM_IIDOF(IGuestSession),

GuestSession::getStaticComponentName(),

strMsg.c_str());

if (FAILED(hr2))

return VERR_COM_UNEXPECTED;

}

return VINF_SUCCESS;

}

SessionTaskCopyTo::SessionTaskCopyTo(GuestSession *pSession, Progress *pProgress,

const Utf8Str &strSource, const Utf8Str &strDest, uint32_t uFlags)

: GuestSessionTask(pSession, pProgress)

{

mSource = strSource;

mDest = mDest;

mFlags = uFlags;

}

SessionTaskCopyTo::~SessionTaskCopyTo(void)

{

}

int SessionTaskCopyTo::Run(void)

{

LogFlowThisFuncEnter();

ComObjPtr<GuestSession> pSession = mSession;

Assert(!pSession.isNull());

AutoCaller autoCaller(pSession);

if (FAILED(autoCaller.rc())) return autoCaller.rc();

int rc;

/** @todo Make use of exception (+ finally block) here! */

try

{

/* Does our source file exist? */

if (!RTFileExists(mSource.c_str()))

{

rc = setProgressErrorMsg(VBOX_E_IPRT_ERROR,

Utf8StrFmt(GuestSession::tr("Source file \"%s\" does not exist or is not a file"),

mSource.c_str()));

}

else

{

RTFILE fileSource;

rc = RTFileOpen(&fileSource, mSource.c_str(),

RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);

if (RT_FAILURE(rc))

{

rc = setProgressErrorMsg(VBOX_E_IPRT_ERROR,

Utf8StrFmt(GuestSession::tr("Could not open source file \"%s\" for reading (%Rrc)"),

mSource.c_str(), rc));

}

else

{

uint64_t cbFileSize;

rc = RTFileGetSize(fileSource, &cbFileSize);

if (RT_FAILURE(rc))

{

setProgressErrorMsg(VBOX_E_IPRT_ERROR,

Utf8StrFmt(GuestSession::tr("Could not query file size of \"%s\" (%Rrc)"),

mSource.c_str(), rc));

}

else

{

GuestProcessInfo procInfo;

procInfo.mName = Utf8StrFmt(GuestSession::tr("Copying file \"%s\" to the guest to \"%s\" (%RU64 bytes)"),

mSource.c_str(), mDest.c_str(), cbFileSize);

procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_CAT);

procInfo.mFlags = ProcessCreateFlag_None;

/* Set arguments.*/

procInfo.mArguments.push_back(Utf8StrFmt("--output=%s", mDest.c_str())); /** @todo Do we need path conversion? */

/* Startup process. */

ComObjPtr<GuestProcess> pProcess;

int rc = pSession->processCreateExInteral(procInfo, pProcess);

if (RT_SUCCESS(rc))

{

GuestProcessWaitResult waitRes;

BYTE byBuf[_64K];

BOOL fCanceled = FALSE;

uint64_t cbWrittenTotal = 0;

uint64_t cbToRead = cbFileSize;

for (;;)

{

rc = pProcess->waitFor(ProcessWaitForFlag_StdIn,

30 * 1000 /* Timeout */, waitRes);

if ( RT_FAILURE(rc)

|| waitRes.mResult != ProcessWaitResult_StdIn)

{

break;

}

size_t cbRead = 0;

if (cbFileSize) /* If we have nothing to write, take a shortcut. */

{

/** @todo Not very efficient, but works for now. */

rc = RTFileSeek(fileSource, cbWrittenTotal,

RTFILE_SEEK_BEGIN, NULL /* poffActual */);

if (RT_SUCCESS(rc))

{

rc = RTFileRead(fileSource, (uint8_t*)byBuf,

RT_MIN(cbToRead, sizeof(byBuf)), &cbRead);

/*

if (RT_FAILURE(rc))

{

setProgressErrorMsg(VBOX_E_IPRT_ERROR,

Utf8StrFmt(GuestSession::tr("Could not read from file \"%s\" (%Rrc)"),

mSource.c_str(), rc));

break;

}

}

else

{

setProgressErrorMsg(VBOX_E_IPRT_ERROR,

Utf8StrFmt(GuestSession::tr("Seeking file \"%s\" offset %RU64 failed: %Rrc"),

mSource.c_str(), cbWrittenTotal, rc));

break;

}

}

uint32_t fFlags = ProcessInputFlag_None;

/* Did we reach the end of the content we want to transfer (last chunk)? */

if ( (cbRead < sizeof(byBuf))

/* Did we reach the last block which is exactly _64K? */

|| (cbToRead - cbRead == 0)

/* ... or does the user want to cancel? */

|| ( SUCCEEDED(mProgress->COMGETTER(Canceled(&fCanceled)))

&& fCanceled)

)

{

fFlags |= ProcessInputFlag_EndOfFile;

}

uint32_t cbWritten;

rc = pProcess->writeData(0 /* StdIn */, fFlags,

byBuf, sizeof(byBuf),

30 * 1000 /* Timeout */, &cbWritten);

if (RT_FAILURE(rc))

{

setProgressErrorMsg(VBOX_E_IPRT_ERROR,

Utf8StrFmt(GuestSession::tr("Writing to file \"%s\" (offset %RU64) failed: %Rrc"),

mSource.c_str(), cbWrittenTotal, rc));

break;

}

/* Safety first. */

Assert(cbRead <= cbToRead);

Assert(cbToRead >= cbRead);

/* Only subtract bytes reported written by the guest. */

cbToRead -= cbWritten;

/* Update total bytes written to the guest. */

cbWrittenTotal += cbWritten;

Assert(cbWrittenTotal <= cbFileSize);

/* Did the user cancel the operation above? */

if (fCanceled)

break;

/* Update the progress. */

HRESULT hr = mProgress->SetCurrentOperationProgress((ULONG)(cbWrittenTotal * 100 / cbFileSize));

if (FAILED(hr))

{

rc = setProgressErrorMsg(VBOX_E_IPRT_ERROR,

Utf8StrFmt(GuestSession::tr("Error updating the progress of copying files \"%s\" to \"%s\""),

mSource.c_str(), mDest.c_str()));

break;

}

/* End of file reached? */

if (cbToRead == 0)

break;

} /* for */

if ( !fCanceled

|| RT_SUCCESS(rc))

{

/*

if ( cbFileSize > 0

&& cbWrittenTotal == 0)

{

/* If nothing was transfered but the file size was > 0 then "vbox_cat" wasn't able to write

rc = setProgressErrorMsg(VBOX_E_IPRT_ERROR,

Utf8StrFmt(GuestSession::tr("Access denied when copying file \"%s\" to \"%s\""),

mSource.c_str(), mDest.c_str()));

}

else if (cbWrittenTotal < cbFileSize)

{

/* If we did not copy all let the user know. */

rc = setProgressErrorMsg(VBOX_E_IPRT_ERROR,

Utf8StrFmt(GuestSession::tr("Copying file \"%s\" failed (%RU64/%RU64 bytes transfered)"),

mSource.c_str(), cbWrittenTotal, cbFileSize));

}

else /* Yay, all went fine! */

rc = setProgressSuccess();

}

} /* processCreateExInteral */

} /* RTFileGetSize */

RTFileClose(fileSource);

} /* RTFileOpen */

} /* RTFileExists */

}

catch (int rc2)

{

rc = rc2;

}

LogFlowFuncLeaveRC(rc);

return rc;

}

int SessionTaskCopyTo::RunAsync(const Utf8Str &strDesc)

{

LogFlowThisFunc(("strDesc=%s, strSource=%s, strDest=%s, uFlags=%x\n",

strDesc.c_str(), mSource.c_str(), mDest.c_str(), mFlags));

mDesc = strDesc;

int rc = RTThreadCreate(NULL, SessionTaskCopyTo::taskThread, this,

0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,

"gctlCpyTo");

LogFlowFuncLeaveRC(rc);

return rc;

}

int SessionTaskCopyTo::taskThread(RTTHREAD Thread, void *pvUser)

{

std::auto_ptr<SessionTaskCopyTo> task(static_cast<SessionTaskCopyTo*>(pvUser));

AssertReturn(task.get(), VERR_GENERAL_FAILURE);

LogFlowFunc(("pTask=%p\n", task.get()));

return task->Run();

}

SessionTaskCopyFrom::SessionTaskCopyFrom(GuestSession *pSession, Progress *pProgress,

const Utf8Str &strSource, const Utf8Str &strDest, uint32_t uFlags)

: GuestSessionTask(pSession, pProgress)

{

mSource = strSource;

mDest = mDest;

mFlags = uFlags;

}

SessionTaskCopyFrom::~SessionTaskCopyFrom(void)

{

}

int SessionTaskCopyFrom::Run(void)

{

return 0;

}

int SessionTaskCopyFrom::RunAsync(const Utf8Str &strDesc)

{

LogFlowThisFunc(("strDesc=%s, strSource=%s, strDest=%s, uFlags=%x\n",

strDesc.c_str(), mSource.c_str(), mDest.c_str(), mFlags));

mDesc = strDesc;

int rc = RTThreadCreate(NULL, SessionTaskCopyFrom::taskThread, this,

0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,

"gctlCpyFrom");

LogFlowFuncLeaveRC(rc);

return rc;

}

int SessionTaskCopyFrom::taskThread(RTTHREAD Thread, void *pvUser)

{

std::auto_ptr<SessionTaskCopyFrom> task(static_cast<SessionTaskCopyFrom*>(pvUser));

AssertReturn(task.get(), VERR_GENERAL_FAILURE);

LogFlowFunc(("pTask=%p\n", task.get()));

return task->Run();

}

int GuestSession::init(Guest *aGuest, ULONG aSessionID,

Utf8Str aUser, Utf8Str aPassword, Utf8Str aDomain, Utf8Str aName)

{

LogFlowThisFuncEnter();

AssertPtrReturn(aGuest, VERR_INVALID_POINTER);

/* Enclose the state transition NotReady->InInit->Ready. */

AutoInitSpan autoInitSpan(this);

AssertReturn(autoInitSpan.isOk(), VERR_OBJECT_DESTROYED);

mData.mTimeout = 30 * 60 * 1000; /* Session timeout is 30 mins by default. */

mData.mParent = aGuest;

mData.mId = aSessionID;

mData.mCredentials.mUser = aUser;

mData.mCredentials.mPassword = aPassword;

mData.mCredentials.mDomain = aDomain;

mData.mName = aName;

mData.mNextProcessID = 0;

/* Confirm a successful initialization when it's the case. */

autoInitSpan.setSucceeded();

LogFlowFuncLeaveRC(VINF_SUCCESS);

return VINF_SUCCESS;

}

void GuestSession::uninit(void)

{

LogFlowThisFuncEnter();

/* Enclose the state transition Ready->InUninit->NotReady. */

AutoUninitSpan autoUninitSpan(this);

if (autoUninitSpan.uninitDone())

return;

#ifdef VBOX_WITH_GUEST_CONTROL

for (SessionDirectories::iterator itDirs = mData.mDirectories.begin();

itDirs != mData.mDirectories.end(); ++itDirs)

{

(*itDirs)->uninit();

(*itDirs).setNull();

}

mData.mDirectories.clear();

for (SessionFiles::iterator itFiles = mData.mFiles.begin();

itFiles != mData.mFiles.end(); ++itFiles)

{

(*itFiles)->uninit();

(*itFiles).setNull();

}

mData.mFiles.clear();

for (SessionProcesses::iterator itProcs = mData.mProcesses.begin();

itProcs != mData.mProcesses.end(); ++itProcs)

{

itProcs->second->close();

}

for (SessionProcesses::iterator itProcs = mData.mProcesses.begin();

itProcs != mData.mProcesses.end(); ++itProcs)

{

itProcs->second->uninit();

itProcs->second.setNull();

}

mData.mProcesses.clear();

mData.mParent->sessionClose(this);

LogFlowThisFuncLeave();

#endif

}

STDMETHODIMP GuestSession::COMGETTER(User)(BSTR *aUser)

{

#ifndef VBOX_WITH_GUEST_CONTROL

ReturnComNotImplemented();

#else

LogFlowThisFuncEnter();

CheckComArgOutPointerValid(aUser);

AutoCaller autoCaller(this);

if (FAILED(autoCaller.rc())) return autoCaller.rc();

AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);

mData.mCredentials.mUser.cloneTo(aUser);

LogFlowFuncLeaveRC(S_OK);

return S_OK;

#endif /* VBOX_WITH_GUEST_CONTROL */

}

STDMETHODIMP GuestSession::COMGETTER(Domain)(BSTR *aDomain)

{

#ifndef VBOX_WITH_GUEST_CONTROL

ReturnComNotImplemented();

#else

LogFlowThisFuncEnter();

CheckComArgOutPointerValid(aDomain);

AutoCaller autoCaller(this);

if (FAILED(autoCaller.rc())) return autoCaller.rc();

AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);

mData.mCredentials.mDomain.cloneTo(aDomain);

LogFlowFuncLeaveRC(S_OK);

return S_OK;

#endif /* VBOX_WITH_GUEST_CONTROL */

}

STDMETHODIMP GuestSession::COMGETTER(Name)(BSTR *aName)

{

#ifndef VBOX_WITH_GUEST_CONTROL

ReturnComNotImplemented();

#else

LogFlowThisFuncEnter();

CheckComArgOutPointerValid(aName);

AutoCaller autoCaller(this);

if (FAILED(autoCaller.rc())) return autoCaller.rc();

AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);

mData.mName.cloneTo(aName);

LogFlowFuncLeaveRC(S_OK);

return S_OK;

#endif /* VBOX_WITH_GUEST_CONTROL */

}

STDMETHODIMP GuestSession::COMGETTER(Id)(ULONG *aId)

{

#ifndef VBOX_WITH_GUEST_CONTROL

ReturnComNotImplemented();

#else

LogFlowThisFuncEnter();

CheckComArgOutPointerValid(aId);

AutoCaller autoCaller(this);

if (FAILED(autoCaller.rc())) return autoCaller.rc();

AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);

*aId = mData.mId;

LogFlowFuncLeaveRC(S_OK);

return S_OK;

#endif /* VBOX_WITH_GUEST_CONTROL */

}

STDMETHODIMP GuestSession::COMGETTER(Timeout)(ULONG *aTimeout)

{

#ifndef VBOX_WITH_GUEST_CONTROL

ReturnComNotImplemented();

#else

LogFlowThisFuncEnter();

CheckComArgOutPointerValid(aTimeout);

AutoCaller autoCaller(this);

if (FAILED(autoCaller.rc())) return autoCaller.rc();

AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);

*aTimeout = mData.mTimeout;

LogFlowFuncLeaveRC(S_OK);

return S_OK;

#endif /* VBOX_WITH_GUEST_CONTROL */

}

STDMETHODIMP GuestSession::COMSETTER(Timeout)(ULONG aTimeout)

{

#ifndef VBOX_WITH_GUEST_CONTROL

ReturnComNotImplemented();

#else

LogFlowThisFuncEnter();

AutoCaller autoCaller(this);

if (FAILED(autoCaller.rc())) return autoCaller.rc();

AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);

mData.mTimeout = aTimeout;

LogFlowFuncLeaveRC(S_OK);

return S_OK;

#endif /* VBOX_WITH_GUEST_CONTROL */

}

STDMETHODIMP GuestSession::COMGETTER(Environment)(ComSafeArrayOut(BSTR, aEnvironment))

{

#ifndef VBOX_WITH_GUEST_CONTROL

ReturnComNotImplemented();

#else

LogFlowThisFuncEnter();

CheckComArgOutSafeArrayPointerValid(aEnvironment);

AutoCaller autoCaller(this);

if (FAILED(autoCaller.rc())) return autoCaller.rc();

AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);

size_t cEnvVars = mData.mEnvironment.Size();

LogFlowThisFunc(("%s cEnvVars=%RU32\n", mData.mName.c_str(), cEnvVars));

com::SafeArray<BSTR> environment(cEnvVars);

for (size_t i = 0; i < cEnvVars; i++)

{

Bstr strEnv(mData.mEnvironment.Get(i));

strEnv.cloneTo(&environment[i]);

}

environment.detachTo(ComSafeArrayOutArg(aEnvironment));

LogFlowFuncLeaveRC(S_OK);

return S_OK;

#endif /* VBOX_WITH_GUEST_CONTROL */

}

STDMETHODIMP GuestSession::COMSETTER(Environment)(ComSafeArrayIn(IN_BSTR, aValues))

{

#ifndef VBOX_WITH_GUEST_CONTROL

ReturnComNotImplemented();

#else

LogFlowThisFuncEnter();

AutoCaller autoCaller(this);

if (FAILED(autoCaller.rc())) return autoCaller.rc();

AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);

com::SafeArray<IN_BSTR> environment(ComSafeArrayInArg(aValues));

int rc = VINF_SUCCESS;

for (size_t i = 0; i < environment.size() && RT_SUCCESS(rc); i++)

{

Utf8Str strEnv(environment[i]);

if (!strEnv.isEmpty()) /* Silently skip empty entries. */

rc = mData.mEnvironment.Set(strEnv);

}

HRESULT hr = RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;

LogFlowFuncLeaveRC(hr);

return hr;

#endif /* VBOX_WITH_GUEST_CONTROL */

}

STDMETHODIMP GuestSession::COMGETTER(Processes)(ComSafeArrayOut(IGuestProcess *, aProcesses))

{

#ifndef VBOX_WITH_GUEST_CONTROL

ReturnComNotImplemented();

#else

LogFlowThisFuncEnter();

CheckComArgOutSafeArrayPointerValid(aProcesses);

AutoCaller autoCaller(this);

if (FAILED(autoCaller.rc())) return autoCaller.rc();

AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);

SafeIfaceArray<IGuestProcess> collection(mData.mProcesses);

collection.detachTo(ComSafeArrayOutArg(aProcesses));

LogFlowFuncLeaveRC(S_OK);

return S_OK;

#endif /* VBOX_WITH_GUEST_CONTROL */

}

STDMETHODIMP GuestSession::COMGETTER(Directories)(ComSafeArrayOut(IGuestDirectory *, aDirectories))

{

#ifndef VBOX_WITH_GUEST_CONTROL

ReturnComNotImplemented();

#else

LogFlowThisFuncEnter();

CheckComArgOutSafeArrayPointerValid(aDirectories);

AutoCaller autoCaller(this);

if (FAILED(autoCaller.rc())) return autoCaller.rc();

AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);

SafeIfaceArray<IGuestDirectory> collection(mData.mDirectories);

collection.detachTo(ComSafeArrayOutArg(aDirectories));

LogFlowFuncLeaveRC(S_OK);

return S_OK;

#endif /* VBOX_WITH_GUEST_CONTROL */

}

STDMETHODIMP GuestSession::COMGETTER(Files)(ComSafeArrayOut(IGuestFile *, aFiles))

{

#ifndef VBOX_WITH_GUEST_CONTROL

ReturnComNotImplemented();

#else

LogFlowThisFuncEnter();

CheckComArgOutSafeArrayPointerValid(aFiles);

AutoCaller autoCaller(this);

if (FAILED(autoCaller.rc())) return autoCaller.rc();

AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);

SafeIfaceArray<IGuestFile> collection(mData.mFiles);

collection.detachTo(ComSafeArrayOutArg(aFiles));

LogFlowFuncLeaveRC(S_OK);

return S_OK;

#endif /* VBOX_WITH_GUEST_CONTROL */

}

int GuestSession::directoryClose(ComObjPtr<GuestDirectory> pDirectory)

{

AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);

for (SessionDirectories::iterator itDirs = mData.mDirectories.begin();

itDirs != mData.mDirectories.end(); ++itDirs)

{

if (pDirectory == (*itDirs))

{

mData.mDirectories.erase(itDirs);

return VINF_SUCCESS;

}

}

return VERR_NOT_FOUND;

}

int GuestSession::directoryCreateInternal(const Utf8Str &strPath, uint32_t uMode, uint32_t uFlags, ComObjPtr<GuestDirectory> &pDirectory)

{

LogFlowThisFunc(("strPath=%s, uMode=%x, uFlags=%x\n",

strPath.c_str(), uMode, uFlags));

GuestProcessInfo procInfo;

procInfo.mName = Utf8StrFmt(tr("Creating directory \"%s\"", strPath.c_str()));

procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_MKDIR);

int rc = VINF_SUCCESS;

/* Construct arguments. */

if (uFlags & DirectoryCreateFlag_Parents)

procInfo.mArguments.push_back(Utf8Str("--parents")); /* We also want to create the parent directories. */

if (uMode)

{

procInfo.mArguments.push_back(Utf8Str("--mode")); /* Set the creation mode. */

char szMode[16];

if (RTStrPrintf(szMode, sizeof(szMode), "%o", uMode))

{

procInfo.mArguments.push_back(Utf8Str(szMode));

}

else

rc = VERR_INVALID_PARAMETER;

}

procInfo.mArguments.push_back(strPath); /* The directory we want to create. */

ComObjPtr<GuestProcess> pProcess;

rc = processCreateExInteral(procInfo, pProcess);

if (RT_SUCCESS(rc))

{

GuestProcessWaitResult waitRes;

rc = pProcess->waitFor(ProcessWaitForFlag_Terminate, 30 * 1000 /* Timeout */, waitRes);

if (RT_SUCCESS(rc))

{

ProcessStatus_T procStatus;

HRESULT hr = pProcess->COMGETTER(Status)(&procStatus);

ComAssertComRC(hr);

if (procStatus == ProcessStatus_TerminatedNormally)

{

LONG lExitCode;

pProcess->COMGETTER(ExitCode)(&lExitCode);

if (lExitCode != 0)

return VERR_CANT_CREATE;

}

else

rc = VERR_BROKEN_PIPE; /** @todo Find a better rc. */

}

}

if (RT_FAILURE(rc))

return rc;

try

{

/* Create the directory object. */

HRESULT hr = pDirectory.createObject();

if (FAILED(hr)) throw VERR_COM_UNEXPECTED;

/* Note: There will be a race between creating and getting/initing the directory

rc = pDirectory->init(this /* Parent */, strPath);

if (RT_FAILURE(rc)) throw rc;

/* Add the created directory to our vector. */

mData.mDirectories.push_back(pDirectory);

LogFlowFunc(("Added new directory (Session: %RU32) with process ID=%RU32\n",

mData.mId, mData.mNextProcessID));

}

catch (int rc2)

{

rc = rc2;

}

LogFlowFuncLeaveRC(rc);

return rc;

}

int GuestSession::dispatchToProcess(uint32_t uContextID, uint32_t uFunction, void *pvData, size_t cbData)

{

LogFlowFuncEnter();

AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);

uint32_t uProcessID = VBOX_GUESTCTRL_CONTEXTID_GET_PROCESS(uContextID);

#ifdef DEBUG

LogFlowFunc(("uProcessID=%RU32 (%RU32 total)\n",

uProcessID, mData.mProcesses.size()));

#endif

int rc;

SessionProcesses::const_iterator itProc

= mData.mProcesses.find(uProcessID);

if (itProc != mData.mProcesses.end())

{

ComObjPtr<GuestProcess> pProcess(itProc->second);

Assert(!pProcess.isNull());

alock.release();

rc = pProcess->callbackDispatcher(uContextID, uFunction, pvData, cbData);

}

else

rc = VERR_NOT_FOUND;

LogFlowFuncLeaveRC(rc);

return rc;

}

int GuestSession::fileClose(ComObjPtr<GuestFile> pFile)

{

AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);

for (SessionFiles::iterator itFiles = mData.mFiles.begin();

itFiles != mData.mFiles.end(); ++itFiles)

{

if (pFile == (*itFiles))

{

mData.mFiles.erase(itFiles);

return VINF_SUCCESS;

}

}

return VERR_NOT_FOUND;

}

int GuestSession::fileQueryInfoInternal(const Utf8Str &strPath, GuestFsObjData &objData)

{

LogFlowThisFunc(("strPath=%s\n", strPath.c_str()));

GuestProcessInfo procInfo;

procInfo.mName = Utf8StrFmt(tr("Querying info for \"%s\"", strPath.c_str()));

procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_STAT);

procInfo.mFlags = ProcessCreateFlag_WaitForStdOut;

/* Construct arguments. */

procInfo.mArguments.push_back(Utf8Str("--machinereadable"));

procInfo.mArguments.push_back(strPath);

GuestProcessStream streamOut;

ComObjPtr<GuestProcess> pProcess;

int rc = processCreateExInteral(procInfo, pProcess);

if (RT_SUCCESS(rc))

{

GuestProcessWaitResult waitRes;

BYTE byBuf[_64K];

size_t cbRead;

for (;;)

{

rc = pProcess->waitFor(ProcessWaitForFlag_StdOut,

30 * 1000 /* Timeout */, waitRes);

if ( RT_FAILURE(rc)

|| waitRes.mResult != ProcessWaitResult_StdOut)

{

break;

}

rc = pProcess->readData(OUTPUT_HANDLE_ID_STDOUT, sizeof(byBuf),

30 * 1000 /* Timeout */, byBuf, sizeof(byBuf),

&cbRead);

if (RT_FAILURE(rc))

break;

rc = streamOut.AddData(byBuf, cbRead);

if (RT_FAILURE(rc))

break;

}

LogFlowThisFunc(("rc=%Rrc, cbRead=%RU32, cbStreamOut=%RU32\n",

rc, cbRead, streamOut.GetSize()));

}

if (RT_SUCCESS(rc))

{

GuestProcessStreamBlock streamBlock;

rc = streamOut.ParseBlock(streamBlock);

if (RT_SUCCESS(rc))

{

rc = objData.From(streamBlock);

}

else

AssertMsgFailed(("Parsing stream block failed: %Rrc\n", rc));

}

LogFlowFuncLeaveRC(rc);

return rc;

}

int GuestSession::fileQuerySizeInternal(const Utf8Str &strPath, int64_t *pllSize)

{

AssertPtrReturn(pllSize, VERR_INVALID_POINTER);

GuestFsObjData objData;

int rc = fileQueryInfoInternal(strPath, objData);

if (RT_SUCCESS(rc))

{

if (objData.mType == FsObjType_File)

*pllSize = objData.mObjectSize;

else

rc = VERR_NOT_A_FILE;

}

return rc;

}

const GuestCredentials& GuestSession::getCredentials(void)

{

return mData.mCredentials;

}

const GuestEnvironment& GuestSession::getEnvironment(void)

{

return mData.mEnvironment;

}

Utf8Str GuestSession::getName(void)

{

return mData.mName;

}

int GuestSession::processClose(ComObjPtr<GuestProcess> pProcess)

{

AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);

for (SessionProcesses::iterator itProcs = mData.mProcesses.begin();

itProcs != mData.mProcesses.end(); ++itProcs)

{

if (pProcess == itProcs->second)

{

mData.mProcesses.erase(itProcs);

return VINF_SUCCESS;

}

}

return VERR_NOT_FOUND;

}

int GuestSession::processCreateExInteral(GuestProcessInfo &procInfo, ComObjPtr<GuestProcess> &pProcess)

{

LogFlowFunc(("mCmd=%s, mFlags=%x, mTimeoutMS=%RU32\n",

procInfo.mCommand.c_str(), procInfo.mFlags, procInfo.mTimeoutMS));

/* Validate flags. */

if (procInfo.mFlags)

{

if ( !(procInfo.mFlags & ProcessCreateFlag_IgnoreOrphanedProcesses)

&& !(procInfo.mFlags & ProcessCreateFlag_WaitForProcessStartOnly)

&& !(procInfo.mFlags & ProcessCreateFlag_Hidden)

&& !(procInfo.mFlags & ProcessCreateFlag_NoProfile)

&& !(procInfo.mFlags & ProcessCreateFlag_WaitForStdOut)

&& !(procInfo.mFlags & ProcessCreateFlag_WaitForStdErr))

{

return VERR_INVALID_PARAMETER;

}

}

/* Adjust timeout. If set to 0, we define

if (procInfo.mTimeoutMS == 0)

procInfo.mTimeoutMS = UINT32_MAX;

/** @tood Implement process priority + affinity. */

AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);

int rc = VERR_MAX_PROCS_REACHED;

if (mData.mProcesses.size() >= VBOX_GUESTCTRL_MAX_PROCESSES)

return rc;

/* Create a new (host-based) process ID and assign it. */

ULONG uTries = 0;

for (;;)

{

/* Is the context ID already used? */

if (!processExists(mData.mNextProcessID, NULL /* pProgress */))

{

/* Callback with context ID was not found. This means

rc = VINF_SUCCESS;

break;

}

mData.mNextProcessID++;

if (mData.mNextProcessID == UINT32_MAX)

mData.mNextProcessID = 0;

if (++uTries == UINT32_MAX)

break; /* Don't try too hard. */

}

if (RT_FAILURE(rc)) return rc;

try

{

/* Create the process object. */

HRESULT hr = pProcess.createObject();

if (FAILED(hr)) throw VERR_COM_UNEXPECTED;

rc = pProcess->init(mData.mParent->getConsole() /* Console */, this /* Session */,

mData.mNextProcessID, procInfo);

if (RT_FAILURE(rc)) throw rc;

/* Add the created process to our map. */

mData.mProcesses[mData.mNextProcessID] = pProcess;

LogFlowFunc(("Added new process (Session: %RU32) with process ID=%RU32\n",

mData.mId, mData.mNextProcessID));

}

catch (int rc2)

{

rc = rc2;

}

return rc;

}

inline bool GuestSession::processExists(uint32_t uProcessID, ComObjPtr<GuestProcess> *pProcess)

{

SessionProcesses::const_iterator it = mData.mProcesses.find(uProcessID);

if (it != mData.mProcesses.end())

{

if (pProcess)

*pProcess = it->second;

return true;

}

return false;

}

inline int GuestSession::processGetByPID(ULONG uPID, ComObjPtr<GuestProcess> *pProcess)

{

AssertReturn(uPID, false);

/* pProcess is optional. */

SessionProcesses::iterator it = mData.mProcesses.begin();

for (; it != mData.mProcesses.end(); it++)

{

ComObjPtr<GuestProcess> pCurProc = it->second;

AutoCaller procCaller(pCurProc);

if (procCaller.rc())

return VERR_COM_INVALID_OBJECT_STATE;

if (it->second->getPID() == uPID)

{

if (pProcess)

*pProcess = pCurProc;

return VINF_SUCCESS;

}

}

return VERR_NOT_FOUND;

}

int GuestSession::startTaskAsync(const Utf8Str &strTaskDesc,

GuestSessionTask *pTask, ComObjPtr<Progress> &pProgress)

{

LogFlowThisFunc(("strTaskDesc=%s, pTask=%p\n", strTaskDesc.c_str(), pTask));

AssertPtrReturn(pTask, VERR_INVALID_POINTER);

int rc;

try

{

/* Create the progress object. */

HRESULT hr = pProgress.createObject();

if (FAILED(hr)) throw VERR_COM_UNEXPECTED;

hr = pProgress->init(static_cast<IGuestSession*>(this),

Bstr(strTaskDesc).raw(),

TRUE /* aCancelable */);

if (FAILED(hr)) throw VERR_COM_UNEXPECTED;

/* Initialize our worker task. */

std::auto_ptr<GuestSessionTask> task(pTask);

rc = task->RunAsync(strTaskDesc);

if (FAILED(rc)) throw rc;

/* Don't destruct on success. */

task.release();

}

catch (int rc2)

{

rc = rc2;

}

LogFlowFuncLeaveRC(rc);

return rc;

}

int GuestSession::queryInfo(void)

{

#if 1

/* Since the new functions were not implemented yet, force Main to use protocol ver 1. */

mData.mProtocolVersion = 1;

#else

/*

ComObjPtr<Guest> pGuest = mData.mParent;

Assert(!pGuest.isNull());

uint32_t uVerAdditions = pGuest->getAdditionsVersion();

mData.mProtocolVersion = ( VBOX_FULL_VERSION_GET_MAJOR(uVerAdditions) >= 4

&& VBOX_FULL_VERSION_GET_MINOR(uVerAdditions) >= 2) /** @todo What's about v5.0 ? */

? 2 /* Guest control 2.0. */

: 1; /* Legacy guest control (VBox < 4.2). */

/* Build revision is ignored. */

/* Tell the user but don't bitch too often. */

static short s_gctrlLegacyWarning = 0;

if (s_gctrlLegacyWarning++ < 3) /** @todo Find a bit nicer text. */

LogRel((tr("Warning: Guest Additions are older (%ld.%ld) than host capabilities for guest control, please upgrade them. Using protocol version %ld now\n"),

VBOX_FULL_VERSION_GET_MAJOR(uVerAdditions), VBOX_FULL_VERSION_GET_MINOR(uVerAdditions), mData.mProtocolVersion));

#endif

return VINF_SUCCESS;

}

STDMETHODIMP GuestSession::Close(void)

{

#ifndef VBOX_WITH_GUEST_CONTROL

ReturnComNotImplemented();

#else

LogFlowThisFuncEnter();

uninit();

LogFlowFuncLeaveRC(S_OK);

return S_OK;

#endif /* VBOX_WITH_GUEST_CONTROL */

}

STDMETHODIMP GuestSession::CopyFrom(IN_BSTR aSource, IN_BSTR aDest, ComSafeArrayIn(CopyFileFlag_T, aFlags), IProgress **aProgress)

{

#ifndef VBOX_WITH_GUEST_CONTROL

ReturnComNotImplemented();

#else

CheckComArgStrNotEmptyOrNull(aSource);

CheckComArgStrNotEmptyOrNull(aDest);

CheckComArgOutPointerValid(aProgress);

LogFlowThisFuncEnter();

if (RT_UNLIKELY((aSource) == NULL || *(aSource) == '\0'))

return setError(E_INVALIDARG, tr("No source specified"));

if (RT_UNLIKELY((aDest) == NULL || *(aDest) == '\0'))

return setError(E_INVALIDARG, tr("No destination specified"));

AutoCaller autoCaller(this);

if (FAILED(autoCaller.rc())) return autoCaller.rc();

uint32_t fFlags = CopyFileFlag_None;

if (aFlags)

{

com::SafeArray<CopyFileFlag_T> flags(ComSafeArrayInArg(aFlags));

for (size_t i = 0; i < flags.size(); i++)

fFlags |= flags[i];

}

AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);

HRESULT hr = S_OK;

ComObjPtr<Progress> pProgress;

SessionTaskCopyFrom *pTask = new SessionTaskCopyFrom(this, pProgress,

Utf8Str(aSource), Utf8Str(aDest), fFlags);

AssertPtrReturn(pTask, VERR_NO_MEMORY);

int rc = startTaskAsync(Utf8StrFmt(tr("Copying \"%ls\" from guest to \"%ls\" on the host"), aSource, aDest),

pTask, pProgress);

if (RT_SUCCESS(rc))

{

/* Return progress to the caller. */

hr = pProgress.queryInterfaceTo(aProgress);

}

/** @todo rc -> hr error lookup. */

return hr;

#endif /* VBOX_WITH_GUEST_CONTROL */

}

STDMETHODIMP GuestSession::CopyTo(IN_BSTR aSource, IN_BSTR aDest, ComSafeArrayIn(CopyFileFlag_T, aFlags), IProgress **aProgress)

{

#ifndef VBOX_WITH_GUEST_CONTROL

ReturnComNotImplemented();

#else

CheckComArgStrNotEmptyOrNull(aSource);

CheckComArgStrNotEmptyOrNull(aDest);

CheckComArgOutPointerValid(aProgress);

LogFlowThisFuncEnter();

if (RT_UNLIKELY((aSource) == NULL || *(aSource) == '\0'))

return setError(E_INVALIDARG, tr("No source specified"));

if (RT_UNLIKELY((aDest) == NULL || *(aDest) == '\0'))

return setError(E_INVALIDARG, tr("No destination specified"));

AutoCaller autoCaller(this);

if (FAILED(autoCaller.rc())) return autoCaller.rc();

uint32_t fFlags = CopyFileFlag_None;

if (aFlags)

{

com::SafeArray<CopyFileFlag_T> flags(ComSafeArrayInArg(aFlags));

for (size_t i = 0; i < flags.size(); i++)

fFlags |= flags[i];

}

AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);

HRESULT hr = S_OK;

ComObjPtr<Progress> pProgress;

SessionTaskCopyTo *pTask = new SessionTaskCopyTo(this, pProgress,

Utf8Str(aSource), Utf8Str(aDest), fFlags);

AssertPtrReturn(pTask, VERR_NO_MEMORY);

int rc = startTaskAsync(Utf8StrFmt(tr("Copying \"%ls\" from host to \"%ls\" on the guest"), aSource, aDest),

pTask, pProgress);

if (RT_SUCCESS(rc))

{

/* Return progress to the caller. */

hr = pProgress.queryInterfaceTo(aProgress);

}

/** @todo rc -> hr error lookup. */

return hr;

#endif /* VBOX_WITH_GUEST_CONTROL */

}

STDMETHODIMP GuestSession::DirectoryCreate(IN_BSTR aPath, ULONG aMode,

ComSafeArrayIn(DirectoryCreateFlag_T, aFlags), IGuestDirectory **aDirectory)

{

#ifndef VBOX_WITH_GUEST_CONTROL

ReturnComNotImplemented();

#else

LogFlowThisFuncEnter();

if (RT_UNLIKELY((aPath) == NULL || *(aPath) == '\0'))

return setError(E_INVALIDARG, tr("No directory to create specified"));

/* aDirectory is optional. */

AutoCaller autoCaller(this);

if (FAILED(autoCaller.rc())) return autoCaller.rc();

uint32_t fFlags = DirectoryCreateFlag_None;

if (aFlags)

{

com::SafeArray<DirectoryCreateFlag_T> flags(ComSafeArrayInArg(aFlags));

for (size_t i = 0; i < flags.size(); i++)

fFlags |= flags[i];

if (!(fFlags & DirectoryCreateFlag_Parents))

return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), fFlags);

}

HRESULT hr = S_OK;

ComObjPtr <GuestDirectory> pDirectory;

int rc = directoryCreateInternal(Utf8Str(aPath), (uint32_t)aMode, (uint32_t)aFlags, pDirectory);

if (RT_SUCCESS(rc))