GuestSessionImpl.cpp revision ca3db470494a8b6eaec69ea37468a5cda65e2da8
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync/* $Id$ */
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync/** @file
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync * VirtualBox Main - XXX.
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync */
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync/*
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync * Copyright (C) 2012 Oracle Corporation
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync *
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync * available from http://www.virtualbox.org. This file is free software;
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync * you can redistribute it and/or modify it under the terms of the GNU
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync * General Public License (GPL) as published by the Free Software
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync */
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync/*******************************************************************************
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync* Header Files *
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync*******************************************************************************/
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync#include "GuestImpl.h"
5f2b03bf7695dabd71222dba123532a3f76828c1vboxsync#include "GuestSessionImpl.h"
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync#include "GuestCtrlImplPrivate.h"
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync#include "Global.h"
9523921c89c66f4bececdbd5ac95aed0039eda1bvboxsync#include "AutoCaller.h"
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync#include "ProgressImpl.h"
c4b821bf03ae7641a0791e3fd161247e66433b68vboxsync
c4b821bf03ae7641a0791e3fd161247e66433b68vboxsync#include <memory> /* For auto_ptr. */
d4a9d525e6f2111d462d2d96462dced6b9ec00efvboxsync
d4a9d525e6f2111d462d2d96462dced6b9ec00efvboxsync#include <iprt/env.h>
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync#include <iprt/file.h> /* For CopyTo/From. */
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync#include <VBox/com/array.h>
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync#include <VBox/version.h>
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync#define VBOX_SERVICE_ENVARG_BUG
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync
6b9d50a0f466bd5a61458ed53925480ab28a3c17vboxsync// constructor / destructor
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync/////////////////////////////////////////////////////////////////////////////
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsyncDEFINE_EMPTY_CTOR_DTOR(GuestSession)
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsyncHRESULT GuestSession::FinalConstruct(void)
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync{
6b9d50a0f466bd5a61458ed53925480ab28a3c17vboxsync LogFlowThisFunc(("\n"));
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync return BaseFinalConstruct();
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync}
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsyncvoid GuestSession::FinalRelease(void)
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync{
6b9d50a0f466bd5a61458ed53925480ab28a3c17vboxsync LogFlowThisFuncEnter();
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync uninit();
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync BaseFinalRelease();
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync LogFlowThisFuncLeave();
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync}
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync// session task classes
6b9d50a0f466bd5a61458ed53925480ab28a3c17vboxsync/////////////////////////////////////////////////////////////////////////////
6b9d50a0f466bd5a61458ed53925480ab28a3c17vboxsync
6b9d50a0f466bd5a61458ed53925480ab28a3c17vboxsyncGuestSessionTask::GuestSessionTask(GuestSession *pSession)
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync{
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync mSession = pSession;
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync}
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsyncGuestSessionTask::~GuestSessionTask(void)
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync{
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync}
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsyncint GuestSessionTask::setProgress(ULONG uPercent)
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync{
6b9d50a0f466bd5a61458ed53925480ab28a3c17vboxsync if (mProgress.isNull()) /* Progress is optional. */
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync return VINF_SUCCESS;
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync BOOL fCanceled;
c740281e4f5e61397e892447aeef2a7bdbbaaf8dvboxsync if ( SUCCEEDED(mProgress->COMGETTER(Canceled(&fCanceled)))
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync && fCanceled)
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync return VERR_CANCELLED;
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync BOOL fCompleted;
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync if ( SUCCEEDED(mProgress->COMGETTER(Completed(&fCompleted)))
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync && !fCompleted)
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync return VINF_SUCCESS;
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync HRESULT hr = mProgress->SetCurrentOperationProgress(uPercent);
6b9d50a0f466bd5a61458ed53925480ab28a3c17vboxsync if (FAILED(hr))
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync return VERR_COM_UNEXPECTED;
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync return VINF_SUCCESS;
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync}
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsyncint GuestSessionTask::setProgressSuccess(void)
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync{
3d33b6a3faf40871bae75119c2569cdc4acb2d46vboxsync if (mProgress.isNull()) /* Progress is optional. */
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync return VINF_SUCCESS;
6b9d50a0f466bd5a61458ed53925480ab28a3c17vboxsync
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync BOOL fCanceled;
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync BOOL fCompleted;
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync if ( SUCCEEDED(mProgress->COMGETTER(Canceled(&fCanceled)))
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync && !fCanceled
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync && SUCCEEDED(mProgress->COMGETTER(Completed(&fCompleted)))
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync && !fCompleted)
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync {
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync HRESULT hr = mProgress->notifyComplete(S_OK);
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync if (FAILED(hr))
6b9d50a0f466bd5a61458ed53925480ab28a3c17vboxsync return VERR_COM_UNEXPECTED; /** @todo Find a better rc. */
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync }
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync return VINF_SUCCESS;
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync}
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsyncHRESULT GuestSessionTask::setProgressErrorMsg(HRESULT hr, const Utf8Str &strMsg)
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync{
6b9d50a0f466bd5a61458ed53925480ab28a3c17vboxsync if (mProgress.isNull()) /* Progress is optional. */
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync return hr; /* Return original rc. */
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync BOOL fCanceled;
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync BOOL fCompleted;
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync if ( SUCCEEDED(mProgress->COMGETTER(Canceled(&fCanceled)))
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync && !fCanceled
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync && SUCCEEDED(mProgress->COMGETTER(Completed(&fCompleted)))
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync && !fCompleted)
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync {
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync HRESULT hr2 = mProgress->notifyComplete(hr,
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync COM_IIDOF(IGuestSession),
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync GuestSession::getStaticComponentName(),
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync strMsg.c_str());
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync if (FAILED(hr2))
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync return hr2;
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync }
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync return hr; /* Return original rc. */
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync}
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsyncSessionTaskCopyTo::SessionTaskCopyTo(GuestSession *pSession,
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync const Utf8Str &strSource, const Utf8Str &strDest, uint32_t uFlags)
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync : mSource(strSource),
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync mDest(strDest),
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync mSourceFile(NULL),
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync mSourceOffset(0),
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync mSourceSize(0),
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync GuestSessionTask(pSession)
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync{
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync mCopyFileFlags = uFlags;
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync}
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync/** @todo Merge this and the above call and let the above call do the open/close file handling so that the
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync * inner code only has to deal with file handles. No time now ... */
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsyncSessionTaskCopyTo::SessionTaskCopyTo(GuestSession *pSession,
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync PRTFILE pSourceFile, size_t cbSourceOffset, uint64_t cbSourceSize,
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync const Utf8Str &strDest, uint32_t uFlags)
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync : GuestSessionTask(pSession)
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync{
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync mSourceFile = pSourceFile;
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync mSourceOffset = cbSourceOffset;
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync mSourceSize = cbSourceSize;
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync mDest = strDest;
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync mCopyFileFlags = uFlags;
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync}
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsyncSessionTaskCopyTo::~SessionTaskCopyTo(void)
7c3bf57b1f6df237b1075e7cae6b188db6fc636avboxsync{
7c3bf57b1f6df237b1075e7cae6b188db6fc636avboxsync
7c3bf57b1f6df237b1075e7cae6b188db6fc636avboxsync}
7c3bf57b1f6df237b1075e7cae6b188db6fc636avboxsync
7c3bf57b1f6df237b1075e7cae6b188db6fc636avboxsyncint SessionTaskCopyTo::Run(void)
7c3bf57b1f6df237b1075e7cae6b188db6fc636avboxsync{
7c3bf57b1f6df237b1075e7cae6b188db6fc636avboxsync LogFlowThisFuncEnter();
7c3bf57b1f6df237b1075e7cae6b188db6fc636avboxsync
7c3bf57b1f6df237b1075e7cae6b188db6fc636avboxsync ComObjPtr<GuestSession> pSession = mSession;
7c3bf57b1f6df237b1075e7cae6b188db6fc636avboxsync Assert(!pSession.isNull());
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync
7c3bf57b1f6df237b1075e7cae6b188db6fc636avboxsync AutoCaller autoCaller(pSession);
7c3bf57b1f6df237b1075e7cae6b188db6fc636avboxsync if (FAILED(autoCaller.rc())) return autoCaller.rc();
7c3bf57b1f6df237b1075e7cae6b188db6fc636avboxsync
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync if (mCopyFileFlags)
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync {
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync setProgressErrorMsg(VBOX_E_IPRT_ERROR,
3c6306a66deef467e3c13483dd6529e1e1c6b822vboxsync Utf8StrFmt(GuestSession::tr("Copy flags (%#x) not implemented yet"),
3c6306a66deef467e3c13483dd6529e1e1c6b822vboxsync mCopyFileFlags));
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync return VERR_INVALID_PARAMETER;
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync }
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync int rc;
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync RTFILE fileLocal;
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync PRTFILE pFile = &fileLocal;
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync if (!mSourceFile)
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync {
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync /* Does our source file exist? */
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync if (!RTFileExists(mSource.c_str()))
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync {
c4b821bf03ae7641a0791e3fd161247e66433b68vboxsync rc = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
c4b821bf03ae7641a0791e3fd161247e66433b68vboxsync Utf8StrFmt(GuestSession::tr("Source file \"%s\" does not exist or is not a file"),
c4b821bf03ae7641a0791e3fd161247e66433b68vboxsync mSource.c_str()));
3c6306a66deef467e3c13483dd6529e1e1c6b822vboxsync }
c4b821bf03ae7641a0791e3fd161247e66433b68vboxsync else
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync {
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync rc = RTFileOpen(pFile, mSource.c_str(),
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync if (RT_FAILURE(rc))
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync {
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync rc = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
cd059a6642b11828bd0ad8b3108f5f7f611d144fvboxsync Utf8StrFmt(GuestSession::tr("Could not open source file \"%s\" for reading: %Rrc"),
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync mSource.c_str(), rc));
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync }
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync else
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync {
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync rc = RTFileGetSize(*pFile, &mSourceSize);
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync if (RT_FAILURE(rc))
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync {
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync setProgressErrorMsg(VBOX_E_IPRT_ERROR,
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync Utf8StrFmt(GuestSession::tr("Could not query file size of \"%s\": %Rrc"),
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync mSource.c_str(), rc));
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync }
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync }
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync }
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync }
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync else
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync {
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync pFile = mSourceFile;
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync /* Size + offset are optional. */
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync }
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync
687794577e2e35c3cae67e692a7f2130d1262a82vboxsync GuestProcessStartupInfo procInfo;
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync procInfo.mName = Utf8StrFmt(GuestSession::tr("Copying file \"%s\" to the guest to \"%s\" (%RU64 bytes)"),
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync mSource.c_str(), mDest.c_str(), mSourceSize);
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_CAT);
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync procInfo.mFlags = ProcessCreateFlag_Hidden;
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync /* Set arguments.*/
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync procInfo.mArguments.push_back(Utf8StrFmt("--output=%s", mDest.c_str())); /** @todo Do we need path conversion? */
06ea6bcf23874b662d499b3f130024c98b2dd7a6vboxsync
06ea6bcf23874b662d499b3f130024c98b2dd7a6vboxsync /* Startup process. */
06ea6bcf23874b662d499b3f130024c98b2dd7a6vboxsync ComObjPtr<GuestProcess> pProcess;
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync rc = pSession->processCreateExInteral(procInfo, pProcess);
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync if (RT_SUCCESS(rc))
7e8ef90d3160234df0f254131b87af4243d79476vboxsync rc = pProcess->startProcess();
06ea6bcf23874b662d499b3f130024c98b2dd7a6vboxsync if (RT_FAILURE(rc))
1cd59fdf671ca60c64d77e3f7046aaecf7003824vboxsync {
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync setProgressErrorMsg(VBOX_E_IPRT_ERROR,
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync Utf8StrFmt(GuestSession::tr("Unable to start guest process: %Rrc"), rc));
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync }
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync else
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync {
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync GuestProcessWaitResult waitRes;
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync BYTE byBuf[_64K];
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync BOOL fCanceled = FALSE;
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync uint64_t cbWrittenTotal = 0;
4121d226ac899f17e13aff3aff42b603c8b5c1fevboxsync uint64_t cbToRead = mSourceSize;
ca3db470494a8b6eaec69ea37468a5cda65e2da8vboxsync
9523921c89c66f4bececdbd5ac95aed0039eda1bvboxsync for (;;)
8bc8d66f188d5357155b8340e2d489573be2b607vboxsync {
9523921c89c66f4bececdbd5ac95aed0039eda1bvboxsync rc = pProcess->waitFor(ProcessWaitForFlag_StdIn,
9523921c89c66f4bececdbd5ac95aed0039eda1bvboxsync 30 * 1000 /* Timeout */, waitRes);
06ea6bcf23874b662d499b3f130024c98b2dd7a6vboxsync if ( RT_FAILURE(rc)
06ea6bcf23874b662d499b3f130024c98b2dd7a6vboxsync || waitRes.mResult != ProcessWaitForFlag_StdIn)
9523921c89c66f4bececdbd5ac95aed0039eda1bvboxsync {
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync break;
702a8ee2dc1de96f2f77e97135015d3e243186fdvboxsync }
9523921c89c66f4bececdbd5ac95aed0039eda1bvboxsync
9523921c89c66f4bececdbd5ac95aed0039eda1bvboxsync size_t cbRead = 0;
92e624e40b06b4dc6d0a8222e1de33bd3e879a63vboxsync if (mSourceSize) /* If we have nothing to write, take a shortcut. */
9523921c89c66f4bececdbd5ac95aed0039eda1bvboxsync {
36f3c24e4ad9c6b813767db1faeabbe7e2ecc057vboxsync /** @todo Not very efficient, but works for now. */
9523921c89c66f4bececdbd5ac95aed0039eda1bvboxsync rc = RTFileSeek(*pFile, mSourceOffset + cbWrittenTotal,
9523921c89c66f4bececdbd5ac95aed0039eda1bvboxsync RTFILE_SEEK_BEGIN, NULL /* poffActual */);
9523921c89c66f4bececdbd5ac95aed0039eda1bvboxsync if (RT_SUCCESS(rc))
06ea6bcf23874b662d499b3f130024c98b2dd7a6vboxsync {
9523921c89c66f4bececdbd5ac95aed0039eda1bvboxsync rc = RTFileRead(*pFile, (uint8_t*)byBuf,
9523921c89c66f4bececdbd5ac95aed0039eda1bvboxsync RT_MIN(cbToRead, sizeof(byBuf)), &cbRead);
d4a9d525e6f2111d462d2d96462dced6b9ec00efvboxsync /*
9523921c89c66f4bececdbd5ac95aed0039eda1bvboxsync * Some other error occured? There might be a chance that RTFileRead
06ea6bcf23874b662d499b3f130024c98b2dd7a6vboxsync * could not resolve/map the native error code to an IPRT code, so just
06ea6bcf23874b662d499b3f130024c98b2dd7a6vboxsync * print a generic error.
d4a9d525e6f2111d462d2d96462dced6b9ec00efvboxsync */
d4a9d525e6f2111d462d2d96462dced6b9ec00efvboxsync if (RT_FAILURE(rc))
06ea6bcf23874b662d499b3f130024c98b2dd7a6vboxsync {
9523921c89c66f4bececdbd5ac95aed0039eda1bvboxsync setProgressErrorMsg(VBOX_E_IPRT_ERROR,
06ea6bcf23874b662d499b3f130024c98b2dd7a6vboxsync Utf8StrFmt(GuestSession::tr("Could not read from file \"%s\" (%Rrc)"),
9523921c89c66f4bececdbd5ac95aed0039eda1bvboxsync mSource.c_str(), rc));
9523921c89c66f4bececdbd5ac95aed0039eda1bvboxsync break;
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync }
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync }
7862f4bd000f1eb6c86289f5ac2849e9cf943ca9vboxsync else
7862f4bd000f1eb6c86289f5ac2849e9cf943ca9vboxsync {
7862f4bd000f1eb6c86289f5ac2849e9cf943ca9vboxsync setProgressErrorMsg(VBOX_E_IPRT_ERROR,
7862f4bd000f1eb6c86289f5ac2849e9cf943ca9vboxsync Utf8StrFmt(GuestSession::tr("Seeking file \"%s\" offset %RU64 failed: %Rrc"),
687794577e2e35c3cae67e692a7f2130d1262a82vboxsync mSource.c_str(), cbWrittenTotal, rc));
cc1ef2ef9bbc6a0ff964928d61b7298e5bfcce5fvboxsync break;
cc1ef2ef9bbc6a0ff964928d61b7298e5bfcce5fvboxsync }
7862f4bd000f1eb6c86289f5ac2849e9cf943ca9vboxsync }
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync uint32_t fFlags = ProcessInputFlag_None;
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync
04f6f18325971f796623469adcf39ba2b2939ed3vboxsync /* Did we reach the end of the content we want to transfer (last chunk)? */
4121d226ac899f17e13aff3aff42b603c8b5c1fevboxsync if ( (cbRead < sizeof(byBuf))
ca3db470494a8b6eaec69ea37468a5cda65e2da8vboxsync /* Did we reach the last block which is exactly _64K? */
ca3db470494a8b6eaec69ea37468a5cda65e2da8vboxsync || (cbToRead - cbRead == 0)
ca3db470494a8b6eaec69ea37468a5cda65e2da8vboxsync /* ... or does the user want to cancel? */
ca3db470494a8b6eaec69ea37468a5cda65e2da8vboxsync || ( SUCCEEDED(mProgress->COMGETTER(Canceled(&fCanceled)))
ca3db470494a8b6eaec69ea37468a5cda65e2da8vboxsync && fCanceled)
8bc8d66f188d5357155b8340e2d489573be2b607vboxsync )
4121d226ac899f17e13aff3aff42b603c8b5c1fevboxsync {
687794577e2e35c3cae67e692a7f2130d1262a82vboxsync fFlags |= ProcessInputFlag_EndOfFile;
04f6f18325971f796623469adcf39ba2b2939ed3vboxsync }
004d74842597dacc4009803171296dfcf9398c69vboxsync
5366e994777f9d9391cf809dc77610f57270d75dvboxsync uint32_t cbWritten;
5366e994777f9d9391cf809dc77610f57270d75dvboxsync Assert(sizeof(byBuf) >= cbRead);
e378dfdadd62aadc0a012c9953322d979d7606e6vboxsync rc = pProcess->writeData(0 /* StdIn */, fFlags,
e378dfdadd62aadc0a012c9953322d979d7606e6vboxsync byBuf, cbRead,
4121d226ac899f17e13aff3aff42b603c8b5c1fevboxsync 30 * 1000 /* Timeout */, &cbWritten);
5f2b03bf7695dabd71222dba123532a3f76828c1vboxsync if (RT_FAILURE(rc))
7862f4bd000f1eb6c86289f5ac2849e9cf943ca9vboxsync {
40c1a23e86c79b24a917a43c186b2e54504d12c1vboxsync setProgressErrorMsg(VBOX_E_IPRT_ERROR,
04f6f18325971f796623469adcf39ba2b2939ed3vboxsync Utf8StrFmt(GuestSession::tr("Writing to file \"%s\" (offset %RU64) failed: %Rrc"),
88cc9bf61296bc5526344415167bb2625ae1dd99vboxsync mDest.c_str(), cbWrittenTotal, rc));
f9ce005e61f0fbb51a2cabc53d58c3485151faa9vboxsync break;
04f6f18325971f796623469adcf39ba2b2939ed3vboxsync }
5366e994777f9d9391cf809dc77610f57270d75dvboxsync
24ef2ade0f53030e73f5b4e43f52892b03f7915dvboxsync LogFlowThisFunc(("cbWritten=%RU32, cbToRead=%RU64, cbWrittenTotal=%RU64, cbFileSize=%RU64\n",
687794577e2e35c3cae67e692a7f2130d1262a82vboxsync cbWritten, cbToRead - cbWritten, cbWrittenTotal + cbWritten, mSourceSize));
0fd108a555ae02f2fb557d5f2c40281999b60d15vboxsync
f9ce005e61f0fbb51a2cabc53d58c3485151faa9vboxsync /* Only subtract bytes reported written by the guest. */
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync Assert(cbToRead >= cbWritten);
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync cbToRead -= cbWritten;
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync /* Update total bytes written to the guest. */
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync cbWrittenTotal += cbWritten;
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync Assert(cbWrittenTotal <= mSourceSize);
02f7c106d33c45f99ec412a5fe0adde868f700fcvboxsync
02f7c106d33c45f99ec412a5fe0adde868f700fcvboxsync /* Did the user cancel the operation above? */
02f7c106d33c45f99ec412a5fe0adde868f700fcvboxsync if (fCanceled)
f9ce005e61f0fbb51a2cabc53d58c3485151faa9vboxsync break;
d4a9d525e6f2111d462d2d96462dced6b9ec00efvboxsync
d4a9d525e6f2111d462d2d96462dced6b9ec00efvboxsync /* Update the progress.
d4a9d525e6f2111d462d2d96462dced6b9ec00efvboxsync * Watch out for division by zero. */
5f2b03bf7695dabd71222dba123532a3f76828c1vboxsync mSourceSize > 0
d4a9d525e6f2111d462d2d96462dced6b9ec00efvboxsync ? rc = setProgress((ULONG)(cbWrittenTotal * 100 / mSourceSize))
d4a9d525e6f2111d462d2d96462dced6b9ec00efvboxsync : rc = setProgress(100);
5f2b03bf7695dabd71222dba123532a3f76828c1vboxsync if (RT_FAILURE(rc))
d4a9d525e6f2111d462d2d96462dced6b9ec00efvboxsync break;
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync
d4a9d525e6f2111d462d2d96462dced6b9ec00efvboxsync /* End of file reached? */
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync if (!cbToRead)
d4a9d525e6f2111d462d2d96462dced6b9ec00efvboxsync break;
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync } /* for */
02f7c106d33c45f99ec412a5fe0adde868f700fcvboxsync
02f7c106d33c45f99ec412a5fe0adde868f700fcvboxsync if ( !fCanceled
7862f4bd000f1eb6c86289f5ac2849e9cf943ca9vboxsync || RT_SUCCESS(rc))
02f7c106d33c45f99ec412a5fe0adde868f700fcvboxsync {
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync /*
02f7c106d33c45f99ec412a5fe0adde868f700fcvboxsync * Even if we succeeded until here make sure to check whether we really transfered
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync * everything.
02f7c106d33c45f99ec412a5fe0adde868f700fcvboxsync */
d4a9d525e6f2111d462d2d96462dced6b9ec00efvboxsync if ( mSourceSize > 0
04f6f18325971f796623469adcf39ba2b2939ed3vboxsync && cbWrittenTotal == 0)
04f6f18325971f796623469adcf39ba2b2939ed3vboxsync {
04f6f18325971f796623469adcf39ba2b2939ed3vboxsync /* If nothing was transfered but the file size was > 0 then "vbox_cat" wasn't able to write
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync * to the destination -> access denied. */
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync rc = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync Utf8StrFmt(GuestSession::tr("Access denied when copying file \"%s\" to \"%s\""),
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync mSource.c_str(), mDest.c_str()));
2f3883b126a405f92b19e829472f614c7352b4f9vboxsync }
else if (cbWrittenTotal < mSourceSize)
{
/* 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, mSourceSize));
}
else
{
rc = pProcess->waitFor(ProcessWaitForFlag_Terminate,
30 * 1000 /* Timeout */, waitRes);
if ( RT_FAILURE(rc)
|| waitRes.mResult != ProcessWaitResult_Terminate)
{
if (RT_FAILURE(rc))
rc = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
Utf8StrFmt(GuestSession::tr("Waiting on termination for copying file \"%s\" failed: %Rrc"),
mSource.c_str(), rc));
else
rc = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
Utf8StrFmt(GuestSession::tr("Waiting on termination for copying file \"%s\" failed with wait result %ld"),
mSource.c_str(), waitRes.mResult));
}
if (RT_SUCCESS(rc))
{
ProcessStatus_T procStatus;
LONG exitCode;
if ( ( SUCCEEDED(pProcess->COMGETTER(Status(&procStatus)))
&& procStatus != ProcessStatus_TerminatedNormally)
|| ( SUCCEEDED(pProcess->COMGETTER(ExitCode(&exitCode)))
&& exitCode != 0)
)
{
rc = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
Utf8StrFmt(GuestSession::tr("Copying file \"%s\" failed with status %ld, exit code %ld"),
mSource.c_str(), procStatus, exitCode)); /**@todo Add stringify methods! */
}
}
if (RT_SUCCESS(rc))
rc = setProgressSuccess();
}
}
pProcess->close();
} /* processCreateExInteral */
if (!mSourceFile) /* Only close locally opened files. */
RTFileClose(*pFile);
LogFlowFuncLeaveRC(rc);
return rc;
}
int SessionTaskCopyTo::RunAsync(const Utf8Str &strDesc, ComObjPtr<Progress> &pProgress)
{
LogFlowThisFunc(("strDesc=%s, strSource=%s, strDest=%s, mCopyFileFlags=%x\n",
strDesc.c_str(), mSource.c_str(), mDest.c_str(), mCopyFileFlags));
mDesc = strDesc;
mProgress = pProgress;
int rc = RTThreadCreate(NULL, SessionTaskCopyTo::taskThread, this,
0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
"gctlCpyTo");
LogFlowFuncLeaveRC(rc);
return rc;
}
/* static */
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,
const Utf8Str &strSource, const Utf8Str &strDest, uint32_t uFlags)
: GuestSessionTask(pSession)
{
mSource = strSource;
mDest = strDest;
mFlags = uFlags;
}
SessionTaskCopyFrom::~SessionTaskCopyFrom(void)
{
}
int SessionTaskCopyFrom::Run(void)
{
LogFlowThisFuncEnter();
ComObjPtr<GuestSession> pSession = mSession;
Assert(!pSession.isNull());
AutoCaller autoCaller(pSession);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
/*
* Note: There will be races between querying file size + reading the guest file's
* content because we currently *do not* lock down the guest file when doing the
* actual operations.
** @todo Implement guest file locking!
*/
GuestFsObjData objData;
int rc = pSession->fileQueryInfoInternal(Utf8Str(mSource), objData);
if (RT_FAILURE(rc))
{
setProgressErrorMsg(VBOX_E_IPRT_ERROR,
Utf8StrFmt(GuestSession::tr("Querying guest file information for \"%s\" failed: %Rrc"),
mSource.c_str(), rc));
}
else if (objData.mType != FsObjType_File) /* Only single files are supported at the moment. */
{
rc = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
Utf8StrFmt(GuestSession::tr("Object \"%s\" on the guest is not a file"), mSource.c_str()));
}
if (RT_SUCCESS(rc))
{
RTFILE fileDest;
rc = RTFileOpen(&fileDest, mDest.c_str(),
RTFILE_O_WRITE | RTFILE_O_OPEN_CREATE | RTFILE_O_DENY_WRITE); /** @todo Use the correct open modes! */
if (RT_FAILURE(rc))
{
setProgressErrorMsg(VBOX_E_IPRT_ERROR,
Utf8StrFmt(GuestSession::tr("Error opening destination file \"%s\": %Rrc"),
mDest.c_str(), rc));
}
else
{
GuestProcessStartupInfo procInfo;
procInfo.mName = Utf8StrFmt(GuestSession::tr("Copying file \"%s\" from guest to the host to \"%s\" (%RI64 bytes)"),
mSource.c_str(), mDest.c_str(), objData.mObjectSize);
procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_CAT);
procInfo.mFlags = ProcessCreateFlag_Hidden | ProcessCreateFlag_WaitForStdOut;
/* Set arguments.*/
procInfo.mArguments.push_back(mSource); /* Which file to output? */
/* Startup process. */
ComObjPtr<GuestProcess> pProcess;
rc = pSession->processCreateExInteral(procInfo, pProcess);
if (RT_SUCCESS(rc))
rc = pProcess->startProcess();
if (RT_FAILURE(rc))
{
setProgressErrorMsg(VBOX_E_IPRT_ERROR,
Utf8StrFmt(GuestSession::tr("Unable to start guest process for copying data from guest to host: %Rrc"), rc));
}
else
{
GuestProcessWaitResult waitRes;
BYTE byBuf[_64K];
BOOL fCanceled = FALSE;
uint64_t cbWrittenTotal = 0;
uint64_t cbToRead = objData.mObjectSize;
for (;;)
{
rc = pProcess->waitFor(ProcessWaitForFlag_StdOut,
30 * 1000 /* Timeout */, waitRes);
if ( waitRes.mResult == ProcessWaitResult_StdOut
|| waitRes.mResult == ProcessWaitResult_Any)
{
size_t cbRead;
rc = pProcess->readData(OUTPUT_HANDLE_ID_STDOUT, sizeof(byBuf),
30 * 1000 /* Timeout */, byBuf, sizeof(byBuf),
&cbRead);
if (RT_FAILURE(rc))
{
setProgressErrorMsg(VBOX_E_IPRT_ERROR,
Utf8StrFmt(GuestSession::tr("Reading from file \"%s\" (offset %RU64) failed: %Rrc"),
mSource.c_str(), cbWrittenTotal, rc));
break;
}
if (cbRead)
{
rc = RTFileWrite(fileDest, byBuf, cbRead, NULL /* No partial writes */);
if (RT_FAILURE(rc))
{
setProgressErrorMsg(VBOX_E_IPRT_ERROR,
Utf8StrFmt(GuestSession::tr("Error writing to file \"%s\" (%RU64 bytes left): %Rrc"),
mDest.c_str(), cbToRead, rc));
break;
}
/* Only subtract bytes reported written by the guest. */
Assert(cbToRead >= cbRead);
cbToRead -= cbRead;
/* Update total bytes written to the guest. */
cbWrittenTotal += cbRead;
Assert(cbWrittenTotal <= (uint64_t)objData.mObjectSize);
/* Did the user cancel the operation above? */
if ( SUCCEEDED(mProgress->COMGETTER(Canceled(&fCanceled)))
&& fCanceled)
break;
rc = setProgress((ULONG)(cbWrittenTotal / ((uint64_t)objData.mObjectSize / 100.0)));
if (RT_FAILURE(rc))
break;
}
}
else if ( RT_FAILURE(rc)
|| waitRes.mResult == ProcessWaitResult_Terminate
|| waitRes.mResult == ProcessWaitResult_Error
|| waitRes.mResult == ProcessWaitResult_Timeout)
{
if (RT_FAILURE(waitRes.mRC))
rc = waitRes.mRC;
break;
}
} /* for */
LogFlowThisFunc(("rc=%Rrc, cbWrittenTotal=%RU64, cbSize=%RI64, cbToRead=%RU64\n",
rc, cbWrittenTotal, objData.mObjectSize, cbToRead));
if ( !fCanceled
|| RT_SUCCESS(rc))
{
/*
* Even if we succeeded until here make sure to check whether we really transfered
* everything.
*/
if ( objData.mObjectSize > 0
&& cbWrittenTotal == 0)
{
/* If nothing was transfered but the file size was > 0 then "vbox_cat" wasn't able to write
* to the destination -> access denied. */
setProgressErrorMsg(VBOX_E_IPRT_ERROR,
Utf8StrFmt(GuestSession::tr("Access denied when copying file \"%s\" to \"%s\""),
mSource.c_str(), mDest.c_str()));
rc = VERR_GENERAL_FAILURE; /* Fudge. */
}
else if (cbWrittenTotal < (uint64_t)objData.mObjectSize)
{
/* If we did not copy all let the user know. */
setProgressErrorMsg(VBOX_E_IPRT_ERROR,
Utf8StrFmt(GuestSession::tr("Copying file \"%s\" failed (%RU64/%RI64 bytes transfered)"),
mSource.c_str(), cbWrittenTotal, objData.mObjectSize));
rc = VERR_GENERAL_FAILURE; /* Fudge. */
}
else
{
ProcessStatus_T procStatus;
LONG exitCode;
if ( ( SUCCEEDED(pProcess->COMGETTER(Status(&procStatus)))
&& procStatus != ProcessStatus_TerminatedNormally)
|| ( SUCCEEDED(pProcess->COMGETTER(ExitCode(&exitCode)))
&& exitCode != 0)
)
{
setProgressErrorMsg(VBOX_E_IPRT_ERROR,
Utf8StrFmt(GuestSession::tr("Copying file \"%s\" failed with status %ld, exit code %d"),
mSource.c_str(), procStatus, exitCode)); /**@todo Add stringify methods! */
rc = VERR_GENERAL_FAILURE; /* Fudge. */
}
else /* Yay, success! */
rc = setProgressSuccess();
}
}
pProcess->close();
}
RTFileClose(fileDest);
}
}
LogFlowFuncLeaveRC(rc);
return rc;
}
int SessionTaskCopyFrom::RunAsync(const Utf8Str &strDesc, ComObjPtr<Progress> &pProgress)
{
LogFlowThisFunc(("strDesc=%s, strSource=%s, strDest=%s, uFlags=%x\n",
strDesc.c_str(), mSource.c_str(), mDest.c_str(), mFlags));
mDesc = strDesc;
mProgress = pProgress;
int rc = RTThreadCreate(NULL, SessionTaskCopyFrom::taskThread, this,
0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
"gctlCpyFrom");
LogFlowFuncLeaveRC(rc);
return rc;
}
/* static */
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();
}
SessionTaskUpdateAdditions::SessionTaskUpdateAdditions(GuestSession *pSession,
const Utf8Str &strSource, uint32_t uFlags)
: GuestSessionTask(pSession)
{
mSource = strSource;
mFlags = uFlags;
}
SessionTaskUpdateAdditions::~SessionTaskUpdateAdditions(void)
{
}
int SessionTaskUpdateAdditions::copyFileToGuest(GuestSession *pSession, PRTISOFSFILE pISO,
Utf8Str const &strFileSource, const Utf8Str &strFileDest,
bool fOptional, uint32_t *pcbSize)
{
AssertPtrReturn(pSession, VERR_INVALID_POINTER);
AssertPtrReturn(pISO, VERR_INVALID_POINTER);
/* pcbSize is optional. */
uint32_t cbOffset;
size_t cbSize;
int rc = RTIsoFsGetFileInfo(pISO, strFileSource.c_str(), &cbOffset, &cbSize);
if (RT_FAILURE(rc))
{
if (fOptional)
return VINF_SUCCESS;
return rc;
}
Assert(cbOffset);
Assert(cbSize);
rc = RTFileSeek(pISO->file, cbOffset, RTFILE_SEEK_BEGIN, NULL);
/* Copy over the Guest Additions file to the guest. */
if (RT_SUCCESS(rc))
{
LogRel(("Copying Guest Additions installer file \"%s\" to \"%s\" on guest ...\n",
strFileSource.c_str(), strFileDest.c_str()));
if (RT_SUCCESS(rc))
{
SessionTaskCopyTo *pTask = new SessionTaskCopyTo(pSession /* GuestSession */,
&pISO->file, cbOffset, cbSize,
strFileDest, CopyFileFlag_None);
AssertPtrReturn(pTask, VERR_NO_MEMORY);
ComObjPtr<Progress> pProgressCopyTo;
rc = pSession->startTaskAsync(Utf8StrFmt(GuestSession::tr("Copying Guest Additions installer file \"%s\" to \"%s\" on guest"),
mSource.c_str(), strFileDest.c_str()),
pTask, pProgressCopyTo);
if (RT_SUCCESS(rc))
{
BOOL fCanceled = FALSE;
HRESULT hr = pProgressCopyTo->WaitForCompletion(-1);
if ( SUCCEEDED(pProgressCopyTo->COMGETTER(Canceled)(&fCanceled))
&& fCanceled)
{
rc = VERR_GENERAL_FAILURE; /* Fudge. */
}
else if (FAILED(hr))
{
Assert(FAILED(hr));
rc = VERR_GENERAL_FAILURE; /* Fudge. */
}
}
}
}
/** @todo Note: Since there is no file locking involved at the moment, there can be modifications
* between finished copying, the verification and the actual execution. */
/* Determine where the installer image ended up and if it has the correct size. */
if (RT_SUCCESS(rc))
{
LogRel(("Verifying Guest Additions installer file \"%s\" ...\n", strFileDest.c_str()));
GuestFsObjData objData;
int64_t cbSizeOnGuest;
rc = pSession->fileQuerySizeInternal(strFileDest, &cbSizeOnGuest);
#ifdef VBOX_SERVICE_ENVARG_BUG
if (RT_FAILURE(rc))
{
/* Ugly hack: Because older Guest Additions have problems with environment variable
expansion in parameters we have to check an alternative location on Windows.
So check for "%TEMP%\" being "C:\\Windows\\system32\\EMP" actually. */
if (strFileDest.startsWith("%TEMP%\\", RTCString::CaseSensitive))
{
Utf8Str strFileDestBug = "C:\\Windows\\system32\\EMP" + strFileDest.substr(sizeof("%TEMP%\\") - sizeof(char));
rc = pSession->fileQuerySizeInternal(strFileDestBug, &cbSizeOnGuest);
}
}
#endif
if ( RT_SUCCESS(rc)
&& cbSize == (uint64_t)cbSizeOnGuest)
{
LogRel(("Guest Additions installer file \"%s\" successfully verified\n",
strFileDest.c_str()));
}
else
{
if (RT_SUCCESS(rc)) /* Size does not match. */
rc = VERR_BROKEN_PIPE; /** @todo FInd a better error. */
}
if (RT_SUCCESS(rc))
{
if (pcbSize)
*pcbSize = cbSizeOnGuest;
}
}
return rc;
}
int SessionTaskUpdateAdditions::runFile(GuestSession *pSession, GuestProcessStartupInfo &procInfo)
{
AssertPtrReturn(pSession, VERR_INVALID_POINTER);
#ifdef VBOX_SERVICE_ENVARG_BUG
GuestFsObjData objData;
int rc = pSession->fileQueryInfoInternal(procInfo.mCommand, objData);
if (RT_FAILURE(rc))
procInfo.mCommand = "C:\\Windows\\system32\\EMP" + procInfo.mCommand.substr(sizeof("%TEMP%\\") - sizeof(char));
#endif
ComObjPtr<GuestProcess> pProcess;
rc = pSession->processCreateExInteral(procInfo, pProcess);
if (RT_SUCCESS(rc))
rc = pProcess->startProcess();
if (RT_SUCCESS(rc))
{
LogRel(("Running %s ...\n", procInfo.mName.c_str()));
GuestProcessWaitResult waitRes;
rc = pProcess->waitFor(ProcessWaitForFlag_Terminate,
10 * 60 * 1000 /* 10 mins Timeout */, waitRes);
if (waitRes.mResult == ProcessWaitResult_Terminate)
{
ProcessStatus_T procStatus;
LONG exitCode;
if ( ( SUCCEEDED(pProcess->COMGETTER(Status(&procStatus)))
&& procStatus != ProcessStatus_TerminatedNormally)
|| ( SUCCEEDED(pProcess->COMGETTER(ExitCode(&exitCode)))
&& exitCode != 0)
)
{
setProgressErrorMsg(VBOX_E_IPRT_ERROR,
Utf8StrFmt(GuestSession::tr("Running %s failed with status %ld, exit code %ld"),
procInfo.mName.c_str(), procStatus, exitCode));
rc = VERR_GENERAL_FAILURE; /* Fudge. */
}
else /* Yay, success! */
{
LogRel(("%s successfully completed\n", procInfo.mName.c_str()));
}
}
else
{
if (RT_FAILURE(rc))
setProgressErrorMsg(VBOX_E_IPRT_ERROR,
Utf8StrFmt(GuestSession::tr("Error while waiting running %s: %Rrc"),
procInfo.mName.c_str(), rc));
else
{
setProgressErrorMsg(VBOX_E_IPRT_ERROR, pProcess->errorMsg());
rc = VERR_GENERAL_FAILURE; /* Fudge. */
}
}
}
if (!pProcess.isNull())
pProcess->close();
return rc;
}
int SessionTaskUpdateAdditions::Run(void)
{
LogFlowThisFuncEnter();
ComObjPtr<GuestSession> pSession = mSession;
Assert(!pSession.isNull());
AutoCaller autoCaller(pSession);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
int rc = setProgress(10);
if (RT_FAILURE(rc))
return rc;
HRESULT hr = S_OK;
LogRel(("Automatic update of Guest Additions started, using \"%s\"\n", mSource.c_str()));
/*
* Determine guest OS type and the required installer image.
* At the moment only Windows guests are supported.
*/
Utf8Str strInstallerImage;
ComObjPtr<Guest> pGuest(mSession->getParent());
Bstr osTypeId;
if ( SUCCEEDED(pGuest->COMGETTER(OSTypeId(osTypeId.asOutParam())))
&& !osTypeId.isEmpty())
{
Utf8Str osTypeIdUtf8(osTypeId); /* Needed for .contains(). */
if ( osTypeIdUtf8.contains("Microsoft", Utf8Str::CaseInsensitive)
|| osTypeIdUtf8.contains("Windows", Utf8Str::CaseInsensitive))
{
if (osTypeIdUtf8.contains("64", Utf8Str::CaseInsensitive))
strInstallerImage = "VBOXWINDOWSADDITIONS_AMD64.EXE";
else
strInstallerImage = "VBOXWINDOWSADDITIONS_X86.EXE";
/* Since the installers are located in the root directory,
* no further path processing needs to be done (yet). */
}
else /* Everything else is not supported (yet). */
{
hr = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
Utf8StrFmt(GuestSession::tr("Detected guest OS (%s) does not support automatic Guest Additions updating, please update manually"),
osTypeIdUtf8.c_str()));
rc = VERR_GENERAL_FAILURE; /* Fudge. */
}
}
else
{
hr = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
Utf8StrFmt(GuestSession::tr("Could not detected guest OS type/version, please update manually")));
rc = VERR_GENERAL_FAILURE; /* Fudge. */
}
RTISOFSFILE iso;
if (RT_SUCCESS(rc))
{
Assert(!strInstallerImage.isEmpty());
/*
* Try to open the .ISO file and locate the specified installer.
*/
rc = RTIsoFsOpen(&iso, mSource.c_str());
if (RT_FAILURE(rc))
{
hr = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
Utf8StrFmt(GuestSession::tr("Unable to open Guest Additions .ISO file \"%s\": %Rrc"),
mSource.c_str(), rc));
}
else
{
rc = setProgress(5);
/** @todo Add support for non-Windows as well! */
Utf8Str strInstallerDest = "%TEMP%\\VBoxWindowsAdditions.exe";
bool fInstallCertificates = false;
if (RT_SUCCESS(rc))
{
/*
* Copy over main installer to the guest.
*/
rc = copyFileToGuest(pSession, &iso, strInstallerImage, strInstallerDest,
false /* File is not optional */, NULL /* cbSize */);
if (RT_SUCCESS(rc))
rc = setProgress(20);
/*
* Install needed certificates for the WHQL crap.
** @todo Only for Windows!
*/
if (RT_SUCCESS(rc))
{
rc = copyFileToGuest(pSession, &iso, "CERT/ORACLE_VBOX.CER", "%TEMP%\\oracle-vbox.cer",
true /* File is optional */, NULL /* cbSize */);
if (RT_SUCCESS(rc))
{
rc = setProgress(30);
if (RT_SUCCESS(rc))
{
rc = copyFileToGuest(pSession, &iso, "CERT/VBOXCERTUTIL.EXE", "%TEMP%\\VBoxCertUtil.exe",
true /* File is optional */, NULL /* cbSize */);
if (RT_SUCCESS(rc))
{
fInstallCertificates = true;
rc = setProgress(40);
}
else
hr = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
Utf8StrFmt(GuestSession::tr("Error while copying certificate installation tool to the guest: %Rrc"), rc));
}
}
else
hr = setProgressErrorMsg(VBOX_E_IPRT_ERROR,
Utf8StrFmt(GuestSession::tr("Error while copying certificate to the guest: %Rrc"), rc));
}
}
/*
* Run VBoxCertUtil.exe to install the Oracle certificate.
*/
if ( RT_SUCCESS(rc)
&& fInstallCertificates)
{
LogRel(("Installing certificates on the guest ...\n"));
GuestProcessStartupInfo procInfo;
procInfo.mName = Utf8StrFmt(GuestSession::tr("VirtualBox Guest Additions Certificate Utility"));
procInfo.mCommand = Utf8Str("%TEMP%\\VBoxCertUtil.exe");
procInfo.mFlags = ProcessCreateFlag_Hidden;
/* Construct arguments. */
/** @todo Remove hardcoded paths. */
procInfo.mArguments.push_back(Utf8Str("add-trusted-publisher"));
/* Ugly hack: Because older Guest Additions have problems with environment variable
expansion in parameters we have to check an alternative location on Windows.
So check for "%TEMP%\VBoxWindowsAdditions.exe" in a screwed up way. */
#ifdef VBOX_SERVICE_ENVARG_BUG
GuestFsObjData objData;
rc = pSession->fileQueryInfoInternal("%TEMP%\\oracle-vbox.cer", objData);
if (RT_SUCCESS(rc))
#endif
procInfo.mArguments.push_back(Utf8Str("%TEMP%\\oracle-vbox.cer"));
#ifdef VBOX_SERVICE_ENVARG_BUG
else
procInfo.mArguments.push_back(Utf8Str("C:\\Windows\\system32\\EMPoracle-vbox.cer"));
#endif
/* Overwrite rc in any case. */
rc = runFile(pSession, procInfo);
}
if (RT_SUCCESS(rc))
rc = setProgress(60);
if (RT_SUCCESS(rc))
{
LogRel(("Updating Guest Additions ...\n"));
GuestProcessStartupInfo procInfo;
procInfo.mName = Utf8StrFmt(GuestSession::tr("VirtualBox Guest Additions Setup"));
procInfo.mCommand = Utf8Str(strInstallerDest);
procInfo.mFlags = ProcessCreateFlag_Hidden;
/* If the caller does not want to wait for out guest update process to end,
* complete the progress object now so that the caller can do other work. */
if (mFlags & AdditionsUpdateFlag_WaitForUpdateStartOnly)
procInfo.mFlags |= ProcessCreateFlag_WaitForProcessStartOnly;
/* Construct arguments. */
procInfo.mArguments.push_back(Utf8Str("/S")); /* We want to install in silent mode. */
procInfo.mArguments.push_back(Utf8Str("/l")); /* ... and logging enabled. */
/* Don't quit VBoxService during upgrade because it still is used for this
* piece of code we're in right now (that is, here!) ... */
procInfo.mArguments.push_back(Utf8Str("/no_vboxservice_exit"));
/* Tell the installer to report its current installation status
* using a running VBoxTray instance via balloon messages in the
* Windows taskbar. */
procInfo.mArguments.push_back(Utf8Str("/post_installstatus"));
rc = runFile(pSession, procInfo);
if (RT_SUCCESS(rc))
hr = setProgressSuccess();
}
RTIsoFsClose(&iso);
}
}
LogFlowFuncLeaveRC(rc);
return rc;
}
int SessionTaskUpdateAdditions::RunAsync(const Utf8Str &strDesc, ComObjPtr<Progress> &pProgress)
{
LogFlowThisFunc(("strDesc=%s, strSource=%s, uFlags=%x\n",
strDesc.c_str(), mSource.c_str(), mFlags));
mDesc = strDesc;
mProgress = pProgress;
int rc = RTThreadCreate(NULL, SessionTaskUpdateAdditions::taskThread, this,
0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
"gctlUpGA");
LogFlowFuncLeaveRC(rc);
return rc;
}
/* static */
int SessionTaskUpdateAdditions::taskThread(RTTHREAD Thread, void *pvUser)
{
std::auto_ptr<SessionTaskUpdateAdditions> task(static_cast<SessionTaskUpdateAdditions*>(pvUser));
AssertReturn(task.get(), VERR_GENERAL_FAILURE);
LogFlowFunc(("pTask=%p\n", task.get()));
return task->Run();
}
// public initializer/uninitializer for internal purposes only
/////////////////////////////////////////////////////////////////////////////
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;
/* Confirm a successful initialization when it's the case. */
autoInitSpan.setSucceeded();
LogFlowFuncLeaveRC(VINF_SUCCESS);
return VINF_SUCCESS;
}
/**
* Uninitializes the instance.
* Called from FinalRelease().
*/
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
}
// implementation of public getters/setters for attributes
/////////////////////////////////////////////////////////////////////////////
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 */
}
// private methods
/////////////////////////////////////////////////////////////////////////////
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));
GuestProcessStartupInfo procInfo;
procInfo.mName = Utf8StrFmt(tr("Creating directory \"%s\"", strPath.c_str()));
procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_MKDIR);
procInfo.mFlags = ProcessCreateFlag_Hidden;
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))
rc = pProcess->startProcess();
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;
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
/* Create the directory object. */
HRESULT hr = pDirectory.createObject();
if (FAILED(hr))
return VERR_COM_UNEXPECTED;
/* Note: There will be a race between creating and getting/initing the directory
object here. */
rc = pDirectory->init(this /* Parent */, strPath);
if (RT_FAILURE(rc))
return rc;
/* Add the created directory to our vector. */
mData.mDirectories.push_back(pDirectory);
LogFlowFunc(("Added new directory \"%s\" (Session: %RU32)\n",
strPath.c_str(), mData.mId));
LogFlowFuncLeaveRC(rc);
return rc;
}
int GuestSession::objectCreateTempInternal(Utf8Str strTemplate,
Utf8Str strPath,
bool fDirectory,
Utf8Str &strName, int *prc)
{
GuestProcessStartupInfo procInfo;
GuestProcessStream streamOut;
ComObjPtr<GuestProcess> pProcess;
int rc = VINF_SUCCESS;
if (fDirectory)
procInfo.mName = Utf8StrFmt(tr("Creating temporary directory from template \"%s\"",
strTemplate.c_str()));
else
procInfo.mName = Utf8StrFmt(tr("Creating temporary file from template \"%s\"",
strTemplate.c_str()));
procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_MKTEMP);
procInfo.mFlags = ProcessCreateFlag_Hidden
| ProcessCreateFlag_WaitForStdOut;
/* Construct arguments. */
procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
if (fDirectory)
procInfo.mArguments.push_back(Utf8Str("-d"));
if (strPath.length()) /* Otherwise use /tmp or equivalent. */
{
procInfo.mArguments.push_back(Utf8Str("-t"));
procInfo.mArguments.push_back(strPath);
}
procInfo.mArguments.push_back(strTemplate);
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_Terminate
|| waitRes.mResult == ProcessWaitResult_Error
|| waitRes.mResult == ProcessWaitResult_Timeout)
{
break;
}
rc = pProcess->readData(OUTPUT_HANDLE_ID_STDOUT, sizeof(byBuf),
30 * 1000 /* Timeout */, byBuf, sizeof(byBuf),
&cbRead);
if (RT_FAILURE(rc))
break;
if (cbRead)
{
rc = streamOut.AddData(byBuf, cbRead);
if (RT_FAILURE(rc))
break;
}
}
LogFlowThisFunc(("rc=%Rrc, cbRead=%RU32, cbStreamOut=%RU32\n",
rc, cbRead, streamOut.GetSize()));
}
else
LogThisFunc(("Error while starting temporary object creation tool on guest: %Rrc\n", rc));
if (RT_FAILURE(rc))
LogThisFunc(("Error while running temporary object creation tool: %Rrc\n", rc));
else if (!streamOut.GetSize())
{
LogThisFunc(("No return code after creating temporary object\n"));
rc = VERR_NO_DATA;
}
if (RT_SUCCESS(rc))
{
const char *pcszName;
int64_t i64rc;
GuestProcessStreamBlock streamBlock;
rc = streamOut.ParseBlock(streamBlock);
if (RT_SUCCESS(rc))
{
pcszName = streamBlock.GetString("name");
if (pcszName)
strName = pcszName;
else
{
LogThisFunc(("No name returned after creating temporary object\n"));
rc = VERR_NO_DATA;
}
if (RT_FAILURE(rc = streamBlock.GetInt64Ex("rc", &i64rc)))
LogThisFunc(("No return code after creating temporary object\n"));
}
if ( RT_SUCCESS(rc)
&& ( i64rc == VERR_INVALID_PARAMETER
|| i64rc == VERR_NOT_SUPPORTED))
rc = (int)i64rc;
if (RT_SUCCESS(rc))
*prc = (int)i64rc;
}
else
LogThisFunc(("Error while getting return code from creating temporary object: %Rrc\n", rc));
return rc;
}
int GuestSession::directoryOpenInternal(const Utf8Str &strPath, const Utf8Str &strFilter,
uint32_t uFlags, ComObjPtr<GuestDirectory> &pDirectory)
{
LogFlowThisFunc(("strPath=%s, strPath=%s, uFlags=%x\n",
strPath.c_str(), strFilter.c_str(), uFlags));
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
/* Create the directory object. */
HRESULT hr = pDirectory.createObject();
if (FAILED(hr))
return VERR_COM_UNEXPECTED;
int rc = pDirectory->init(this /* Parent */,
strPath, strFilter, uFlags);
if (RT_FAILURE(rc))
return rc;
/* Add the created directory to our vector. */
mData.mDirectories.push_back(pDirectory);
LogFlowFunc(("Added new directory \"%s\" (Session: %RU32)\n",
strPath.c_str(), mData.mId));
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;
}
/**
* Implementation of FileRemove(). Can throw an exception due to the use of
* Utf8Str, Utf8StrFmt and std::vector near the beginning (and others?). The
* caller should catch this. On success, *prc will be set to the return code
* of the delete operation to distinguish between API and command failure.
*/
int GuestSession::fileRemoveInternal(Utf8Str strPath, int *prc)
{
GuestProcessStartupInfo procInfo;
GuestProcessStream streamOut;
int rc = VINF_SUCCESS;
AssertPtrReturn(prc, VERR_INVALID_POINTER);
procInfo.mName = Utf8StrFmt(tr("Removing file \"%s\"",
strPath.c_str()));
procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_RM);
procInfo.mFlags = ProcessCreateFlag_Hidden
| ProcessCreateFlag_WaitForStdOut;
/* Construct arguments. */
procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
procInfo.mArguments.push_back(strPath); /* The directory we want to create. */
ComObjPtr<GuestProcess> pProcess;
rc = processCreateExInteral(procInfo, pProcess);
if (RT_SUCCESS(rc))
rc = pProcess->startProcess();
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_Terminate
|| waitRes.mResult == ProcessWaitResult_Error
|| waitRes.mResult == ProcessWaitResult_Timeout)
{
break;
}
rc = pProcess->readData(OUTPUT_HANDLE_ID_STDOUT, sizeof(byBuf),
30 * 1000 /* Timeout */, byBuf, sizeof(byBuf),
&cbRead);
if (RT_FAILURE(rc))
break;
if (cbRead)
{
rc = streamOut.AddData(byBuf, cbRead);
if (RT_FAILURE(rc))
break;
}
}
LogFlowThisFunc(("rc=%Rrc, cbRead=%RU32, cbStreamOut=%RU32\n",
rc, cbRead, streamOut.GetSize()));
}
else
LogThisFunc(("Error starting delete tool on guest: %Rrc\n", rc));
if (RT_FAILURE(rc))
LogThisFunc(("Error running delete tool on guest: %Rrc\n", rc));
else if (!streamOut.GetSize())
{
LogThisFunc(("No return code after deleting file"));
rc = VERR_NO_DATA;
}
if (RT_SUCCESS(rc))
{
GuestProcessStreamBlock streamBlock;
int64_t i64rc;
rc = streamOut.ParseBlock(streamBlock);
streamBlock.GetString("fname");
rc = streamBlock.GetInt64Ex("rc", &i64rc);
if (RT_SUCCESS(rc))
*prc = (int)i64rc;
}
else
Log(("Error getting return code from deleting file: %Rrc\n", rc));
return rc;
}
int GuestSession::fileOpenInternal(const Utf8Str &strPath, const Utf8Str &strOpenMode, const Utf8Str &strDisposition,
uint32_t uCreationMode, int64_t iOffset, ComObjPtr<GuestFile> &pFile)
{
LogFlowThisFunc(("strPath=%s, strOpenMode=%s, strDisposition=%s, uCreationMode=%x, iOffset=%RI64\n",
strPath.c_str(), strOpenMode.c_str(), strDisposition.c_str(), uCreationMode, iOffset));
/* Create the directory object. */
HRESULT hr = pFile.createObject();
if (FAILED(hr))
return VERR_COM_UNEXPECTED;
/* Note: There will be a race between creating and getting/initing the directory
object here. */
int rc = pFile->init(this /* Parent */,
strPath, strOpenMode, strDisposition, uCreationMode, iOffset);
if (RT_FAILURE(rc))
return rc;
/* Add the created directory to our vector. */
mData.mFiles.push_back(pFile);
LogFlowFunc(("Added new file \"%s\" (Session: %RU32\n",
strPath.c_str(), mData.mId));
LogFlowFuncLeaveRC(rc);
return rc;
}
/* Note: Will work on directories and others, too. */
int GuestSession::fileQueryInfoInternal(const Utf8Str &strPath, GuestFsObjData &objData)
{
LogFlowThisFunc(("strPath=%s\n", strPath.c_str()));
GuestProcessStartupInfo procInfo;
procInfo.mName = Utf8StrFmt(tr("Querying info for \"%s\""), strPath.c_str());
procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_STAT);
procInfo.mFlags = ProcessCreateFlag_Hidden | 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))
rc = pProcess->startProcess();
if (RT_SUCCESS(rc))
{
GuestProcessWaitResult waitRes;
BYTE byBuf[_64K];
size_t cbRead = 0;
/** @todo Merge with GuestDirectory::read. */
for (;;)
{
rc = pProcess->waitFor(ProcessWaitForFlag_StdOut,
30 * 1000 /* Timeout */, waitRes);
if ( RT_FAILURE(rc)
|| waitRes.mResult == ProcessWaitResult_Terminate
|| waitRes.mResult == ProcessWaitResult_Error
|| waitRes.mResult == ProcessWaitResult_Timeout)
{
break;
}
rc = pProcess->readData(OUTPUT_HANDLE_ID_STDOUT, sizeof(byBuf),
30 * 1000 /* Timeout */, byBuf, sizeof(byBuf),
&cbRead);
if (RT_FAILURE(rc))
break;
if (cbRead)
{
rc = streamOut.AddData(byBuf, cbRead);
if (RT_FAILURE(rc))
break;
}
}
LogFlowThisFunc(("rc=%Rrc, cbRead=%RU64, cbStreamOut=%RU32\n",
rc, cbRead, streamOut.GetSize()));
}
if (RT_SUCCESS(rc))
{
GuestProcessStreamBlock streamBlock;
rc = streamOut.ParseBlock(streamBlock);
if (RT_SUCCESS(rc))
{
rc = objData.FromStat(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)
{
LogFlowFunc(("Removing process (Session: %RU32) with process ID=%RU32, guest PID=%RU32 (now total %ld processes)\n",
mData.mId, itProcs->second->getProcessID(), itProcs->second->getPID(), mData.mProcesses.size() - 1));
mData.mProcesses.erase(itProcs);
return VINF_SUCCESS;
}
}
return VERR_NOT_FOUND;
}
/**
* Creates but does *not* start the process yet. See GuestProcess::startProcess() or
* GuestProcess::startProcessAsync() for that.
*
* @return IPRT status code.
* @param procInfo
* @param pProcess
*/
int GuestSession::processCreateExInteral(GuestProcessStartupInfo &procInfo, ComObjPtr<GuestProcess> &pProcess)
{
LogFlowFunc(("mCmd=%s, mFlags=%x, mTimeoutMS=%RU32\n",
procInfo.mCommand.c_str(), procInfo.mFlags, procInfo.mTimeoutMS));
#ifdef DEBUG
if (procInfo.mArguments.size())
{
LogFlowFunc(("Arguments:"));
ProcessArguments::const_iterator it = procInfo.mArguments.begin();
while (it != procInfo.mArguments.end())
{
LogFlow((" %s", (*it).c_str()));
it++;
}
LogFlow(("\n"));
}
#endif
/* 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
* an infinite timeout. */
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. */
uint32_t uNewProcessID = 0;
ULONG uTries = 0;
for (;;)
{
/* Is the context ID already used? */
if (!processExists(uNewProcessID, NULL /* pProgress */))
{
/* Callback with context ID was not found. This means
* we can use this context ID for our new callback we want
* to add below. */
rc = VINF_SUCCESS;
break;
}
uNewProcessID++;
if (uNewProcessID == VBOX_GUESTCTRL_MAX_PROCESSES)
uNewProcessID = 0;
if (++uTries == UINT32_MAX)
break; /* Don't try too hard. */
}
if (RT_FAILURE(rc))
return rc;
/* Create the process object. */
HRESULT hr = pProcess.createObject();
if (FAILED(hr))
return VERR_COM_UNEXPECTED;
rc = pProcess->init(mData.mParent->getConsole() /* Console */, this /* Session */,
uNewProcessID, procInfo);
if (RT_FAILURE(rc))
return rc;
/* Add the created process to our map. */
mData.mProcesses[uNewProcessID] = pProcess;
LogFlowFunc(("Added new process (Session: %RU32) with process ID=%RU32 (now total %ld processes)\n",
mData.mId, uNewProcessID, mData.mProcesses.size()));
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);
/* Create the progress object. */
HRESULT hr = pProgress.createObject();
if (FAILED(hr))
return VERR_COM_UNEXPECTED;
hr = pProgress->init(static_cast<IGuestSession*>(this),
Bstr(strTaskDesc).raw(),
TRUE /* aCancelable */);
if (FAILED(hr))
return VERR_COM_UNEXPECTED;
/* Initialize our worker task. */
std::auto_ptr<GuestSessionTask> task(pTask);
int rc = task->RunAsync(strTaskDesc, pProgress);
if (RT_FAILURE(rc))
return rc;
/* Don't destruct on success. */
task.release();
LogFlowFuncLeaveRC(rc);
return rc;
}
/**
* Queries/collects information prior to establishing a guest session.
* This is necessary to know which guest control protocol version to use,
* among other things (later).
*
* @return IPRT status code.
*/
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
/*
* Try querying the guest control protocol version running on the guest.
* This is done using the Guest Additions version
*/
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;
}
// implementation of public methods
/////////////////////////////////////////////////////////////////////////////
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 /* GuestSession */,
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);
}
else
hr = setError(VBOX_E_IPRT_ERROR,
tr("Starting task for copying file \"%ls\" from guest to \"%ls\" on the host failed: %Rrc"), rc);
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 /* GuestSession */,
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);
}
else
hr = setError(VBOX_E_IPRT_ERROR,
tr("Starting task for copying file \"%ls\" from host to \"%ls\" on the guest failed: %Rrc"), rc);
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)
{
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, fFlags, pDirectory);
if (RT_SUCCESS(rc))
{
if (aDirectory)
{
/* Return directory object to the caller. */
hr = pDirectory.queryInterfaceTo(aDirectory);
}
else
{
rc = directoryClose(pDirectory);
if (RT_FAILURE(rc))
hr = setError(VBOX_E_IPRT_ERROR, tr("Unable to close directory object, rc=%Rrc"), rc);
}
}
else
{
switch (rc)
{
case VERR_INVALID_PARAMETER:
hr = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: Invalid parameters given"));
break;
case VERR_BROKEN_PIPE:
hr = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: Unexpectedly aborted"));
break;
case VERR_CANT_CREATE:
hr = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: Could not create directory"));
break;
default:
hr = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: %Rrc"), rc);
break;
}
}
return hr;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::DirectoryCreateTemp(IN_BSTR aTemplate, ULONG aMode, IN_BSTR aPath, BOOL aSecure, BSTR *aDirectory)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
if (RT_UNLIKELY((aTemplate) == NULL || *(aTemplate) == '\0'))
return setError(E_INVALIDARG, tr("No file to remove specified"));
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
int rc = VINF_SUCCESS;
try /* Can this be done without exceptions? */
{
Utf8Str strName;
if (RT_FAILURE(objectCreateTempInternal(Utf8Str(aTemplate),
Utf8Str(aPath),
true, strName, &rc)))
return E_FAIL;
HRESULT hrc = rc == VERR_INVALID_PARAMETER ? E_INVALIDARG
: rc == VERR_NOT_SUPPORTED ? VBOX_E_NOT_SUPPORTED
: RT_FAILURE(rc) ? VBOX_E_IPRT_ERROR
: S_OK;
if (FAILED(hrc))
return setError(hrc, tr("Temporary directory creation failed: %Rrc"),
rc);
strName.cloneTo(aDirectory);
return S_OK;
}
catch (...)
{
return E_OUTOFMEMORY;
}
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::DirectoryExists(IN_BSTR aPath, BOOL *aExists)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
if (RT_UNLIKELY((aPath) == NULL || *(aPath) == '\0'))
return setError(E_INVALIDARG, tr("No directory to check existence for specified"));
CheckComArgOutPointerValid(aExists);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
HRESULT hr = S_OK;
GuestFsObjData objData;
int rc = fileQueryInfoInternal(Utf8Str(aPath), objData);
if (RT_SUCCESS(rc))
{
*aExists = objData.mType == FsObjType_Directory;
}
else
{
switch (rc)
{
/** @todo Add more errors here! */
default:
hr = setError(VBOX_E_IPRT_ERROR, tr("Querying directory existence failed: %Rrc"), rc);
break;
}
}
return hr;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::DirectoryOpen(IN_BSTR aPath, IN_BSTR aFilter, ComSafeArrayIn(DirectoryOpenFlag_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 open specified"));
if (RT_UNLIKELY((aFilter) != NULL && *(aFilter) != '\0'))
return setError(E_INVALIDARG, tr("Directory filters not implemented yet"));
CheckComArgOutPointerValid(aDirectory);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
uint32_t fFlags = DirectoryOpenFlag_None;
if (aFlags)
{
com::SafeArray<DirectoryOpenFlag_T> flags(ComSafeArrayInArg(aFlags));
for (size_t i = 0; i < flags.size(); i++)
fFlags |= flags[i];
if (fFlags)
return setError(E_INVALIDARG, tr("Open flags (%#x) not implemented yet"), fFlags);
}
HRESULT hr = S_OK;
ComObjPtr <GuestDirectory> pDirectory;
int rc = directoryOpenInternal(Utf8Str(aPath), Utf8Str(aFilter), fFlags, pDirectory);
if (RT_SUCCESS(rc))
{
if (aDirectory)
{
/* Return directory object to the caller. */
hr = pDirectory.queryInterfaceTo(aDirectory);
}
else
{
rc = directoryClose(pDirectory);
if (RT_FAILURE(rc))
hr = setError(VBOX_E_IPRT_ERROR, tr("Unable to close directory object, rc=%Rrc"), rc);
}
}
else
{
switch (rc)
{
case VERR_INVALID_PARAMETER:
hr = setError(VBOX_E_IPRT_ERROR, tr("Opening directory failed: Invalid parameters given"));
break;
case VERR_BROKEN_PIPE:
hr = setError(VBOX_E_IPRT_ERROR, tr("Opening directory failed: Unexpectedly aborted"));
break;
default:
hr = setError(VBOX_E_IPRT_ERROR, tr("Opening directory failed: %Rrc"), rc);
break;
}
}
return hr;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::DirectoryQueryInfo(IN_BSTR aPath, IGuestFsObjInfo **aInfo)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
ReturnComNotImplemented();
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::DirectoryRemove(IN_BSTR aPath)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
ReturnComNotImplemented();
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::DirectoryRemoveRecursive(IN_BSTR aPath, ComSafeArrayIn(DirectoryRemoveRecFlag_T, aFlags), IProgress **aProgress)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
ReturnComNotImplemented();
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::DirectoryRename(IN_BSTR aSource, IN_BSTR aDest, ComSafeArrayIn(PathRenameFlag_T, aFlags))
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
ReturnComNotImplemented();
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::DirectorySetACL(IN_BSTR aPath, IN_BSTR aACL)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
ReturnComNotImplemented();
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::EnvironmentClear(void)
{
#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.mEnvironment.Clear();
LogFlowFuncLeaveRC(S_OK);
return S_OK;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::EnvironmentGet(IN_BSTR aName, BSTR *aValue)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
if (RT_UNLIKELY((aName) == NULL || *(aName) == '\0'))
return setError(E_INVALIDARG, tr("No value name specified"));
CheckComArgOutPointerValid(aValue);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
Bstr strValue(mData.mEnvironment.Get(Utf8Str(aName)));
strValue.cloneTo(aValue);
LogFlowFuncLeaveRC(S_OK);
return S_OK;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::EnvironmentSet(IN_BSTR aName, IN_BSTR aValue)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
if (RT_UNLIKELY((aName) == NULL || *(aName) == '\0'))
return setError(E_INVALIDARG, tr("No value name specified"));
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
int rc = mData.mEnvironment.Set(Utf8Str(aName), Utf8Str(aValue));
HRESULT hr = RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
LogFlowFuncLeaveRC(hr);
return hr;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::EnvironmentUnset(IN_BSTR aName)
{
#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.mEnvironment.Unset(Utf8Str(aName));
LogFlowFuncLeaveRC(S_OK);
return S_OK;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::FileCreateTemp(IN_BSTR aTemplate, ULONG aMode, IN_BSTR aPath, BOOL aSecure, IGuestFile **aFile)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
ReturnComNotImplemented();
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::FileExists(IN_BSTR aPath, BOOL *aExists)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
if (RT_UNLIKELY((aPath) == NULL || *(aPath) == '\0'))
return setError(E_INVALIDARG, tr("No file to check existence for specified"));
CheckComArgOutPointerValid(aExists);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
HRESULT hr = S_OK;
GuestFsObjData objData;
int rc = fileQueryInfoInternal(Utf8Str(aPath), objData);
if (RT_SUCCESS(rc))
{
*aExists = objData.mType == FsObjType_File;
}
else
{
switch (rc)
{
/** @todo Add more errors here! */
default:
hr = setError(VBOX_E_IPRT_ERROR, tr("Querying file existence failed: %Rrc"), rc);
break;
}
}
return hr;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::FileRemove(IN_BSTR aPath)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
if (RT_UNLIKELY((aPath) == NULL || *(aPath) == '\0'))
return setError(E_INVALIDARG, tr("No file to remove specified"));
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
try /* Can this be done without exceptions? */
{
int rc2;
int rc = fileRemoveInternal(Utf8Str(aPath), &rc2);
if (RT_FAILURE((rc)))
return setError(E_FAIL,
tr("Internal error deleting file: %Rrc"), rc);
else if (RT_FAILURE((rc2)))
return setError(VBOX_E_IPRT_ERROR,
tr("File deletion on guest returned: %Rrc"), rc2);
}
catch (...)
{
return E_OUTOFMEMORY;
}
return S_OK;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::FileOpen(IN_BSTR aPath, IN_BSTR aOpenMode, IN_BSTR aDisposition, ULONG aCreationMode, LONG64 aOffset, IGuestFile **aFile)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
if (RT_UNLIKELY((aPath) == NULL || *(aPath) == '\0'))
return setError(E_INVALIDARG, tr("No file to open specified"));
if (RT_UNLIKELY((aOpenMode) == NULL || *(aOpenMode) == '\0'))
return setError(E_INVALIDARG, tr("No open mode specified"));
if (RT_UNLIKELY((aDisposition) == NULL || *(aDisposition) == '\0'))
return setError(E_INVALIDARG, tr("No disposition mode specified"));
CheckComArgOutPointerValid(aFile);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
/** @todo Validate open mode. */
/** @todo Validate disposition mode. */
/** @todo Validate creation mode. */
uint32_t uCreationMode = 0;
HRESULT hr = S_OK;
ComObjPtr <GuestFile> pFile;
int rc = fileOpenInternal(Utf8Str(aPath), Utf8Str(aOpenMode), Utf8Str(aDisposition),
aCreationMode, aOffset, pFile);
if (RT_SUCCESS(rc))
{
/* Return directory object to the caller. */
hr = pFile.queryInterfaceTo(aFile);
}
else
{
switch (rc)
{
/** @todo Add more error info! */
default:
hr = setError(VBOX_E_IPRT_ERROR, tr("Directory creation failed: %Rrc"), rc);
break;
}
}
return hr;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::FileQueryInfo(IN_BSTR aPath, IGuestFsObjInfo **aInfo)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
ReturnComNotImplemented();
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::FileQuerySize(IN_BSTR aPath, LONG64 *aSize)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
if (RT_UNLIKELY((aPath) == NULL || *(aPath) == '\0'))
return setError(E_INVALIDARG, tr("No file to query size for specified"));
CheckComArgOutPointerValid(aSize);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
HRESULT hr = S_OK;
int64_t llSize;
int rc = fileQuerySizeInternal(Utf8Str(aPath), &llSize);
if (RT_SUCCESS(rc))
{
*aSize = llSize;
}
else
{
switch (rc)
{
/** @todo Add more errors here! */
default:
hr = setError(VBOX_E_IPRT_ERROR, tr("Querying file size failed: %Rrc"), rc);
break;
}
}
return hr;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::FileRename(IN_BSTR aSource, IN_BSTR aDest, ComSafeArrayIn(PathRenameFlag_T, aFlags))
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
ReturnComNotImplemented();
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::FileSetACL(IN_BSTR aPath, IN_BSTR aACL)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
ReturnComNotImplemented();
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::ProcessCreate(IN_BSTR aCommand, ComSafeArrayIn(IN_BSTR, aArguments), ComSafeArrayIn(IN_BSTR, aEnvironment),
ComSafeArrayIn(ProcessCreateFlag_T, aFlags), ULONG aTimeoutMS, IGuestProcess **aProcess)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
com::SafeArray<LONG> affinity;
HRESULT hr = ProcessCreateEx(aCommand, ComSafeArrayInArg(aArguments), ComSafeArrayInArg(aEnvironment),
ComSafeArrayInArg(aFlags), aTimeoutMS, ProcessPriority_Default, ComSafeArrayAsInParam(affinity), aProcess);
return hr;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::ProcessCreateEx(IN_BSTR aCommand, ComSafeArrayIn(IN_BSTR, aArguments), ComSafeArrayIn(IN_BSTR, aEnvironment),
ComSafeArrayIn(ProcessCreateFlag_T, aFlags), ULONG aTimeoutMS,
ProcessPriority_T aPriority, ComSafeArrayIn(LONG, aAffinity),
IGuestProcess **aProcess)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
if (RT_UNLIKELY((aCommand) == NULL || *(aCommand) == '\0'))
return setError(E_INVALIDARG, tr("No command to execute specified"));
CheckComArgOutPointerValid(aProcess);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
GuestProcessStartupInfo procInfo;
procInfo.mCommand = Utf8Str(aCommand);
if (aArguments)
{
com::SafeArray<IN_BSTR> arguments(ComSafeArrayInArg(aArguments));
for (size_t i = 0; i < arguments.size(); i++)
procInfo.mArguments.push_back(Utf8Str(arguments[i]));
}
int rc = VINF_SUCCESS;
/*
* Create the process environment:
* - Apply the session environment in a first step, and
* - Apply environment variables specified by this call to
* have the chance of overwriting/deleting session entries.
*/
procInfo.mEnvironment = mData.mEnvironment; /* Apply original session environment. */
if (aEnvironment)
{
com::SafeArray<IN_BSTR> environment(ComSafeArrayInArg(aEnvironment));
for (size_t i = 0; i < environment.size() && RT_SUCCESS(rc); i++)
rc = procInfo.mEnvironment.Set(Utf8Str(environment[i]));
}
HRESULT hr = S_OK;
if (RT_SUCCESS(rc))
{
if (aFlags)
{
com::SafeArray<ProcessCreateFlag_T> flags(ComSafeArrayInArg(aFlags));
for (size_t i = 0; i < flags.size(); i++)
procInfo.mFlags |= flags[i];
}
procInfo.mTimeoutMS = aTimeoutMS;
if (aAffinity)
{
com::SafeArray<LONG> affinity(ComSafeArrayInArg(aAffinity));
for (size_t i = 0; i < affinity.size(); i++)
procInfo.mAffinity[i] = affinity[i]; /** @todo Really necessary? Later. */
}
procInfo.mPriority = aPriority;
ComObjPtr<GuestProcess> pProcess;
rc = processCreateExInteral(procInfo, pProcess);
if (RT_SUCCESS(rc))
{
/* Return guest session to the caller. */
HRESULT hr2 = pProcess.queryInterfaceTo(aProcess);
if (FAILED(hr2))
rc = VERR_COM_OBJECT_NOT_FOUND;
if (RT_SUCCESS(rc))
rc = pProcess->startProcessAsync();
}
}
if (RT_FAILURE(rc))
{
switch (rc)
{
case VERR_MAX_PROCS_REACHED:
hr = setError(VBOX_E_IPRT_ERROR, tr("Maximum number of guest processes per session (%ld) reached"),
VBOX_GUESTCTRL_MAX_PROCESSES);
break;
/** @todo Add more errors here. */
default:
hr = setError(VBOX_E_IPRT_ERROR, tr("Could not create guest process, rc=%Rrc"), rc);
break;
}
}
LogFlowFuncLeaveRC(rc);
return hr;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::ProcessGet(ULONG aPID, IGuestProcess **aProcess)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFunc(("aPID=%RU32\n", aPID));
CheckComArgOutPointerValid(aProcess);
if (aPID == 0)
return setError(E_INVALIDARG, tr("No valid process ID (PID) specified"));
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
HRESULT hr = S_OK;
ComObjPtr<GuestProcess> pProcess;
int rc = processGetByPID(aPID, &pProcess);
if (RT_FAILURE(rc))
hr = setError(E_INVALIDARG, tr("No process with PID %RU32 found"), aPID);
/* This will set (*aProcess) to NULL if pProgress is NULL. */
HRESULT hr2 = pProcess.queryInterfaceTo(aProcess);
if (SUCCEEDED(hr))
hr = hr2;
LogFlowThisFunc(("aProcess=%p, hr=%Rhrc\n", *aProcess, hr));
return hr;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::SymlinkCreate(IN_BSTR aSource, IN_BSTR aTarget, SymlinkType_T aType)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
ReturnComNotImplemented();
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::SymlinkExists(IN_BSTR aSymlink, BOOL *aExists)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
ReturnComNotImplemented();
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::SymlinkRead(IN_BSTR aSymlink, ComSafeArrayIn(SymlinkReadFlag_T, aFlags), BSTR *aTarget)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
ReturnComNotImplemented();
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::SymlinkRemoveDirectory(IN_BSTR aPath)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
ReturnComNotImplemented();
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestSession::SymlinkRemoveFile(IN_BSTR aFile)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
ReturnComNotImplemented();
#endif /* VBOX_WITH_GUEST_CONTROL */
}