Adding upstream version 7.0.14-dfsg.upstream/7.0.14-dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 973 insertions, 0 deletions

diff --git a/src/VBox/Main/src-server/VRDEServerImpl.cpp b/src/VBox/Main/src-server/VRDEServerImpl.cpp
new file mode 100644
index 00000000..f77dcaae
--- /dev/null
+++ b/src/VBox/Main/src-server/VRDEServerImpl.cpp
@@ -0,0 +1,973 @@
+/* $Id: VRDEServerImpl.cpp $ */
+/** @file
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#define LOG_GROUP LOG_GROUP_MAIN_VRDESERVER
+#include "VRDEServerImpl.h"
+#include "MachineImpl.h"
+#include "VirtualBoxImpl.h"
+#ifdef VBOX_WITH_EXTPACK
+# include "ExtPackManagerImpl.h"
+#endif
+
+#include <iprt/cpp/utils.h>
+#include <iprt/ctype.h>
+#include <iprt/ldr.h>
+#include <iprt/path.h>
+
+#include <VBox/err.h>
+#include <VBox/sup.h>
+#include <VBox/com/array.h>
+
+#include <VBox/RemoteDesktop/VRDE.h>
+
+#include "AutoStateDep.h"
+#include "AutoCaller.h"
+#include "Global.h"
+#include "LoggingNew.h"
+
+// defines
+/////////////////////////////////////////////////////////////////////////////
+#define VRDP_DEFAULT_PORT_STR "3389"
+
+// constructor / destructor
+/////////////////////////////////////////////////////////////////////////////
+
+VRDEServer::VRDEServer()
+    : mParent(NULL)
+{
+}
+
+VRDEServer::~VRDEServer()
+{
+}
+
+HRESULT VRDEServer::FinalConstruct()
+{
+    return BaseFinalConstruct();
+}
+
+void VRDEServer::FinalRelease()
+{
+    uninit();
+    BaseFinalRelease();
+}
+
+// public initializer/uninitializer for internal purposes only
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Initializes the VRDP server object.
+ *
+ *  @param aParent  Handle of the parent object.
+ */
+HRESULT VRDEServer::init(Machine *aParent)
+{
+    LogFlowThisFunc(("aParent=%p\n", aParent));
+
+    ComAssertRet(aParent, E_INVALIDARG);
+
+    /* Enclose the state transition NotReady->InInit->Ready */
+    AutoInitSpan autoInitSpan(this);
+    AssertReturn(autoInitSpan.isOk(), E_FAIL);
+
+    unconst(mParent) = aParent;
+    /* mPeer is left null */
+
+    mData.allocate();
+
+    mData->fEnabled = false;
+
+    /* Confirm a successful initialization */
+    autoInitSpan.setSucceeded();
+
+    return S_OK;
+}
+
+/**
+ *  Initializes the object given another object
+ *  (a kind of copy constructor). This object shares data with
+ *  the object passed as an argument.
+ *
+ *  @note This object must be destroyed before the original object
+ *  it shares data with is destroyed.
+ *
+ *  @note Locks @a aThat object for reading.
+ */
+HRESULT VRDEServer::init(Machine *aParent, VRDEServer *aThat)
+{
+    LogFlowThisFunc(("aParent=%p, aThat=%p\n", aParent, aThat));
+
+    ComAssertRet(aParent && aThat, E_INVALIDARG);
+
+    /* Enclose the state transition NotReady->InInit->Ready */
+    AutoInitSpan autoInitSpan(this);
+    AssertReturn(autoInitSpan.isOk(), E_FAIL);
+
+    unconst(mParent) = aParent;
+    unconst(mPeer) = aThat;
+
+    AutoCaller thatCaller(aThat);
+    AssertComRCReturnRC(thatCaller.hrc());
+
+    AutoReadLock thatLock(aThat COMMA_LOCKVAL_SRC_POS);
+    mData.share(aThat->mData);
+
+    /* Confirm a successful initialization */
+    autoInitSpan.setSucceeded();
+
+    return S_OK;
+}
+
+/**
+ *  Initializes the guest object given another guest object
+ *  (a kind of copy constructor). This object makes a private copy of data
+ *  of the original object passed as an argument.
+ *
+ *  @note Locks @a aThat object for reading.
+ */
+HRESULT VRDEServer::initCopy(Machine *aParent, VRDEServer *aThat)
+{
+    LogFlowThisFunc(("aParent=%p, aThat=%p\n", aParent, aThat));
+
+    ComAssertRet(aParent && aThat, E_INVALIDARG);
+
+    /* Enclose the state transition NotReady->InInit->Ready */
+    AutoInitSpan autoInitSpan(this);
+    AssertReturn(autoInitSpan.isOk(), E_FAIL);
+
+    unconst(mParent) = aParent;
+    /* mPeer is left null */
+
+    AutoCaller thatCaller(aThat);
+    AssertComRCReturnRC(thatCaller.hrc());
+
+    AutoReadLock thatLock(aThat COMMA_LOCKVAL_SRC_POS);
+    mData.attachCopy(aThat->mData);
+
+    /* Confirm a successful initialization */
+    autoInitSpan.setSucceeded();
+
+    return S_OK;
+}
+
+/**
+ *  Uninitializes the instance and sets the ready flag to FALSE.
+ *  Called either from FinalRelease() or by the parent when it gets destroyed.
+ */
+void VRDEServer::uninit()
+{
+    LogFlowThisFunc(("\n"));
+
+    /* Enclose the state transition Ready->InUninit->NotReady */
+    AutoUninitSpan autoUninitSpan(this);
+    if (autoUninitSpan.uninitDone())
+        return;
+
+    mData.free();
+
+    unconst(mPeer) = NULL;
+    unconst(mParent) = NULL;
+}
+
+/**
+ *  Loads settings from the given machine node.
+ *  May be called once right after this object creation.
+ *
+ *  @param data Configuration settings.
+ *
+ *  @note Locks this object for writing.
+ */
+HRESULT VRDEServer::i_loadSettings(const settings::VRDESettings &data)
+{
+    using namespace settings;
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+    mData.assignCopy(&data);
+
+    return S_OK;
+}
+
+/**
+ *  Saves settings to the given machine node.
+ *
+ *  @param data Configuration settings.
+ *
+ *  @note Locks this object for reading.
+ */
+HRESULT VRDEServer::i_saveSettings(settings::VRDESettings &data)
+{
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    data = *mData.data();
+
+    return S_OK;
+}
+
+// IVRDEServer properties
+/////////////////////////////////////////////////////////////////////////////
+
+HRESULT VRDEServer::getEnabled(BOOL *aEnabled)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    *aEnabled = mData->fEnabled;
+
+    return S_OK;
+}
+
+HRESULT VRDEServer::setEnabled(BOOL aEnabled)
+{
+    /* the machine can also be in saved state for this property to change */
+    AutoMutableOrSavedOrRunningStateDependency adep(mParent);
+    if (FAILED(adep.hrc())) return adep.hrc();
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    HRESULT hrc = S_OK;
+
+    if (mData->fEnabled != RT_BOOL(aEnabled))
+    {
+        mData.backup();
+        mData->fEnabled = RT_BOOL(aEnabled);
+
+        /* leave the lock before informing callbacks */
+        alock.release();
+
+        AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS);       // mParent is const, needs no locking
+        mParent->i_setModified(Machine::IsModified_VRDEServer);
+        mlock.release();
+
+        /* Avoid deadlock when i_onVRDEServerChange eventually calls SetExtraData. */
+        adep.release();
+
+        hrc = mParent->i_onVRDEServerChange(/* aRestart */ TRUE);
+        if (FAILED(hrc))
+        {
+            /* Failed to enable/disable the server. Revert the internal state. */
+            adep.add();
+            if (SUCCEEDED(adep.hrc()))
+            {
+                alock.acquire();
+                mData->fEnabled = !RT_BOOL(aEnabled);
+                alock.release();
+                mlock.acquire();
+                mParent->i_setModified(Machine::IsModified_VRDEServer);
+            }
+        }
+    }
+
+    return hrc;
+}
+
+static int i_portParseNumber(uint16_t *pu16Port, const char *pszStart, const char *pszEnd)
+{
+    /* Gets a string of digits, converts to 16 bit port number.
+     * Note: pszStart <= pszEnd is expected, the string contains
+     *       only digits and pszEnd points to the char after last
+     *       digit.
+     */
+    size_t cch = (size_t)(pszEnd - pszStart);
+    if (cch > 0 && cch <= 5) /* Port is up to 5 decimal digits. */
+    {
+        unsigned uPort = 0;
+        while (pszStart != pszEnd)
+        {
+            uPort = uPort * 10 + (unsigned)(*pszStart - '0');
+            pszStart++;
+        }
+
+        if (uPort != 0 && uPort < 0x10000)
+        {
+            if (pu16Port)
+                *pu16Port = (uint16_t)uPort;
+            return VINF_SUCCESS;
+        }
+    }
+
+    return VERR_INVALID_PARAMETER;
+}
+
+static int i_vrdpServerVerifyPortsString(const com::Utf8Str &aPortRange)
+{
+    const char *pszPortRange = aPortRange.c_str();
+
+    if (!pszPortRange || *pszPortRange == 0) /* Reject empty string. */
+        return VERR_INVALID_PARAMETER;
+
+    /* The string should be like "1000-1010,1020,2000-2003" */
+    while (*pszPortRange)
+    {
+        const char *pszStart = pszPortRange;
+        const char *pszDash = NULL;
+        const char *pszEnd = pszStart;
+
+        while (*pszEnd && *pszEnd != ',')
+        {
+            if (*pszEnd == '-')
+            {
+                if (pszDash != NULL)
+                    return VERR_INVALID_PARAMETER; /* More than one '-'. */
+
+                pszDash = pszEnd;
+            }
+            else if (!RT_C_IS_DIGIT(*pszEnd))
+                return VERR_INVALID_PARAMETER;
+
+            pszEnd++;
+        }
+
+        /* Update the next range pointer. */
+        pszPortRange = pszEnd;
+        if (*pszPortRange == ',')
+        {
+            pszPortRange++;
+        }
+
+        /* A probably valid range. Verify and parse it. */
+        int vrc;
+        if (pszDash)
+        {
+            vrc = i_portParseNumber(NULL, pszStart, pszDash);
+            if (RT_SUCCESS(vrc))
+                vrc = i_portParseNumber(NULL, pszDash + 1, pszEnd);
+        }
+        else
+            vrc = i_portParseNumber(NULL, pszStart, pszEnd);
+
+        if (RT_FAILURE(vrc))
+            return vrc;
+    }
+
+    return VINF_SUCCESS;
+}
+
+HRESULT VRDEServer::setVRDEProperty(const com::Utf8Str &aKey, const com::Utf8Str &aValue)
+{
+    LogFlowThisFunc(("\n"));
+
+    /* the machine can also be in saved state for this property to change */
+    AutoMutableOrSavedOrRunningStateDependency adep(mParent);
+    if (FAILED(adep.hrc())) return adep.hrc();
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    /* Special processing for some "standard" properties. */
+    if (aKey == "TCP/Ports")
+    {
+        /* Verify the string. "0" means the default port. */
+        Utf8Str strPorts = aValue == "0"?
+                               VRDP_DEFAULT_PORT_STR:
+                               aValue;
+        int vrc = i_vrdpServerVerifyPortsString(strPorts);
+        if (RT_FAILURE(vrc))
+            return E_INVALIDARG;
+
+        if (strPorts != mData->mapProperties["TCP/Ports"])
+        {
+            /* Port value is not verified here because it is up to VRDP transport to
+             * use it. Specifying a wrong port number will cause a running server to
+             * stop. There is no fool proof here.
+             */
+            mData.backup();
+            mData->mapProperties["TCP/Ports"] = strPorts;
+
+            /* leave the lock before informing callbacks */
+            alock.release();
+
+            AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS);       // mParent is const, needs no locking
+            mParent->i_setModified(Machine::IsModified_VRDEServer);
+            mlock.release();
+
+            /* Avoid deadlock when i_onVRDEServerChange eventually calls SetExtraData. */
+            adep.release();
+
+            mParent->i_onVRDEServerChange(/* aRestart */ TRUE);
+        }
+    }
+    else
+    {
+        /* Generic properties processing.
+         * Look up the old value first; if nothing's changed then do nothing.
+         */
+        Utf8Str strOldValue;
+
+        settings::StringsMap::const_iterator it = mData->mapProperties.find(aKey);
+        if (it != mData->mapProperties.end())
+            strOldValue = it->second;
+
+        if (strOldValue != aValue)
+        {
+            if (aValue.isEmpty())
+                mData->mapProperties.erase(aKey);
+            else
+                mData->mapProperties[aKey] = aValue;
+
+            /* leave the lock before informing callbacks */
+            alock.release();
+
+            AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS);
+            mParent->i_setModified(Machine::IsModified_VRDEServer);
+            mlock.release();
+
+            /* Avoid deadlock when i_onVRDEServerChange eventually calls SetExtraData. */
+            adep.release();
+
+            mParent->i_onVRDEServerChange(/* aRestart */ TRUE);
+        }
+    }
+
+    return S_OK;
+}
+
+HRESULT VRDEServer::getVRDEProperty(const com::Utf8Str &aKey, com::Utf8Str &aValue)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    settings::StringsMap::const_iterator it = mData->mapProperties.find(aKey);
+    if (it != mData->mapProperties.end())
+        aValue = it->second; // source is a Utf8Str
+    else if (aKey == "TCP/Ports")
+        aValue = VRDP_DEFAULT_PORT_STR;
+
+    return S_OK;
+}
+
+/*
+ * Work around clang being unhappy about PFNVRDESUPPORTEDPROPERTIES
+ * ("exception specifications are not allowed beyond a single level of
+ * indirection").  The original comment for 13.0 check said: "assuming
+ * this issue will be fixed eventually".  Well, 13.0 is now out, and
+ * it was not.
+ */
+#define CLANG_EXCEPTION_SPEC_HACK (RT_CLANG_PREREQ(11, 0) /* && !RT_CLANG_PREREQ(13, 0) */)
+
+#if CLANG_EXCEPTION_SPEC_HACK
+static int loadVRDELibrary(const char *pszLibraryName, RTLDRMOD *phmod, void *ppfn)
+#else
+static int loadVRDELibrary(const char *pszLibraryName, RTLDRMOD *phmod, PFNVRDESUPPORTEDPROPERTIES *ppfn)
+#endif
+{
+    int vrc = VINF_SUCCESS;
+
+    RTLDRMOD hmod = NIL_RTLDRMOD;
+
+    RTERRINFOSTATIC ErrInfo;
+    RTErrInfoInitStatic(&ErrInfo);
+    if (RTPathHavePath(pszLibraryName))
+        vrc = SUPR3HardenedLdrLoadPlugIn(pszLibraryName, &hmod, &ErrInfo.Core);
+    else
+        vrc = SUPR3HardenedLdrLoadAppPriv(pszLibraryName, &hmod, RTLDRLOAD_FLAGS_LOCAL, &ErrInfo.Core);
+    if (RT_SUCCESS(vrc))
+    {
+        vrc = RTLdrGetSymbol(hmod, "VRDESupportedProperties", (void **)ppfn);
+
+        if (RT_FAILURE(vrc) && vrc != VERR_SYMBOL_NOT_FOUND)
+            LogRel(("VRDE: Error resolving symbol '%s', vrc %Rrc.\n", "VRDESupportedProperties", vrc));
+    }
+    else
+    {
+        if (RTErrInfoIsSet(&ErrInfo.Core))
+            LogRel(("VRDE: Error loading the library '%s': %s (%Rrc)\n", pszLibraryName, ErrInfo.Core.pszMsg, vrc));
+        else
+            LogRel(("VRDE: Error loading the library '%s' vrc = %Rrc.\n", pszLibraryName, vrc));
+
+        hmod = NIL_RTLDRMOD;
+    }
+
+    if (RT_SUCCESS(vrc))
+        *phmod = hmod;
+    else
+    {
+        if (hmod != NIL_RTLDRMOD)
+        {
+            RTLdrClose(hmod);
+            hmod = NIL_RTLDRMOD;
+        }
+    }
+
+    return vrc;
+}
+
+HRESULT VRDEServer::getVRDEProperties(std::vector<com::Utf8Str> &aProperties)
+{
+    size_t cProperties = 0;
+    aProperties.resize(0);
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    if (!mData->fEnabled)
+    {
+        return S_OK;
+    }
+    alock.release();
+
+    /*
+     * Check that a VRDE extension pack name is set and resolve it into a
+     * library path.
+     */
+    Bstr bstrExtPack;
+    HRESULT hrc = COMGETTER(VRDEExtPack)(bstrExtPack.asOutParam());
+    Log(("VRDEPROP: get extpack hrc 0x%08X, isEmpty %d\n", hrc, bstrExtPack.isEmpty()));
+    if (FAILED(hrc))
+        return hrc;
+    if (bstrExtPack.isEmpty())
+        return E_FAIL;
+
+    Utf8Str strExtPack(bstrExtPack);
+    Utf8Str strVrdeLibrary;
+    int vrc = VINF_SUCCESS;
+    if (strExtPack.equals(VBOXVRDP_KLUDGE_EXTPACK_NAME))
+        strVrdeLibrary = "VBoxVRDP";
+    else
+    {
+#ifdef VBOX_WITH_EXTPACK
+        VirtualBox *pVirtualBox = mParent->i_getVirtualBox();
+        ExtPackManager *pExtPackMgr = pVirtualBox->i_getExtPackManager();
+        vrc = pExtPackMgr->i_getVrdeLibraryPathForExtPack(&strExtPack, &strVrdeLibrary);
+#else
+        vrc = VERR_FILE_NOT_FOUND;
+#endif
+    }
+    Log(("VRDEPROP: library get vrc %Rrc\n", vrc));
+
+    if (RT_SUCCESS(vrc))
+    {
+        /*
+         * Load the VRDE library and start the server, if it is enabled.
+         */
+        PFNVRDESUPPORTEDPROPERTIES pfn = NULL;
+        RTLDRMOD hmod = NIL_RTLDRMOD;
+#if CLANG_EXCEPTION_SPEC_HACK
+        vrc = loadVRDELibrary(strVrdeLibrary.c_str(), &hmod, (void **)&pfn);
+#else
+        vrc = loadVRDELibrary(strVrdeLibrary.c_str(), &hmod, &pfn);
+#endif
+        Log(("VRDEPROP: load library [%s] vrc %Rrc\n", strVrdeLibrary.c_str(), vrc));
+        if (RT_SUCCESS(vrc))
+        {
+            const char * const *papszNames = pfn();
+
+            if (papszNames)
+            {
+                size_t i;
+                for (i = 0; papszNames[i] != NULL; ++i)
+                {
+                    cProperties++;
+                }
+            }
+            Log(("VRDEPROP: %d properties\n", cProperties));
+
+            if (cProperties > 0)
+            {
+                aProperties.resize(cProperties);
+                for (size_t i = 0; i < cProperties && papszNames[i] != NULL; ++i)
+                {
+                     aProperties[i] = papszNames[i];
+                }
+            }
+
+            /* Do not forget to unload the library. */
+            RTLdrClose(hmod);
+            hmod = NIL_RTLDRMOD;
+        }
+    }
+
+    if (RT_FAILURE(vrc))
+    {
+        return E_FAIL;
+    }
+
+    return S_OK;
+}
+
+
+HRESULT VRDEServer::getAuthType(AuthType_T *aType)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    *aType = mData->authType;
+
+    return S_OK;
+}
+
+HRESULT VRDEServer::setAuthType(AuthType_T aType)
+{
+    /* the machine can also be in saved state for this property to change */
+    AutoMutableOrSavedOrRunningStateDependency adep(mParent);
+    if (FAILED(adep.hrc())) return adep.hrc();
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (mData->authType != aType)
+    {
+        mData.backup();
+        mData->authType = aType;
+
+        /* leave the lock before informing callbacks */
+        alock.release();
+
+        AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS);       // mParent is const, needs no locking
+        mParent->i_setModified(Machine::IsModified_VRDEServer);
+        mlock.release();
+
+        mParent->i_onVRDEServerChange(/* aRestart */ TRUE);
+    }
+
+    return S_OK;
+}
+
+HRESULT VRDEServer::getAuthTimeout(ULONG *aTimeout)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    *aTimeout = mData->ulAuthTimeout;
+
+    return S_OK;
+}
+
+
+HRESULT VRDEServer::setAuthTimeout(ULONG aTimeout)
+{
+    /* the machine can also be in saved state for this property to change */
+    AutoMutableOrSavedOrRunningStateDependency adep(mParent);
+    if (FAILED(adep.hrc())) return adep.hrc();
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (aTimeout != mData->ulAuthTimeout)
+    {
+        mData.backup();
+        mData->ulAuthTimeout = aTimeout;
+
+        /* leave the lock before informing callbacks */
+        alock.release();
+
+        AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS);       // mParent is const, needs no locking
+        mParent->i_setModified(Machine::IsModified_VRDEServer);
+        mlock.release();
+
+        /* sunlover 20060131: This setter does not require the notification
+         * really */
+#if 0
+        mParent->onVRDEServerChange();
+#endif
+    }
+
+    return S_OK;
+}
+
+HRESULT VRDEServer::getAuthLibrary(com::Utf8Str &aLibrary)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    aLibrary = mData->strAuthLibrary;
+    alock.release();
+
+    if (aLibrary.isEmpty())
+    {
+        /* Get the global setting. */
+        ComPtr<ISystemProperties> systemProperties;
+        HRESULT hrc = mParent->i_getVirtualBox()->COMGETTER(SystemProperties)(systemProperties.asOutParam());
+        if (SUCCEEDED(hrc))
+        {
+            Bstr strlib;
+            hrc = systemProperties->COMGETTER(VRDEAuthLibrary)(strlib.asOutParam());
+            if (SUCCEEDED(hrc))
+                aLibrary = Utf8Str(strlib).c_str();
+        }
+
+        if (FAILED(hrc))
+            return setError(hrc, tr("failed to query the library setting\n"));
+    }
+
+    return S_OK;
+}
+
+
+HRESULT VRDEServer::setAuthLibrary(const com::Utf8Str &aLibrary)
+{
+    /* the machine can also be in saved state for this property to change */
+    AutoMutableOrSavedOrRunningStateDependency adep(mParent);
+    if (FAILED(adep.hrc())) return adep.hrc();
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (mData->strAuthLibrary != aLibrary)
+    {
+        mData.backup();
+        mData->strAuthLibrary = aLibrary;
+
+        /* leave the lock before informing callbacks */
+        alock.release();
+
+        AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS);
+        mParent->i_setModified(Machine::IsModified_VRDEServer);
+        mlock.release();
+
+        mParent->i_onVRDEServerChange(/* aRestart */ TRUE);
+    }
+
+    return S_OK;
+}
+
+
+HRESULT VRDEServer::getAllowMultiConnection(BOOL *aAllowMultiConnection)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    *aAllowMultiConnection = mData->fAllowMultiConnection;
+
+    return S_OK;
+}
+
+
+HRESULT VRDEServer::setAllowMultiConnection(BOOL aAllowMultiConnection)
+{
+    /* the machine can also be in saved state for this property to change */
+    AutoMutableOrSavedOrRunningStateDependency adep(mParent);
+    if (FAILED(adep.hrc())) return adep.hrc();
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (mData->fAllowMultiConnection != RT_BOOL(aAllowMultiConnection))
+    {
+        mData.backup();
+        mData->fAllowMultiConnection = RT_BOOL(aAllowMultiConnection);
+
+        /* leave the lock before informing callbacks */
+        alock.release();
+
+        AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS);       // mParent is const, needs no locking
+        mParent->i_setModified(Machine::IsModified_VRDEServer);
+        mlock.release();
+
+        mParent->i_onVRDEServerChange(/* aRestart */ TRUE); /// @todo does it need a restart?
+    }
+
+    return S_OK;
+}
+
+HRESULT VRDEServer::getReuseSingleConnection(BOOL *aReuseSingleConnection)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    *aReuseSingleConnection = mData->fReuseSingleConnection;
+
+    return S_OK;
+}
+
+
+HRESULT VRDEServer::setReuseSingleConnection(BOOL aReuseSingleConnection)
+{
+    AutoMutableOrSavedOrRunningStateDependency adep(mParent);
+    if (FAILED(adep.hrc())) return adep.hrc();
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (mData->fReuseSingleConnection != RT_BOOL(aReuseSingleConnection))
+    {
+        mData.backup();
+        mData->fReuseSingleConnection = RT_BOOL(aReuseSingleConnection);
+
+        /* leave the lock before informing callbacks */
+        alock.release();
+
+        AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS);       // mParent is const, needs no locking
+        mParent->i_setModified(Machine::IsModified_VRDEServer);
+        mlock.release();
+
+        mParent->i_onVRDEServerChange(/* aRestart */ TRUE); /// @todo needs a restart?
+    }
+
+    return S_OK;
+}
+
+HRESULT VRDEServer::getVRDEExtPack(com::Utf8Str &aExtPack)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    Utf8Str strExtPack = mData->strVrdeExtPack;
+    alock.release();
+    HRESULT hrc = S_OK;
+
+    if (strExtPack.isNotEmpty())
+    {
+        if (strExtPack.equals(VBOXVRDP_KLUDGE_EXTPACK_NAME))
+            hrc = S_OK;
+        else
+        {
+#ifdef VBOX_WITH_EXTPACK
+            ExtPackManager *pExtPackMgr = mParent->i_getVirtualBox()->i_getExtPackManager();
+            hrc = pExtPackMgr->i_checkVrdeExtPack(&strExtPack);
+#else
+            hrc = setError(E_FAIL, tr("Extension pack '%s' does not exist"), strExtPack.c_str());
+#endif
+        }
+        if (SUCCEEDED(hrc))
+            aExtPack = strExtPack;
+    }
+    else
+    {
+        /* Get the global setting. */
+        ComPtr<ISystemProperties> systemProperties;
+        hrc = mParent->i_getVirtualBox()->COMGETTER(SystemProperties)(systemProperties.asOutParam());
+        if (SUCCEEDED(hrc))
+        {
+            Bstr bstr;
+            hrc = systemProperties->COMGETTER(DefaultVRDEExtPack)(bstr.asOutParam());
+            if (SUCCEEDED(hrc))
+                aExtPack = bstr;
+        }
+    }
+    return hrc;
+}
+
+// public methods only for internal purposes
+/////////////////////////////////////////////////////////////////////////////
+HRESULT VRDEServer::setVRDEExtPack(const com::Utf8Str &aExtPack)
+{
+    HRESULT hrc = S_OK;
+    /* the machine can also be in saved state for this property to change */
+    AutoMutableOrSavedOrRunningStateDependency adep(mParent);
+    hrc = adep.hrc();
+    if (SUCCEEDED(hrc))
+    {
+        /*
+         * If not empty, check the specific extension pack.
+         */
+        if (!aExtPack.isEmpty())
+        {
+            if (aExtPack.equals(VBOXVRDP_KLUDGE_EXTPACK_NAME))
+                hrc = S_OK;
+            else
+            {
+#ifdef VBOX_WITH_EXTPACK
+                ExtPackManager *pExtPackMgr = mParent->i_getVirtualBox()->i_getExtPackManager();
+                hrc = pExtPackMgr->i_checkVrdeExtPack(&aExtPack);
+#else
+                hrc = setError(E_FAIL, tr("Extension pack '%s' does not exist"), aExtPack.c_str());
+#endif
+            }
+        }
+        if (SUCCEEDED(hrc))
+        {
+            /*
+             * Update the setting if there is an actual change, post an
+             * change event to trigger a VRDE server restart.
+             */
+             AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+             if (aExtPack != mData->strVrdeExtPack)
+             {
+                 mData.backup();
+                 mData->strVrdeExtPack = aExtPack;
+
+                /* leave the lock before informing callbacks */
+                alock.release();
+
+                AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS);
+                mParent->i_setModified(Machine::IsModified_VRDEServer);
+                mlock.release();
+
+                mParent->i_onVRDEServerChange(/* aRestart */ TRUE);
+            }
+        }
+    }
+
+    return hrc;
+}
+
+// public methods only for internal purposes
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  @note Locks this object for writing.
+ */
+void VRDEServer::i_rollback()
+{
+    /* sanity */
+    AutoCaller autoCaller(this);
+    AssertComRCReturnVoid(autoCaller.hrc());
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    mData.rollback();
+}
+
+/**
+ *  @note Locks this object for writing, together with the peer object (also
+ *  for writing) if there is one.
+ */
+void VRDEServer::i_commit()
+{
+    /* sanity */
+    AutoCaller autoCaller(this);
+    AssertComRCReturnVoid(autoCaller.hrc());
+
+    /* sanity too */
+    AutoCaller peerCaller(mPeer);
+    AssertComRCReturnVoid(peerCaller.hrc());
+
+    /* lock both for writing since we modify both (mPeer is "master" so locked
+     * first) */
+    AutoMultiWriteLock2 alock(mPeer, this COMMA_LOCKVAL_SRC_POS);
+
+    if (mData.isBackedUp())
+    {
+        mData.commit();
+        if (mPeer)
+        {
+            /* attach new data to the peer and reshare it */
+            mPeer->mData.attach(mData);
+        }
+    }
+}
+
+/**
+ *  @note Locks this object for writing, together with the peer object
+ *  represented by @a aThat (locked for reading).
+ */
+void VRDEServer::i_copyFrom(VRDEServer *aThat)
+{
+    AssertReturnVoid(aThat != NULL);
+
+    /* sanity */
+    AutoCaller autoCaller(this);
+    AssertComRCReturnVoid(autoCaller.hrc());
+
+    /* sanity too */
+    AutoCaller thatCaller(aThat);
+    AssertComRCReturnVoid(thatCaller.hrc());
+
+    /* peer is not modified, lock it for reading (aThat is "master" so locked
+     * first) */
+    AutoReadLock rl(aThat COMMA_LOCKVAL_SRC_POS);
+    AutoWriteLock wl(this COMMA_LOCKVAL_SRC_POS);
+
+    /* this will back up current data */
+    mData.assignCopy(aThat->mData);
+}
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */