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, 6599 insertions, 0 deletions

diff --git a/src/VBox/Main/src-server/VirtualBoxImpl.cpp b/src/VBox/Main/src-server/VirtualBoxImpl.cpp
new file mode 100644
index 00000000..73e07dbb
--- /dev/null
+++ b/src/VBox/Main/src-server/VirtualBoxImpl.cpp
@@ -0,0 +1,6599 @@
+/* $Id: VirtualBoxImpl.cpp $ */
+/** @file
+ * Implementation of IVirtualBox in VBoxSVC.
+ */
+
+/*
+ * 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_VIRTUALBOX
+#include <iprt/asm.h>
+#include <iprt/base64.h>
+#include <iprt/buildconfig.h>
+#include <iprt/cpp/utils.h>
+#include <iprt/dir.h>
+#include <iprt/env.h>
+#include <iprt/file.h>
+#include <iprt/path.h>
+#include <iprt/process.h>
+#include <iprt/rand.h>
+#include <iprt/sha.h>
+#include <iprt/string.h>
+#include <iprt/stream.h>
+#include <iprt/system.h>
+#include <iprt/thread.h>
+#include <iprt/uuid.h>
+#include <iprt/cpp/xml.h>
+#include <iprt/ctype.h>
+
+#include <VBox/com/com.h>
+#include <VBox/com/array.h>
+#include "VBox/com/EventQueue.h"
+#include "VBox/com/MultiResult.h"
+
+#include <VBox/err.h>
+#include <VBox/param.h>
+#include <VBox/settings.h>
+#include <VBox/sup.h>
+#include <VBox/version.h>
+
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
+# include <VBox/GuestHost/SharedClipboard-transfers.h>
+#endif
+
+#include <package-generated.h>
+
+#include <algorithm>
+#include <set>
+#include <vector>
+#include <memory> // for auto_ptr
+
+#include "VirtualBoxImpl.h"
+
+#include "Global.h"
+#include "MachineImpl.h"
+#include "MediumImpl.h"
+#include "SharedFolderImpl.h"
+#include "ProgressImpl.h"
+#include "HostImpl.h"
+#include "USBControllerImpl.h"
+#include "SystemPropertiesImpl.h"
+#include "GuestOSTypeImpl.h"
+#include "NetworkServiceRunner.h"
+#include "DHCPServerImpl.h"
+#include "NATNetworkImpl.h"
+#ifdef VBOX_WITH_VMNET
+#include "HostOnlyNetworkImpl.h"
+#endif /* VBOX_WITH_VMNET */
+#ifdef VBOX_WITH_CLOUD_NET
+#include "CloudNetworkImpl.h"
+#endif /* VBOX_WITH_CLOUD_NET */
+#ifdef VBOX_WITH_RESOURCE_USAGE_API
+# include "PerformanceImpl.h"
+#endif /* VBOX_WITH_RESOURCE_USAGE_API */
+#ifdef VBOX_WITH_UPDATE_AGENT
+# include "UpdateAgentImpl.h"
+#endif
+#include "EventImpl.h"
+#ifdef VBOX_WITH_EXTPACK
+# include "ExtPackManagerImpl.h"
+#endif
+#ifdef VBOX_WITH_UNATTENDED
+# include "UnattendedImpl.h"
+#endif
+#include "AutostartDb.h"
+#include "ClientWatcher.h"
+#include "AutoCaller.h"
+#include "LoggingNew.h"
+#include "CloudProviderManagerImpl.h"
+#include "ThreadTask.h"
+#include "VBoxEvents.h"
+
+#include <QMTranslator.h>
+
+#ifdef RT_OS_WINDOWS
+# include "win/svchlp.h"
+# include "tchar.h"
+#endif
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Definitions
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#define VBOX_GLOBAL_SETTINGS_FILE "VirtualBox.xml"
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Global variables
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// static
+com::Utf8Str VirtualBox::sVersion;
+
+// static
+com::Utf8Str VirtualBox::sVersionNormalized;
+
+// static
+ULONG VirtualBox::sRevision;
+
+// static
+com::Utf8Str VirtualBox::sPackageType;
+
+// static
+com::Utf8Str VirtualBox::sAPIVersion;
+
+// static
+std::map<com::Utf8Str, int> VirtualBox::sNatNetworkNameToRefCount;
+
+// static leaked (todo: find better place to free it.)
+RWLockHandle *VirtualBox::spMtxNatNetworkNameToRefCountLock;
+
+
+#if 0 /* obsoleted by AsyncEvent */
+////////////////////////////////////////////////////////////////////////////////
+//
+// CallbackEvent class
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Abstract callback event class to asynchronously call VirtualBox callbacks
+ *  on a dedicated event thread. Subclasses reimplement #prepareEventDesc()
+ *  to initialize the event depending on the event to be dispatched.
+ *
+ *  @note The VirtualBox instance passed to the constructor is strongly
+ *  referenced, so that the VirtualBox singleton won't be released until the
+ *  event gets handled by the event thread.
+ */
+class VirtualBox::CallbackEvent : public Event
+{
+public:
+
+    CallbackEvent(VirtualBox *aVirtualBox, VBoxEventType_T aWhat)
+        : mVirtualBox(aVirtualBox), mWhat(aWhat)
+    {
+        Assert(aVirtualBox);
+    }
+
+    void *handler();
+
+    virtual HRESULT prepareEventDesc(IEventSource* aSource, VBoxEventDesc& aEvDesc) = 0;
+
+private:
+
+    /**
+     *  Note that this is a weak ref -- the CallbackEvent handler thread
+     *  is bound to the lifetime of the VirtualBox instance, so it's safe.
+     */
+    VirtualBox         *mVirtualBox;
+protected:
+    VBoxEventType_T     mWhat;
+};
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// AsyncEvent class
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * For firing off an event on asynchronously on an event thread.
+ */
+class VirtualBox::AsyncEvent : public Event
+{
+public:
+    AsyncEvent(VirtualBox *a_pVirtualBox, ComPtr<IEvent> const &a_rEvent)
+        : mVirtualBox(a_pVirtualBox), mEvent(a_rEvent)
+    {
+        Assert(a_pVirtualBox);
+    }
+
+    void *handler() RT_OVERRIDE;
+
+private:
+    /**
+     * @note This is a weak ref -- the CallbackEvent handler thread is bound to the
+     *       lifetime of the VirtualBox instance, so it's safe.
+     */
+    VirtualBox         *mVirtualBox;
+    /** The event. */
+    ComPtr<IEvent>      mEvent;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// VirtualBox private member data definition
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#if defined(RT_OS_WINDOWS) && defined(VBOXSVC_WITH_CLIENT_WATCHER)
+/**
+ * Client process watcher data.
+ */
+class WatchedClientProcess
+{
+public:
+    WatchedClientProcess(RTPROCESS a_pid, HANDLE a_hProcess) RT_NOEXCEPT
+        : m_pid(a_pid)
+        , m_cRefs(1)
+        , m_hProcess(a_hProcess)
+    {
+    }
+
+    ~WatchedClientProcess()
+    {
+        if (m_hProcess != NULL)
+        {
+            ::CloseHandle(m_hProcess);
+            m_hProcess = NULL;
+        }
+        m_pid = NIL_RTPROCESS;
+    }
+
+    /** The client PID.   */
+    RTPROCESS           m_pid;
+    /** Number of references to this structure. */
+    uint32_t volatile   m_cRefs;
+    /** Handle of the client process.
+     * Ideally, we've got full query privileges, but we'll settle for waiting.  */
+    HANDLE              m_hProcess;
+};
+typedef std::map<RTPROCESS, WatchedClientProcess *> WatchedClientProcessMap;
+#endif
+
+
+typedef ObjectsList<Medium> MediaOList;
+typedef ObjectsList<GuestOSType> GuestOSTypesOList;
+typedef ObjectsList<SharedFolder> SharedFoldersOList;
+typedef ObjectsList<DHCPServer> DHCPServersOList;
+typedef ObjectsList<NATNetwork> NATNetworksOList;
+#ifdef VBOX_WITH_VMNET
+typedef ObjectsList<HostOnlyNetwork> HostOnlyNetworksOList;
+#endif /* VBOX_WITH_VMNET */
+#ifdef VBOX_WITH_CLOUD_NET
+typedef ObjectsList<CloudNetwork> CloudNetworksOList;
+#endif /* VBOX_WITH_CLOUD_NET */
+
+typedef std::map<Guid, ComPtr<IProgress> > ProgressMap;
+typedef std::map<Guid, ComObjPtr<Medium> > HardDiskMap;
+
+/**
+ *  Main VirtualBox data structure.
+ *  @note |const| members are persistent during lifetime so can be accessed
+ *  without locking.
+ */
+struct VirtualBox::Data
+{
+    Data()
+        : pMainConfigFile(NULL)
+        , uuidMediaRegistry("48024e5c-fdd9-470f-93af-ec29f7ea518c")
+        , uRegistryNeedsSaving(0)
+        , lockMachines(LOCKCLASS_LISTOFMACHINES)
+        , allMachines(lockMachines)
+        , lockGuestOSTypes(LOCKCLASS_LISTOFOTHEROBJECTS)
+        , allGuestOSTypes(lockGuestOSTypes)
+        , lockMedia(LOCKCLASS_LISTOFMEDIA)
+        , allHardDisks(lockMedia)
+        , allDVDImages(lockMedia)
+        , allFloppyImages(lockMedia)
+        , lockSharedFolders(LOCKCLASS_LISTOFOTHEROBJECTS)
+        , allSharedFolders(lockSharedFolders)
+        , lockDHCPServers(LOCKCLASS_LISTOFOTHEROBJECTS)
+        , allDHCPServers(lockDHCPServers)
+        , lockNATNetworks(LOCKCLASS_LISTOFOTHEROBJECTS)
+        , allNATNetworks(lockNATNetworks)
+#ifdef VBOX_WITH_VMNET
+        , lockHostOnlyNetworks(LOCKCLASS_LISTOFOTHEROBJECTS)
+        , allHostOnlyNetworks(lockHostOnlyNetworks)
+#endif /* VBOX_WITH_VMNET */
+#ifdef VBOX_WITH_CLOUD_NET
+        , lockCloudNetworks(LOCKCLASS_LISTOFOTHEROBJECTS)
+        , allCloudNetworks(lockCloudNetworks)
+#endif /* VBOX_WITH_CLOUD_NET */
+        , mtxProgressOperations(LOCKCLASS_PROGRESSLIST)
+        , pClientWatcher(NULL)
+        , threadAsyncEvent(NIL_RTTHREAD)
+        , pAsyncEventQ(NULL)
+        , pAutostartDb(NULL)
+        , fSettingsCipherKeySet(false)
+#ifdef VBOX_WITH_MAIN_NLS
+        , pVBoxTranslator(NULL)
+        , pTrComponent(NULL)
+#endif
+#if defined(RT_OS_WINDOWS) && defined(VBOXSVC_WITH_CLIENT_WATCHER)
+        , fWatcherIsReliable(RTSystemGetNtVersion() >= RTSYSTEM_MAKE_NT_VERSION(6, 0, 0))
+#endif
+        , hLdrModCrypto(NIL_RTLDRMOD)
+        , cRefsCrypto(0)
+        , pCryptoIf(NULL)
+    {
+#if defined(RT_OS_WINDOWS) && defined(VBOXSVC_WITH_CLIENT_WATCHER)
+        RTCritSectRwInit(&WatcherCritSect);
+#endif
+    }
+
+    ~Data()
+    {
+        if (pMainConfigFile)
+        {
+            delete pMainConfigFile;
+            pMainConfigFile = NULL;
+        }
+    };
+
+    // const data members not requiring locking
+    const Utf8Str                       strHomeDir;
+
+    // VirtualBox main settings file
+    const Utf8Str                       strSettingsFilePath;
+    settings::MainConfigFile            *pMainConfigFile;
+
+    // constant pseudo-machine ID for global media registry
+    const Guid                          uuidMediaRegistry;
+
+    // counter if global media registry needs saving, updated using atomic
+    // operations, without requiring any locks
+    uint64_t                            uRegistryNeedsSaving;
+
+    // const objects not requiring locking
+    const ComObjPtr<Host>               pHost;
+    const ComObjPtr<SystemProperties>   pSystemProperties;
+#ifdef VBOX_WITH_RESOURCE_USAGE_API
+    const ComObjPtr<PerformanceCollector> pPerformanceCollector;
+#endif /* VBOX_WITH_RESOURCE_USAGE_API */
+
+    // Each of the following lists use a particular lock handle that protects the
+    // list as a whole. As opposed to version 3.1 and earlier, these lists no
+    // longer need the main VirtualBox object lock, but only the respective list
+    // lock. In each case, the locking order is defined that the list must be
+    // requested before object locks of members of the lists (see the order definitions
+    // in AutoLock.h; e.g. LOCKCLASS_LISTOFMACHINES before LOCKCLASS_MACHINEOBJECT).
+    RWLockHandle                        lockMachines;
+    MachinesOList                       allMachines;
+
+    RWLockHandle                        lockGuestOSTypes;
+    GuestOSTypesOList                   allGuestOSTypes;
+
+    // All the media lists are protected by the following locking handle:
+    RWLockHandle                        lockMedia;
+    MediaOList                          allHardDisks,           // base images only!
+                                        allDVDImages,
+                                        allFloppyImages;
+    // the hard disks map is an additional map sorted by UUID for quick lookup
+    // and contains ALL hard disks (base and differencing); it is protected by
+    // the same lock as the other media lists above
+    HardDiskMap                         mapHardDisks;
+
+    // list of pending machine renames (also protected by media tree lock;
+    // see VirtualBox::rememberMachineNameChangeForMedia())
+    struct PendingMachineRename
+    {
+        Utf8Str     strConfigDirOld;
+        Utf8Str     strConfigDirNew;
+    };
+    typedef std::list<PendingMachineRename> PendingMachineRenamesList;
+    PendingMachineRenamesList           llPendingMachineRenames;
+
+    RWLockHandle                        lockSharedFolders;
+    SharedFoldersOList                  allSharedFolders;
+
+    RWLockHandle                        lockDHCPServers;
+    DHCPServersOList                    allDHCPServers;
+
+    RWLockHandle                        lockNATNetworks;
+    NATNetworksOList                    allNATNetworks;
+
+#ifdef VBOX_WITH_VMNET
+    RWLockHandle                        lockHostOnlyNetworks;
+    HostOnlyNetworksOList               allHostOnlyNetworks;
+#endif /* VBOX_WITH_VMNET */
+#ifdef VBOX_WITH_CLOUD_NET
+    RWLockHandle                        lockCloudNetworks;
+    CloudNetworksOList                  allCloudNetworks;
+#endif /* VBOX_WITH_CLOUD_NET */
+
+    RWLockHandle                        mtxProgressOperations;
+    ProgressMap                         mapProgressOperations;
+
+    ClientWatcher * const               pClientWatcher;
+
+    // the following are data for the async event thread
+    const RTTHREAD                      threadAsyncEvent;
+    EventQueue * const                  pAsyncEventQ;
+    const ComObjPtr<EventSource>        pEventSource;
+
+#ifdef VBOX_WITH_EXTPACK
+    /** The extension pack manager object lives here. */
+    const ComObjPtr<ExtPackManager>     ptrExtPackManager;
+#endif
+
+    /** The reference to the cloud provider manager singleton. */
+    const ComObjPtr<CloudProviderManager> pCloudProviderManager;
+
+    /** The global autostart database for the user. */
+    AutostartDb * const                 pAutostartDb;
+
+    /** Settings secret */
+    bool                                fSettingsCipherKeySet;
+    uint8_t                             SettingsCipherKey[RTSHA512_HASH_SIZE];
+#ifdef VBOX_WITH_MAIN_NLS
+    VirtualBoxTranslator               *pVBoxTranslator;
+    PTRCOMPONENT                        pTrComponent;
+#endif
+#if defined(RT_OS_WINDOWS) && defined(VBOXSVC_WITH_CLIENT_WATCHER)
+    /** Critical section protecting WatchedProcesses. */
+    RTCRITSECTRW                        WatcherCritSect;
+    /** Map of processes being watched, key is the PID. */
+    WatchedClientProcessMap             WatchedProcesses;
+    /** Set if the watcher is reliable, otherwise cleared.
+     * The watcher goes unreliable when we run out of memory, fail open a client
+     * process, or if the watcher thread gets messed up. */
+    bool                                fWatcherIsReliable;
+#endif
+
+    /** @name Members related to the cryptographic support interface.
+     * @{ */
+    /** The loaded module handle if loaded. */
+    RTLDRMOD                            hLdrModCrypto;
+    /** Reference counter tracking how many users of the cryptographic support
+     * are there currently. */
+    volatile uint32_t                   cRefsCrypto;
+    /** Pointer to the cryptographic support interface. */
+    PCVBOXCRYPTOIF                      pCryptoIf;
+    /** Critical section protecting the module handle. */
+    RTCRITSECT                          CritSectModCrypto;
+    /** @} */
+};
+
+// constructor / destructor
+/////////////////////////////////////////////////////////////////////////////
+
+DEFINE_EMPTY_CTOR_DTOR(VirtualBox)
+
+HRESULT VirtualBox::FinalConstruct()
+{
+    LogRelFlowThisFuncEnter();
+    LogRel(("VirtualBox: object creation starts\n"));
+
+    BaseFinalConstruct();
+
+    HRESULT hrc = init();
+
+    LogRelFlowThisFuncLeave();
+    LogRel(("VirtualBox: object created\n"));
+
+    return hrc;
+}
+
+void VirtualBox::FinalRelease()
+{
+    LogRelFlowThisFuncEnter();
+    LogRel(("VirtualBox: object deletion starts\n"));
+
+    uninit();
+
+    BaseFinalRelease();
+
+    LogRel(("VirtualBox: object deleted\n"));
+    LogRelFlowThisFuncLeave();
+}
+
+// public initializer/uninitializer for internal purposes only
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Initializes the VirtualBox object.
+ *
+ *  @return COM result code
+ */
+HRESULT VirtualBox::init()
+{
+    LogRelFlowThisFuncEnter();
+    /* Enclose the state transition NotReady->InInit->Ready */
+    AutoInitSpan autoInitSpan(this);
+    AssertReturn(autoInitSpan.isOk(), E_FAIL);
+
+    /* Locking this object for writing during init sounds a bit paradoxical,
+     * but in the current locking mess this avoids that some code gets a
+     * read lock and later calls code which wants the same write lock. */
+    AutoWriteLock lock(this COMMA_LOCKVAL_SRC_POS);
+
+    // allocate our instance data
+    m = new Data;
+
+    LogFlow(("===========================================================\n"));
+    LogFlowThisFuncEnter();
+
+    if (sVersion.isEmpty())
+        sVersion = RTBldCfgVersion();
+    if (sVersionNormalized.isEmpty())
+    {
+        Utf8Str tmp(RTBldCfgVersion());
+        if (tmp.endsWith(VBOX_BUILD_PUBLISHER))
+            tmp = tmp.substr(0, tmp.length() - strlen(VBOX_BUILD_PUBLISHER));
+        sVersionNormalized = tmp;
+    }
+    sRevision = RTBldCfgRevision();
+    if (sPackageType.isEmpty())
+        sPackageType = VBOX_PACKAGE_STRING;
+    if (sAPIVersion.isEmpty())
+        sAPIVersion = VBOX_API_VERSION_STRING;
+    if (!spMtxNatNetworkNameToRefCountLock)
+        spMtxNatNetworkNameToRefCountLock = new RWLockHandle(LOCKCLASS_VIRTUALBOXOBJECT);
+
+    LogFlowThisFunc(("Version: %s, Package: %s, API Version: %s\n", sVersion.c_str(), sPackageType.c_str(), sAPIVersion.c_str()));
+
+    /* Important: DO NOT USE any kind of "early return" (except the single
+     * one above, checking the init span success) in this method. It is vital
+     * for correct error handling that it has only one point of return, which
+     * does all the magic on COM to signal object creation success and
+     * reporting the error later for every API method. COM translates any
+     * unsuccessful object creation to REGDB_E_CLASSNOTREG errors or similar
+     * unhelpful ones which cause us a lot of grief with troubleshooting. */
+
+    HRESULT hrc = S_OK;
+    bool fCreate = false;
+    try
+    {
+        /* Create the event source early as we may fire async event during settings loading (media). */
+        hrc = unconst(m->pEventSource).createObject();
+        if (FAILED(hrc)) throw hrc;
+        hrc = m->pEventSource->init();
+        if (FAILED(hrc)) throw hrc;
+
+
+        /* Get the VirtualBox home directory. */
+        {
+            char szHomeDir[RTPATH_MAX];
+            int vrc = com::GetVBoxUserHomeDirectory(szHomeDir, sizeof(szHomeDir));
+            if (RT_FAILURE(vrc))
+                throw setErrorBoth(E_FAIL, vrc,
+                                   tr("Could not create the VirtualBox home directory '%s' (%Rrc)"),
+                                   szHomeDir, vrc);
+
+            unconst(m->strHomeDir) = szHomeDir;
+        }
+
+        LogRel(("Home directory: '%s'\n", m->strHomeDir.c_str()));
+
+        i_reportDriverVersions();
+
+        /* Create the critical section protecting the cryptographic module handle. */
+        {
+            int vrc = RTCritSectInit(&m->CritSectModCrypto);
+            if (RT_FAILURE(vrc))
+                throw setErrorBoth(E_FAIL, vrc,
+                                   tr("Could not create the cryptographic module critical section (%Rrc)"),
+                                   vrc);
+
+        }
+
+        /* compose the VirtualBox.xml file name */
+        unconst(m->strSettingsFilePath) = Utf8StrFmt("%s%c%s",
+                                                     m->strHomeDir.c_str(),
+                                                     RTPATH_DELIMITER,
+                                                     VBOX_GLOBAL_SETTINGS_FILE);
+        // load and parse VirtualBox.xml; this will throw on XML or logic errors
+        try
+        {
+            m->pMainConfigFile = new settings::MainConfigFile(&m->strSettingsFilePath);
+        }
+        catch (xml::EIPRTFailure &e)
+        {
+            // this is thrown by the XML backend if the RTOpen() call fails;
+            // only if the main settings file does not exist, create it,
+            // if there's something more serious, then do fail!
+            if (e.getStatus() == VERR_FILE_NOT_FOUND)
+                fCreate = true;
+            else
+                throw;
+        }
+
+        if (fCreate)
+            m->pMainConfigFile = new settings::MainConfigFile(NULL);
+
+#ifdef VBOX_WITH_RESOURCE_USAGE_API
+        /* create the performance collector object BEFORE host */
+        unconst(m->pPerformanceCollector).createObject();
+        hrc = m->pPerformanceCollector->init();
+        ComAssertComRCThrowRC(hrc);
+#endif /* VBOX_WITH_RESOURCE_USAGE_API */
+
+        /* create the host object early, machines will need it */
+        unconst(m->pHost).createObject();
+        hrc = m->pHost->init(this);
+        ComAssertComRCThrowRC(hrc);
+
+        hrc = m->pHost->i_loadSettings(m->pMainConfigFile->host);
+        if (FAILED(hrc)) throw hrc;
+
+        /*
+         * Create autostart database object early, because the system properties
+         * might need it.
+         */
+        unconst(m->pAutostartDb) = new AutostartDb;
+
+        /* create the system properties object, someone may need it too */
+        hrc = unconst(m->pSystemProperties).createObject();
+        if (SUCCEEDED(hrc))
+            hrc = m->pSystemProperties->init(this);
+        ComAssertComRCThrowRC(hrc);
+
+        hrc = m->pSystemProperties->i_loadSettings(m->pMainConfigFile->systemProperties);
+        if (FAILED(hrc)) throw hrc;
+#ifdef VBOX_WITH_MAIN_NLS
+        m->pVBoxTranslator = VirtualBoxTranslator::instance();
+        /* Do not throw an exception on language errors.
+         * Just do not use translation. */
+        if (m->pVBoxTranslator)
+        {
+
+            char szNlsPath[RTPATH_MAX];
+            int vrc = RTPathAppPrivateNoArch(szNlsPath, sizeof(szNlsPath));
+            if (RT_SUCCESS(vrc))
+                vrc = RTPathAppend(szNlsPath, sizeof(szNlsPath), "nls" RTPATH_SLASH_STR "VirtualBoxAPI");
+
+            if (RT_SUCCESS(vrc))
+            {
+                vrc = m->pVBoxTranslator->registerTranslation(szNlsPath, true, &m->pTrComponent);
+                if (RT_SUCCESS(vrc))
+                {
+                    com::Utf8Str strLocale;
+                    HRESULT hrc2 = m->pSystemProperties->getLanguageId(strLocale);
+                    if (SUCCEEDED(hrc2))
+                    {
+                        vrc = m->pVBoxTranslator->i_loadLanguage(strLocale.c_str());
+                        if (RT_FAILURE(vrc))
+                        {
+                            hrc2 = Global::vboxStatusCodeToCOM(vrc);
+                            LogRel(("Load language failed (%Rhrc).\n", hrc2));
+                        }
+                    }
+                    else
+                    {
+                        LogRel(("Getting language settings failed (%Rhrc).\n", hrc2));
+                        m->pVBoxTranslator->release();
+                        m->pVBoxTranslator = NULL;
+                        m->pTrComponent = NULL;
+                    }
+                }
+                else
+                {
+                    HRESULT hrc2 = Global::vboxStatusCodeToCOM(vrc);
+                    LogRel(("Register translation failed (%Rhrc).\n", hrc2));
+                    m->pVBoxTranslator->release();
+                    m->pVBoxTranslator = NULL;
+                    m->pTrComponent = NULL;
+                }
+            }
+            else
+            {
+                HRESULT hrc2 = Global::vboxStatusCodeToCOM(vrc);
+                LogRel(("Path constructing failed (%Rhrc).\n", hrc2));
+                m->pVBoxTranslator->release();
+                m->pVBoxTranslator = NULL;
+                m->pTrComponent = NULL;
+            }
+        }
+        else
+            LogRel(("Translator creation failed.\n"));
+#endif
+
+#ifdef VBOX_WITH_EXTPACK
+        /*
+         * Initialize extension pack manager before system properties because
+         * it is required for the VD plugins.
+         */
+        hrc = unconst(m->ptrExtPackManager).createObject();
+        if (SUCCEEDED(hrc))
+            hrc = m->ptrExtPackManager->initExtPackManager(this, VBOXEXTPACKCTX_PER_USER_DAEMON);
+        if (FAILED(hrc))
+            throw hrc;
+#endif
+        /* guest OS type objects, needed by machines */
+        for (size_t i = 0; i < Global::cOSTypes; ++i)
+        {
+            ComObjPtr<GuestOSType> guestOSTypeObj;
+            hrc = guestOSTypeObj.createObject();
+            if (SUCCEEDED(hrc))
+            {
+                hrc = guestOSTypeObj->init(Global::sOSTypes[i]);
+                if (SUCCEEDED(hrc))
+                    m->allGuestOSTypes.addChild(guestOSTypeObj);
+            }
+            ComAssertComRCThrowRC(hrc);
+        }
+
+        /* all registered media, needed by machines */
+        if (FAILED(hrc = initMedia(m->uuidMediaRegistry,
+                                  m->pMainConfigFile->mediaRegistry,
+                                  Utf8Str::Empty)))     // const Utf8Str &machineFolder
+            throw hrc;
+
+        /* machines */
+        if (FAILED(hrc = initMachines()))
+            throw hrc;
+
+#ifdef DEBUG
+        LogFlowThisFunc(("Dumping media backreferences\n"));
+        i_dumpAllBackRefs();
+#endif
+
+        /* net services - dhcp services */
+        for (settings::DHCPServersList::const_iterator it = m->pMainConfigFile->llDhcpServers.begin();
+             it != m->pMainConfigFile->llDhcpServers.end();
+             ++it)
+        {
+            const settings::DHCPServer &data = *it;
+
+            ComObjPtr<DHCPServer> pDhcpServer;
+            if (SUCCEEDED(hrc = pDhcpServer.createObject()))
+                hrc = pDhcpServer->init(this, data);
+            if (FAILED(hrc)) throw hrc;
+
+            hrc = i_registerDHCPServer(pDhcpServer, false /* aSaveRegistry */);
+            if (FAILED(hrc)) throw hrc;
+        }
+
+        /* net services - nat networks */
+        for (settings::NATNetworksList::const_iterator it = m->pMainConfigFile->llNATNetworks.begin();
+             it != m->pMainConfigFile->llNATNetworks.end();
+             ++it)
+        {
+            const settings::NATNetwork &net = *it;
+
+            ComObjPtr<NATNetwork> pNATNetwork;
+            hrc = pNATNetwork.createObject();
+            AssertComRCThrowRC(hrc);
+            hrc = pNATNetwork->init(this, "");
+            AssertComRCThrowRC(hrc);
+            hrc = pNATNetwork->i_loadSettings(net);
+            AssertComRCThrowRC(hrc);
+            hrc = i_registerNATNetwork(pNATNetwork, false /* aSaveRegistry */);
+            AssertComRCThrowRC(hrc);
+        }
+
+#ifdef VBOX_WITH_VMNET
+        /* host-only networks */
+        for (settings::HostOnlyNetworksList::const_iterator it = m->pMainConfigFile->llHostOnlyNetworks.begin();
+             it != m->pMainConfigFile->llHostOnlyNetworks.end();
+             ++it)
+        {
+            ComObjPtr<HostOnlyNetwork> pHostOnlyNetwork;
+            hrc = pHostOnlyNetwork.createObject();
+            AssertComRCThrowRC(hrc);
+            hrc = pHostOnlyNetwork->init(this, "TODO???");
+            AssertComRCThrowRC(hrc);
+            hrc = pHostOnlyNetwork->i_loadSettings(*it);
+            AssertComRCThrowRC(hrc);
+            m->allHostOnlyNetworks.addChild(pHostOnlyNetwork);
+            AssertComRCThrowRC(hrc);
+        }
+#endif /* VBOX_WITH_VMNET */
+
+#ifdef VBOX_WITH_CLOUD_NET
+        /* net services - cloud networks */
+        for (settings::CloudNetworksList::const_iterator it = m->pMainConfigFile->llCloudNetworks.begin();
+             it != m->pMainConfigFile->llCloudNetworks.end();
+             ++it)
+        {
+            ComObjPtr<CloudNetwork> pCloudNetwork;
+            hrc = pCloudNetwork.createObject();
+            AssertComRCThrowRC(hrc);
+            hrc = pCloudNetwork->init(this, "");
+            AssertComRCThrowRC(hrc);
+            hrc = pCloudNetwork->i_loadSettings(*it);
+            AssertComRCThrowRC(hrc);
+            m->allCloudNetworks.addChild(pCloudNetwork);
+            AssertComRCThrowRC(hrc);
+        }
+#endif /* VBOX_WITH_CLOUD_NET */
+
+        /* cloud provider manager */
+        hrc = unconst(m->pCloudProviderManager).createObject();
+        if (SUCCEEDED(hrc))
+            hrc = m->pCloudProviderManager->init(this);
+        ComAssertComRCThrowRC(hrc);
+        if (FAILED(hrc)) throw hrc;
+    }
+    catch (HRESULT err)
+    {
+        /* we assume that error info is set by the thrower */
+        hrc = err;
+    }
+    catch (...)
+    {
+        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
+    }
+
+    if (SUCCEEDED(hrc))
+    {
+        /* set up client monitoring */
+        try
+        {
+            unconst(m->pClientWatcher) = new ClientWatcher(this);
+            if (!m->pClientWatcher->isReady())
+            {
+                delete m->pClientWatcher;
+                unconst(m->pClientWatcher) = NULL;
+                hrc = E_FAIL;
+            }
+        }
+        catch (std::bad_alloc &)
+        {
+            hrc = E_OUTOFMEMORY;
+        }
+    }
+
+    if (SUCCEEDED(hrc))
+    {
+        try
+        {
+            /* start the async event handler thread */
+            int vrc = RTThreadCreate(&unconst(m->threadAsyncEvent),
+                                     AsyncEventHandler,
+                                     &unconst(m->pAsyncEventQ),
+                                     0,
+                                     RTTHREADTYPE_MAIN_WORKER,
+                                     RTTHREADFLAGS_WAITABLE,
+                                     "EventHandler");
+            ComAssertRCThrow(vrc, E_FAIL);
+
+            /* wait until the thread sets m->pAsyncEventQ */
+            RTThreadUserWait(m->threadAsyncEvent, RT_INDEFINITE_WAIT);
+            ComAssertThrow(m->pAsyncEventQ, E_FAIL);
+        }
+        catch (HRESULT hrcXcpt)
+        {
+            hrc = hrcXcpt;
+        }
+    }
+
+#ifdef VBOX_WITH_EXTPACK
+    /* Let the extension packs have a go at things. */
+    if (SUCCEEDED(hrc))
+    {
+        lock.release();
+        m->ptrExtPackManager->i_callAllVirtualBoxReadyHooks();
+    }
+#endif
+
+    /* Confirm a successful initialization when it's the case. Must be last,
+     * as on failure it will uninitialize the object. */
+    if (SUCCEEDED(hrc))
+        autoInitSpan.setSucceeded();
+    else
+        autoInitSpan.setFailed(hrc);
+
+    LogFlowThisFunc(("hrc=%Rhrc\n", hrc));
+    LogFlowThisFuncLeave();
+    LogFlow(("===========================================================\n"));
+    /* Unconditionally return success, because the error return is delayed to
+     * the attribute/method calls through the InitFailed object state. */
+    return S_OK;
+}
+
+HRESULT VirtualBox::initMachines()
+{
+    for (settings::MachinesRegistry::const_iterator it = m->pMainConfigFile->llMachines.begin();
+         it != m->pMainConfigFile->llMachines.end();
+         ++it)
+    {
+        HRESULT hrc = S_OK;
+        const settings::MachineRegistryEntry &xmlMachine = *it;
+        Guid uuid = xmlMachine.uuid;
+
+        /* Check if machine record has valid parameters. */
+        if (xmlMachine.strSettingsFile.isEmpty() || uuid.isZero())
+        {
+            LogRel(("Skipped invalid machine record.\n"));
+            continue;
+        }
+
+        ComObjPtr<Machine> pMachine;
+        com::Utf8Str strPassword;
+        if (SUCCEEDED(hrc = pMachine.createObject()))
+        {
+            hrc = pMachine->initFromSettings(this, xmlMachine.strSettingsFile, &uuid, strPassword);
+            if (SUCCEEDED(hrc))
+                hrc = i_registerMachine(pMachine);
+            if (FAILED(hrc))
+                return hrc;
+        }
+    }
+
+    return S_OK;
+}
+
+/**
+ * Loads a media registry from XML and adds the media contained therein to
+ * the global lists of known media.
+ *
+ * This now (4.0) gets called from two locations:
+ *
+ *  --  VirtualBox::init(), to load the global media registry from VirtualBox.xml;
+ *
+ *  --  Machine::loadMachineDataFromSettings(), to load the per-machine registry
+ *      from machine XML, for machines created with VirtualBox 4.0 or later.
+ *
+ * In both cases, the media found are added to the global lists so the
+ * global arrays of media (including the GUI's virtual media manager)
+ * continue to work as before.
+ *
+ * @param uuidRegistry The UUID of the media registry. This is either the
+ *       transient UUID created at VirtualBox startup for the global registry or
+ *       a machine ID.
+ * @param mediaRegistry The XML settings structure to load, either from VirtualBox.xml
+ *       or a machine XML.
+ * @param strMachineFolder The folder of the machine.
+ * @return
+ */
+HRESULT VirtualBox::initMedia(const Guid &uuidRegistry,
+                              const settings::MediaRegistry &mediaRegistry,
+                              const Utf8Str &strMachineFolder)
+{
+    LogFlow(("VirtualBox::initMedia ENTERING, uuidRegistry=%s, strMachineFolder=%s\n",
+             uuidRegistry.toString().c_str(),
+             strMachineFolder.c_str()));
+
+    AutoWriteLock treeLock(i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    // the order of notification is critical for GUI, so use std::list<std::pair> instead of map
+    std::list<std::pair<Guid, DeviceType_T> > uIdsForNotify;
+
+    HRESULT hrc = S_OK;
+    settings::MediaList::const_iterator it;
+    for (it = mediaRegistry.llHardDisks.begin();
+         it != mediaRegistry.llHardDisks.end();
+         ++it)
+    {
+        const settings::Medium &xmlHD = *it;
+
+        hrc = Medium::initFromSettings(this,
+                                       DeviceType_HardDisk,
+                                       uuidRegistry,
+                                       strMachineFolder,
+                                       xmlHD,
+                                       treeLock,
+                                       uIdsForNotify);
+        if (FAILED(hrc)) return hrc;
+    }
+
+    for (it = mediaRegistry.llDvdImages.begin();
+         it != mediaRegistry.llDvdImages.end();
+         ++it)
+    {
+        const settings::Medium &xmlDvd = *it;
+
+        hrc = Medium::initFromSettings(this,
+                                       DeviceType_DVD,
+                                       uuidRegistry,
+                                       strMachineFolder,
+                                       xmlDvd,
+                                       treeLock,
+                                       uIdsForNotify);
+        if (FAILED(hrc)) return hrc;
+    }
+
+    for (it = mediaRegistry.llFloppyImages.begin();
+         it != mediaRegistry.llFloppyImages.end();
+         ++it)
+    {
+        const settings::Medium &xmlFloppy = *it;
+
+        hrc = Medium::initFromSettings(this,
+                                       DeviceType_Floppy,
+                                       uuidRegistry,
+                                       strMachineFolder,
+                                       xmlFloppy,
+                                       treeLock,
+                                       uIdsForNotify);
+        if (FAILED(hrc)) return hrc;
+    }
+
+    for (std::list<std::pair<Guid, DeviceType_T> >::const_iterator itItem = uIdsForNotify.begin();
+         itItem != uIdsForNotify.end();
+         ++itItem)
+    {
+        i_onMediumRegistered(itItem->first, itItem->second, TRUE);
+    }
+
+    LogFlow(("VirtualBox::initMedia LEAVING\n"));
+
+    return S_OK;
+}
+
+void VirtualBox::uninit()
+{
+    /* Must be done outside the AutoUninitSpan, as it expects AutoCaller to
+     * be successful. This needs additional checks to protect against double
+     * uninit, as then the pointer is NULL. */
+    if (RT_VALID_PTR(m))
+    {
+        Assert(!m->uRegistryNeedsSaving);
+        if (m->uRegistryNeedsSaving)
+            i_saveSettings();
+    }
+
+    /* Enclose the state transition Ready->InUninit->NotReady */
+    AutoUninitSpan autoUninitSpan(this);
+    if (autoUninitSpan.uninitDone())
+        return;
+
+    LogFlow(("===========================================================\n"));
+    LogFlowThisFuncEnter();
+    LogFlowThisFunc(("initFailed()=%d\n", autoUninitSpan.initFailed()));
+
+    /* tell all our child objects we've been uninitialized */
+
+    LogFlowThisFunc(("Uninitializing machines (%d)...\n", m->allMachines.size()));
+    if (m->pHost)
+    {
+        /* It is necessary to hold the VirtualBox and Host locks here because
+           we may have to uninitialize SessionMachines. */
+        AutoMultiWriteLock2 multilock(this, m->pHost COMMA_LOCKVAL_SRC_POS);
+        m->allMachines.uninitAll();
+    }
+    else
+        m->allMachines.uninitAll();
+    m->allFloppyImages.uninitAll();
+    m->allDVDImages.uninitAll();
+    m->allHardDisks.uninitAll();
+    m->allDHCPServers.uninitAll();
+
+    m->mapProgressOperations.clear();
+
+    m->allGuestOSTypes.uninitAll();
+
+    /* Note that we release singleton children after we've all other children.
+     * In some cases this is important because these other children may use
+     * some resources of the singletons which would prevent them from
+     * uninitializing (as for example, mSystemProperties which owns
+     * MediumFormat objects which Medium objects refer to) */
+    if (m->pCloudProviderManager)
+    {
+        m->pCloudProviderManager->uninit();
+        unconst(m->pCloudProviderManager).setNull();
+    }
+
+    if (m->pSystemProperties)
+    {
+        m->pSystemProperties->uninit();
+        unconst(m->pSystemProperties).setNull();
+    }
+
+    if (m->pHost)
+    {
+        m->pHost->uninit();
+        unconst(m->pHost).setNull();
+    }
+
+#ifdef VBOX_WITH_RESOURCE_USAGE_API
+    if (m->pPerformanceCollector)
+    {
+        m->pPerformanceCollector->uninit();
+        unconst(m->pPerformanceCollector).setNull();
+    }
+#endif /* VBOX_WITH_RESOURCE_USAGE_API */
+
+    /*
+     * Unload the cryptographic module if loaded before the extension
+     * pack manager is torn down.
+     */
+    Assert(!m->cRefsCrypto);
+    if (m->hLdrModCrypto != NIL_RTLDRMOD)
+    {
+        m->pCryptoIf = NULL;
+
+        int vrc = RTLdrClose(m->hLdrModCrypto);
+        AssertRC(vrc);
+        m->hLdrModCrypto = NIL_RTLDRMOD;
+    }
+
+    RTCritSectDelete(&m->CritSectModCrypto);
+
+#ifdef VBOX_WITH_EXTPACK
+    if (m->ptrExtPackManager)
+    {
+        m->ptrExtPackManager->uninit();
+        unconst(m->ptrExtPackManager).setNull();
+    }
+#endif
+
+    LogFlowThisFunc(("Terminating the async event handler...\n"));
+    if (m->threadAsyncEvent != NIL_RTTHREAD)
+    {
+        /* signal to exit the event loop */
+        if (RT_SUCCESS(m->pAsyncEventQ->interruptEventQueueProcessing()))
+        {
+            /*
+             *  Wait for thread termination (only after we've successfully
+             *  interrupted the event queue processing!)
+             */
+            int vrc = RTThreadWait(m->threadAsyncEvent, 60000, NULL);
+            if (RT_FAILURE(vrc))
+                Log1WarningFunc(("RTThreadWait(%RTthrd) -> %Rrc\n", m->threadAsyncEvent, vrc));
+        }
+        else
+        {
+            AssertMsgFailed(("interruptEventQueueProcessing() failed\n"));
+            RTThreadWait(m->threadAsyncEvent, 0, NULL);
+        }
+
+        unconst(m->threadAsyncEvent) = NIL_RTTHREAD;
+        unconst(m->pAsyncEventQ) = NULL;
+    }
+
+    LogFlowThisFunc(("Releasing event source...\n"));
+    if (m->pEventSource)
+    {
+        // Must uninit the event source here, because it makes no sense that
+        // it survives longer than the base object. If someone gets an event
+        // with such an event source then that's life and it has to be dealt
+        // with appropriately on the API client side.
+        m->pEventSource->uninit();
+        unconst(m->pEventSource).setNull();
+    }
+
+    LogFlowThisFunc(("Terminating the client watcher...\n"));
+    if (m->pClientWatcher)
+    {
+        delete m->pClientWatcher;
+        unconst(m->pClientWatcher) = NULL;
+    }
+
+    delete m->pAutostartDb;
+#ifdef VBOX_WITH_MAIN_NLS
+    if (m->pVBoxTranslator)
+        m->pVBoxTranslator->release();
+#endif
+    // clean up our instance data
+    delete m;
+    m = NULL;
+
+    /* Unload hard disk plugin backends. */
+    VDShutdown();
+
+    LogFlowThisFuncLeave();
+    LogFlow(("===========================================================\n"));
+}
+
+// Wrapped IVirtualBox properties
+/////////////////////////////////////////////////////////////////////////////
+HRESULT VirtualBox::getVersion(com::Utf8Str &aVersion)
+{
+    aVersion = sVersion;
+    return S_OK;
+}
+
+HRESULT VirtualBox::getVersionNormalized(com::Utf8Str &aVersionNormalized)
+{
+    aVersionNormalized = sVersionNormalized;
+    return S_OK;
+}
+
+HRESULT VirtualBox::getRevision(ULONG *aRevision)
+{
+    *aRevision = sRevision;
+    return S_OK;
+}
+
+HRESULT VirtualBox::getPackageType(com::Utf8Str &aPackageType)
+{
+    aPackageType = sPackageType;
+    return S_OK;
+}
+
+HRESULT VirtualBox::getAPIVersion(com::Utf8Str &aAPIVersion)
+{
+    aAPIVersion = sAPIVersion;
+    return S_OK;
+}
+
+HRESULT VirtualBox::getAPIRevision(LONG64 *aAPIRevision)
+{
+    AssertCompile(VBOX_VERSION_MAJOR < 128 && VBOX_VERSION_MAJOR > 0);
+    AssertCompile((uint64_t)VBOX_VERSION_MINOR < 256);
+    uint64_t uRevision = ((uint64_t)VBOX_VERSION_MAJOR << 56)
+                       | ((uint64_t)VBOX_VERSION_MINOR << 48)
+                       | ((uint64_t)VBOX_VERSION_BUILD << 40);
+
+    /** @todo This needs to be the same in OSE and non-OSE, preferrably
+     *        only changing when actual API changes happens. */
+    uRevision |= 1;
+
+    *aAPIRevision = (LONG64)uRevision;
+
+    return S_OK;
+}
+
+HRESULT VirtualBox::getHomeFolder(com::Utf8Str &aHomeFolder)
+{
+    /* mHomeDir is const and doesn't need a lock */
+    aHomeFolder = m->strHomeDir;
+    return S_OK;
+}
+
+HRESULT VirtualBox::getSettingsFilePath(com::Utf8Str &aSettingsFilePath)
+{
+    /* mCfgFile.mName is const and doesn't need a lock */
+    aSettingsFilePath = m->strSettingsFilePath;
+    return S_OK;
+}
+
+HRESULT VirtualBox::getHost(ComPtr<IHost> &aHost)
+{
+    /* mHost is const, no need to lock */
+    m->pHost.queryInterfaceTo(aHost.asOutParam());
+    return S_OK;
+}
+
+HRESULT VirtualBox::getSystemProperties(ComPtr<ISystemProperties> &aSystemProperties)
+{
+    /* mSystemProperties is const, no need to lock */
+    m->pSystemProperties.queryInterfaceTo(aSystemProperties.asOutParam());
+    return S_OK;
+}
+
+HRESULT VirtualBox::getMachines(std::vector<ComPtr<IMachine> > &aMachines)
+{
+    AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+    aMachines.resize(m->allMachines.size());
+    size_t i = 0;
+    for (MachinesOList::const_iterator it= m->allMachines.begin();
+         it!= m->allMachines.end(); ++it, ++i)
+        (*it).queryInterfaceTo(aMachines[i].asOutParam());
+    return S_OK;
+}
+
+HRESULT VirtualBox::getMachineGroups(std::vector<com::Utf8Str> &aMachineGroups)
+{
+    std::list<com::Utf8Str> allGroups;
+
+    /* get copy of all machine references, to avoid holding the list lock */
+    MachinesOList::MyList allMachines;
+    {
+        AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+        allMachines = m->allMachines.getList();
+    }
+    for (MachinesOList::MyList::const_iterator it = allMachines.begin();
+         it != allMachines.end();
+         ++it)
+    {
+        const ComObjPtr<Machine> &pMachine = *it;
+        AutoCaller autoMachineCaller(pMachine);
+        if (FAILED(autoMachineCaller.hrc()))
+            continue;
+        AutoReadLock mlock(pMachine COMMA_LOCKVAL_SRC_POS);
+
+        if (pMachine->i_isAccessible())
+        {
+            const StringsList &thisGroups = pMachine->i_getGroups();
+            for (StringsList::const_iterator it2 = thisGroups.begin();
+                 it2 != thisGroups.end(); ++it2)
+                allGroups.push_back(*it2);
+        }
+    }
+
+    /* throw out any duplicates */
+    allGroups.sort();
+    allGroups.unique();
+    aMachineGroups.resize(allGroups.size());
+    size_t i = 0;
+    for (std::list<com::Utf8Str>::const_iterator it = allGroups.begin();
+         it != allGroups.end(); ++it, ++i)
+        aMachineGroups[i] = (*it);
+    return S_OK;
+}
+
+HRESULT VirtualBox::getHardDisks(std::vector<ComPtr<IMedium> > &aHardDisks)
+{
+    AutoReadLock al(m->allHardDisks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+    aHardDisks.resize(m->allHardDisks.size());
+    size_t i = 0;
+    for (MediaOList::const_iterator it = m->allHardDisks.begin();
+         it !=  m->allHardDisks.end(); ++it, ++i)
+        (*it).queryInterfaceTo(aHardDisks[i].asOutParam());
+    return S_OK;
+}
+
+HRESULT VirtualBox::getDVDImages(std::vector<ComPtr<IMedium> > &aDVDImages)
+{
+    AutoReadLock al(m->allDVDImages.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+    aDVDImages.resize(m->allDVDImages.size());
+    size_t i = 0;
+    for (MediaOList::const_iterator it = m->allDVDImages.begin();
+         it!= m->allDVDImages.end(); ++it, ++i)
+        (*it).queryInterfaceTo(aDVDImages[i].asOutParam());
+    return S_OK;
+}
+
+HRESULT VirtualBox::getFloppyImages(std::vector<ComPtr<IMedium> > &aFloppyImages)
+{
+    AutoReadLock al(m->allFloppyImages.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+    aFloppyImages.resize(m->allFloppyImages.size());
+    size_t i = 0;
+    for (MediaOList::const_iterator it = m->allFloppyImages.begin();
+         it != m->allFloppyImages.end(); ++it, ++i)
+        (*it).queryInterfaceTo(aFloppyImages[i].asOutParam());
+    return S_OK;
+}
+
+HRESULT VirtualBox::getProgressOperations(std::vector<ComPtr<IProgress> > &aProgressOperations)
+{
+    /* protect mProgressOperations */
+    AutoReadLock safeLock(m->mtxProgressOperations COMMA_LOCKVAL_SRC_POS);
+    ProgressMap pmap(m->mapProgressOperations);
+    /* Can release lock now. The following code works on a copy of the map. */
+    safeLock.release();
+    aProgressOperations.resize(pmap.size());
+    size_t i = 0;
+    for (ProgressMap::iterator it = pmap.begin(); it != pmap.end(); ++it, ++i)
+        it->second.queryInterfaceTo(aProgressOperations[i].asOutParam());
+    return S_OK;
+}
+
+HRESULT VirtualBox::getGuestOSTypes(std::vector<ComPtr<IGuestOSType> > &aGuestOSTypes)
+{
+    AutoReadLock al(m->allGuestOSTypes.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+    aGuestOSTypes.resize(m->allGuestOSTypes.size());
+    size_t i = 0;
+    for (GuestOSTypesOList::const_iterator it = m->allGuestOSTypes.begin();
+         it != m->allGuestOSTypes.end(); ++it, ++i)
+         (*it).queryInterfaceTo(aGuestOSTypes[i].asOutParam());
+    return S_OK;
+}
+
+HRESULT VirtualBox::getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders)
+{
+    NOREF(aSharedFolders);
+
+    return setError(E_NOTIMPL, tr("Not yet implemented"));
+}
+
+HRESULT VirtualBox::getPerformanceCollector(ComPtr<IPerformanceCollector> &aPerformanceCollector)
+{
+#ifdef VBOX_WITH_RESOURCE_USAGE_API
+    /* mPerformanceCollector is const, no need to lock */
+    m->pPerformanceCollector.queryInterfaceTo(aPerformanceCollector.asOutParam());
+
+    return S_OK;
+#else /* !VBOX_WITH_RESOURCE_USAGE_API */
+    NOREF(aPerformanceCollector);
+    ReturnComNotImplemented();
+#endif /* !VBOX_WITH_RESOURCE_USAGE_API */
+}
+
+HRESULT VirtualBox::getDHCPServers(std::vector<ComPtr<IDHCPServer> > &aDHCPServers)
+{
+    AutoReadLock al(m->allDHCPServers.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+    aDHCPServers.resize(m->allDHCPServers.size());
+    size_t i = 0;
+    for (DHCPServersOList::const_iterator it= m->allDHCPServers.begin();
+         it!= m->allDHCPServers.end(); ++it, ++i)
+         (*it).queryInterfaceTo(aDHCPServers[i].asOutParam());
+    return S_OK;
+}
+
+
+HRESULT VirtualBox::getNATNetworks(std::vector<ComPtr<INATNetwork> > &aNATNetworks)
+{
+#ifdef VBOX_WITH_NAT_SERVICE
+    AutoReadLock al(m->allNATNetworks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+    aNATNetworks.resize(m->allNATNetworks.size());
+    size_t i = 0;
+    for (NATNetworksOList::const_iterator it= m->allNATNetworks.begin();
+         it!= m->allNATNetworks.end(); ++it, ++i)
+         (*it).queryInterfaceTo(aNATNetworks[i].asOutParam());
+    return S_OK;
+#else
+    NOREF(aNATNetworks);
+    return E_NOTIMPL;
+#endif
+}
+
+HRESULT VirtualBox::getEventSource(ComPtr<IEventSource> &aEventSource)
+{
+    /* event source is const, no need to lock */
+    m->pEventSource.queryInterfaceTo(aEventSource.asOutParam());
+    return S_OK;
+}
+
+HRESULT VirtualBox::getExtensionPackManager(ComPtr<IExtPackManager> &aExtensionPackManager)
+{
+    HRESULT hrc = S_OK;
+#ifdef VBOX_WITH_EXTPACK
+    /* The extension pack manager is const, no need to lock. */
+    hrc = m->ptrExtPackManager.queryInterfaceTo(aExtensionPackManager.asOutParam());
+#else
+    hrc = E_NOTIMPL;
+    NOREF(aExtensionPackManager);
+#endif
+    return hrc;
+}
+
+/**
+ * Host Only Network
+ */
+HRESULT VirtualBox::createHostOnlyNetwork(const com::Utf8Str &aNetworkName,
+                                          ComPtr<IHostOnlyNetwork> &aNetwork)
+{
+#ifdef VBOX_WITH_VMNET
+    ComObjPtr<HostOnlyNetwork> HostOnlyNetwork;
+    HostOnlyNetwork.createObject();
+    HRESULT hrc = HostOnlyNetwork->init(this, aNetworkName);
+    if (FAILED(hrc)) return hrc;
+
+    m->allHostOnlyNetworks.addChild(HostOnlyNetwork);
+
+    {
+        AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
+        hrc = i_saveSettings();
+        vboxLock.release();
+
+        if (FAILED(hrc))
+            m->allHostOnlyNetworks.removeChild(HostOnlyNetwork);
+        else
+            HostOnlyNetwork.queryInterfaceTo(aNetwork.asOutParam());
+    }
+
+    return hrc;
+#else /* !VBOX_WITH_VMNET */
+    NOREF(aNetworkName);
+    NOREF(aNetwork);
+    return E_NOTIMPL;
+#endif /* !VBOX_WITH_VMNET */
+}
+
+HRESULT VirtualBox::findHostOnlyNetworkByName(const com::Utf8Str &aNetworkName,
+                                           ComPtr<IHostOnlyNetwork> &aNetwork)
+{
+#ifdef VBOX_WITH_VMNET
+    Bstr bstrNameToFind(aNetworkName);
+
+    AutoReadLock alock(m->allHostOnlyNetworks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    for (HostOnlyNetworksOList::const_iterator it = m->allHostOnlyNetworks.begin();
+         it != m->allHostOnlyNetworks.end();
+         ++it)
+    {
+        Bstr bstrHostOnlyNetworkName;
+        HRESULT hrc = (*it)->COMGETTER(NetworkName)(bstrHostOnlyNetworkName.asOutParam());
+        if (FAILED(hrc)) return hrc;
+
+        if (bstrHostOnlyNetworkName == bstrNameToFind)
+        {
+            it->queryInterfaceTo(aNetwork.asOutParam());
+            return S_OK;
+        }
+    }
+    return VBOX_E_OBJECT_NOT_FOUND;
+#else /* !VBOX_WITH_VMNET */
+    NOREF(aNetworkName);
+    NOREF(aNetwork);
+    return E_NOTIMPL;
+#endif /* !VBOX_WITH_VMNET */
+}
+
+HRESULT VirtualBox::findHostOnlyNetworkById(const com::Guid &aId,
+                                           ComPtr<IHostOnlyNetwork> &aNetwork)
+{
+#ifdef VBOX_WITH_VMNET
+    ComObjPtr<HostOnlyNetwork> network;
+    AutoReadLock alock(m->allHostOnlyNetworks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    for (HostOnlyNetworksOList::const_iterator it = m->allHostOnlyNetworks.begin();
+         it != m->allHostOnlyNetworks.end();
+         ++it)
+    {
+        Bstr bstrHostOnlyNetworkId;
+        HRESULT hrc = (*it)->COMGETTER(Id)(bstrHostOnlyNetworkId.asOutParam());
+        if (FAILED(hrc)) return hrc;
+
+        if (Guid(bstrHostOnlyNetworkId) == aId)
+        {
+            it->queryInterfaceTo(aNetwork.asOutParam());;
+            return S_OK;
+        }
+    }
+    return VBOX_E_OBJECT_NOT_FOUND;
+#else /* !VBOX_WITH_VMNET */
+    NOREF(aId);
+    NOREF(aNetwork);
+    return E_NOTIMPL;
+#endif /* !VBOX_WITH_VMNET */
+}
+
+HRESULT VirtualBox::removeHostOnlyNetwork(const ComPtr<IHostOnlyNetwork> &aNetwork)
+{
+#ifdef VBOX_WITH_VMNET
+    Bstr name;
+    HRESULT hrc = aNetwork->COMGETTER(NetworkName)(name.asOutParam());
+    if (FAILED(hrc))
+        return hrc;
+    IHostOnlyNetwork *p = aNetwork;
+    HostOnlyNetwork *network = static_cast<HostOnlyNetwork *>(p);
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    AutoCaller HostOnlyNetworkCaller(network);
+    AssertComRCReturnRC(HostOnlyNetworkCaller.hrc());
+
+    m->allHostOnlyNetworks.removeChild(network);
+
+    {
+        AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
+        hrc = i_saveSettings();
+        vboxLock.release();
+
+        if (FAILED(hrc))
+            m->allHostOnlyNetworks.addChild(network);
+    }
+    return hrc;
+#else /* !VBOX_WITH_VMNET */
+    NOREF(aNetwork);
+    return E_NOTIMPL;
+#endif /* !VBOX_WITH_VMNET */
+}
+
+HRESULT VirtualBox::getHostOnlyNetworks(std::vector<ComPtr<IHostOnlyNetwork> > &aHostOnlyNetworks)
+{
+#ifdef VBOX_WITH_VMNET
+    AutoReadLock al(m->allHostOnlyNetworks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+    aHostOnlyNetworks.resize(m->allHostOnlyNetworks.size());
+    size_t i = 0;
+    for (HostOnlyNetworksOList::const_iterator it = m->allHostOnlyNetworks.begin();
+         it != m->allHostOnlyNetworks.end(); ++it)
+         (*it).queryInterfaceTo(aHostOnlyNetworks[i++].asOutParam());
+    return S_OK;
+#else /* !VBOX_WITH_VMNET */
+    NOREF(aHostOnlyNetworks);
+    return E_NOTIMPL;
+#endif /* !VBOX_WITH_VMNET */
+}
+
+
+HRESULT VirtualBox::getInternalNetworks(std::vector<com::Utf8Str> &aInternalNetworks)
+{
+    std::list<com::Utf8Str> allInternalNetworks;
+
+    /* get copy of all machine references, to avoid holding the list lock */
+    MachinesOList::MyList allMachines;
+    {
+        AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+        allMachines = m->allMachines.getList();
+    }
+    for (MachinesOList::MyList::const_iterator it = allMachines.begin();
+         it != allMachines.end(); ++it)
+    {
+        const ComObjPtr<Machine> &pMachine = *it;
+        AutoCaller autoMachineCaller(pMachine);
+        if (FAILED(autoMachineCaller.hrc()))
+            continue;
+        AutoReadLock mlock(pMachine COMMA_LOCKVAL_SRC_POS);
+
+        if (pMachine->i_isAccessible())
+        {
+            uint32_t cNetworkAdapters = Global::getMaxNetworkAdapters(pMachine->i_getChipsetType());
+            for (ULONG i = 0; i < cNetworkAdapters; i++)
+            {
+                ComPtr<INetworkAdapter> pNet;
+                HRESULT hrc = pMachine->GetNetworkAdapter(i, pNet.asOutParam());
+                if (FAILED(hrc) || pNet.isNull())
+                    continue;
+                Bstr strInternalNetwork;
+                hrc = pNet->COMGETTER(InternalNetwork)(strInternalNetwork.asOutParam());
+                if (FAILED(hrc) || strInternalNetwork.isEmpty())
+                    continue;
+
+                allInternalNetworks.push_back(Utf8Str(strInternalNetwork));
+            }
+        }
+    }
+
+    /* throw out any duplicates */
+    allInternalNetworks.sort();
+    allInternalNetworks.unique();
+    size_t i = 0;
+    aInternalNetworks.resize(allInternalNetworks.size());
+    for (std::list<com::Utf8Str>::const_iterator it = allInternalNetworks.begin();
+         it != allInternalNetworks.end();
+         ++it, ++i)
+        aInternalNetworks[i] = *it;
+    return S_OK;
+}
+
+HRESULT VirtualBox::getGenericNetworkDrivers(std::vector<com::Utf8Str> &aGenericNetworkDrivers)
+{
+    std::list<com::Utf8Str> allGenericNetworkDrivers;
+
+    /* get copy of all machine references, to avoid holding the list lock */
+    MachinesOList::MyList allMachines;
+    {
+        AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+        allMachines = m->allMachines.getList();
+    }
+    for (MachinesOList::MyList::const_iterator it = allMachines.begin();
+         it != allMachines.end();
+         ++it)
+    {
+        const ComObjPtr<Machine> &pMachine = *it;
+        AutoCaller autoMachineCaller(pMachine);
+        if (FAILED(autoMachineCaller.hrc()))
+            continue;
+        AutoReadLock mlock(pMachine COMMA_LOCKVAL_SRC_POS);
+
+        if (pMachine->i_isAccessible())
+        {
+            uint32_t cNetworkAdapters = Global::getMaxNetworkAdapters(pMachine->i_getChipsetType());
+            for (ULONG i = 0; i < cNetworkAdapters; i++)
+            {
+                ComPtr<INetworkAdapter> pNet;
+                HRESULT hrc = pMachine->GetNetworkAdapter(i, pNet.asOutParam());
+                if (FAILED(hrc) || pNet.isNull())
+                    continue;
+                Bstr strGenericNetworkDriver;
+                hrc = pNet->COMGETTER(GenericDriver)(strGenericNetworkDriver.asOutParam());
+                if (FAILED(hrc) || strGenericNetworkDriver.isEmpty())
+                    continue;
+
+                allGenericNetworkDrivers.push_back(Utf8Str(strGenericNetworkDriver).c_str());
+            }
+        }
+    }
+
+    /* throw out any duplicates */
+    allGenericNetworkDrivers.sort();
+    allGenericNetworkDrivers.unique();
+    aGenericNetworkDrivers.resize(allGenericNetworkDrivers.size());
+    size_t i = 0;
+    for (std::list<com::Utf8Str>::const_iterator it = allGenericNetworkDrivers.begin();
+         it != allGenericNetworkDrivers.end(); ++it, ++i)
+        aGenericNetworkDrivers[i] = *it;
+
+    return S_OK;
+}
+
+/**
+ * Cloud Network
+ */
+#ifdef VBOX_WITH_CLOUD_NET
+HRESULT VirtualBox::i_findCloudNetworkByName(const com::Utf8Str &aNetworkName,
+                                             ComObjPtr<CloudNetwork> *aNetwork)
+{
+    ComPtr<CloudNetwork> found;
+    Bstr bstrNameToFind(aNetworkName);
+
+    AutoReadLock alock(m->allCloudNetworks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    for (CloudNetworksOList::const_iterator it = m->allCloudNetworks.begin();
+         it != m->allCloudNetworks.end();
+         ++it)
+    {
+        Bstr bstrCloudNetworkName;
+        HRESULT hrc = (*it)->COMGETTER(NetworkName)(bstrCloudNetworkName.asOutParam());
+        if (FAILED(hrc)) return hrc;
+
+        if (bstrCloudNetworkName == bstrNameToFind)
+        {
+            *aNetwork = *it;
+            return S_OK;
+        }
+    }
+    return VBOX_E_OBJECT_NOT_FOUND;
+}
+#endif /* VBOX_WITH_CLOUD_NET */
+
+HRESULT VirtualBox::createCloudNetwork(const com::Utf8Str &aNetworkName,
+                                       ComPtr<ICloudNetwork> &aNetwork)
+{
+#ifdef VBOX_WITH_CLOUD_NET
+    ComObjPtr<CloudNetwork> cloudNetwork;
+    cloudNetwork.createObject();
+    HRESULT hrc = cloudNetwork->init(this, aNetworkName);
+    if (FAILED(hrc)) return hrc;
+
+    m->allCloudNetworks.addChild(cloudNetwork);
+
+    {
+        AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
+        hrc = i_saveSettings();
+        vboxLock.release();
+
+        if (FAILED(hrc))
+            m->allCloudNetworks.removeChild(cloudNetwork);
+        else
+            cloudNetwork.queryInterfaceTo(aNetwork.asOutParam());
+    }
+
+    return hrc;
+#else /* !VBOX_WITH_CLOUD_NET */
+    NOREF(aNetworkName);
+    NOREF(aNetwork);
+    return E_NOTIMPL;
+#endif /* !VBOX_WITH_CLOUD_NET */
+}
+
+HRESULT VirtualBox::findCloudNetworkByName(const com::Utf8Str &aNetworkName,
+                                           ComPtr<ICloudNetwork> &aNetwork)
+{
+#ifdef VBOX_WITH_CLOUD_NET
+    ComObjPtr<CloudNetwork> network;
+    HRESULT hrc = i_findCloudNetworkByName(aNetworkName, &network);
+    if (SUCCEEDED(hrc))
+        network.queryInterfaceTo(aNetwork.asOutParam());
+    return hrc;
+#else /* !VBOX_WITH_CLOUD_NET */
+    NOREF(aNetworkName);
+    NOREF(aNetwork);
+    return E_NOTIMPL;
+#endif /* !VBOX_WITH_CLOUD_NET */
+}
+
+HRESULT VirtualBox::removeCloudNetwork(const ComPtr<ICloudNetwork> &aNetwork)
+{
+#ifdef VBOX_WITH_CLOUD_NET
+    Bstr name;
+    HRESULT hrc = aNetwork->COMGETTER(NetworkName)(name.asOutParam());
+    if (FAILED(hrc))
+        return hrc;
+    ICloudNetwork *p = aNetwork;
+    CloudNetwork *network = static_cast<CloudNetwork *>(p);
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    AutoCaller cloudNetworkCaller(network);
+    AssertComRCReturnRC(cloudNetworkCaller.hrc());
+
+    m->allCloudNetworks.removeChild(network);
+
+    {
+        AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
+        hrc = i_saveSettings();
+        vboxLock.release();
+
+        if (FAILED(hrc))
+            m->allCloudNetworks.addChild(network);
+    }
+    return hrc;
+#else /* !VBOX_WITH_CLOUD_NET */
+    NOREF(aNetwork);
+    return E_NOTIMPL;
+#endif /* !VBOX_WITH_CLOUD_NET */
+}
+
+HRESULT VirtualBox::getCloudNetworks(std::vector<ComPtr<ICloudNetwork> > &aCloudNetworks)
+{
+#ifdef VBOX_WITH_CLOUD_NET
+    AutoReadLock al(m->allCloudNetworks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+    aCloudNetworks.resize(m->allCloudNetworks.size());
+    size_t i = 0;
+    for (CloudNetworksOList::const_iterator it = m->allCloudNetworks.begin();
+         it != m->allCloudNetworks.end(); ++it)
+         (*it).queryInterfaceTo(aCloudNetworks[i++].asOutParam());
+    return S_OK;
+#else /* !VBOX_WITH_CLOUD_NET */
+    NOREF(aCloudNetworks);
+    return E_NOTIMPL;
+#endif /* !VBOX_WITH_CLOUD_NET */
+}
+
+#ifdef VBOX_WITH_CLOUD_NET
+HRESULT VirtualBox::i_getEventSource(ComPtr<IEventSource>& aSource)
+{
+    m->pEventSource.queryInterfaceTo(aSource.asOutParam());
+    return S_OK;
+}
+#endif /* VBOX_WITH_CLOUD_NET */
+
+HRESULT VirtualBox::getCloudProviderManager(ComPtr<ICloudProviderManager> &aCloudProviderManager)
+{
+    HRESULT hrc = m->pCloudProviderManager.queryInterfaceTo(aCloudProviderManager.asOutParam());
+    return hrc;
+}
+
+HRESULT VirtualBox::checkFirmwarePresent(FirmwareType_T aFirmwareType,
+                                         const com::Utf8Str &aVersion,
+                                         com::Utf8Str &aUrl,
+                                         com::Utf8Str &aFile,
+                                         BOOL *aResult)
+{
+    NOREF(aVersion);
+
+    static const struct
+    {
+        FirmwareType_T  enmType;
+        bool            fBuiltIn;
+        const char     *pszFileName;
+        const char     *pszUrl;
+    }
+    firmwareDesc[] =
+    {
+        {   FirmwareType_BIOS,    true,  NULL,             NULL },
+#ifdef VBOX_WITH_EFI_IN_DD2
+        {   FirmwareType_EFI32,   true,  "VBoxEFI32.fd",   NULL },
+        {   FirmwareType_EFI64,   true,  "VBoxEFI64.fd",   NULL },
+        {   FirmwareType_EFIDUAL, true,  "VBoxEFIDual.fd", NULL },
+#else
+        {   FirmwareType_EFI32,   false, "VBoxEFI32.fd",   "http://virtualbox.org/firmware/VBoxEFI32.fd" },
+        {   FirmwareType_EFI64,   false, "VBoxEFI64.fd",   "http://virtualbox.org/firmware/VBoxEFI64.fd" },
+        {   FirmwareType_EFIDUAL, false, "VBoxEFIDual.fd", "http://virtualbox.org/firmware/VBoxEFIDual.fd" },
+#endif
+    };
+
+    for (size_t i = 0; i < sizeof(firmwareDesc) / sizeof(firmwareDesc[0]); i++)
+    {
+        if (aFirmwareType != firmwareDesc[i].enmType)
+            continue;
+
+        /* compiled-in firmware */
+        if (firmwareDesc[i].fBuiltIn)
+        {
+            aFile = firmwareDesc[i].pszFileName;
+            *aResult = TRUE;
+            break;
+        }
+
+        Utf8Str    fullName;
+        Utf8StrFmt shortName("Firmware%c%s", RTPATH_DELIMITER, firmwareDesc[i].pszFileName);
+        int vrc = i_calculateFullPath(shortName, fullName);
+        AssertRCReturn(vrc, VBOX_E_IPRT_ERROR);
+        if (RTFileExists(fullName.c_str()))
+        {
+            *aResult = TRUE;
+            aFile = fullName;
+            break;
+        }
+
+        char szVBoxPath[RTPATH_MAX];
+        vrc = RTPathExecDir(szVBoxPath, RTPATH_MAX);
+        AssertRCReturn(vrc, VBOX_E_IPRT_ERROR);
+        vrc = RTPathAppend(szVBoxPath, sizeof(szVBoxPath), firmwareDesc[i].pszFileName);
+        AssertRCReturn(vrc, VBOX_E_IPRT_ERROR);
+        if (RTFileExists(szVBoxPath))
+        {
+            *aResult = TRUE;
+            aFile = szVBoxPath;
+            break;
+        }
+
+        /** @todo account for version in the URL */
+        aUrl = firmwareDesc[i].pszUrl;
+        *aResult = FALSE;
+
+        /* Assume single record per firmware type */
+        break;
+    }
+
+    return S_OK;
+}
+// Wrapped IVirtualBox methods
+/////////////////////////////////////////////////////////////////////////////
+
+/* Helper for VirtualBox::ComposeMachineFilename */
+static void sanitiseMachineFilename(Utf8Str &aName);
+
+HRESULT VirtualBox::composeMachineFilename(const com::Utf8Str &aName,
+                                           const com::Utf8Str &aGroup,
+                                           const com::Utf8Str &aCreateFlags,
+                                           const com::Utf8Str &aBaseFolder,
+                                           com::Utf8Str       &aFile)
+{
+    if (RT_UNLIKELY(aName.isEmpty()))
+        return setError(E_INVALIDARG, tr("Machine name is invalid, must not be empty"));
+
+    Utf8Str strBase = aBaseFolder;
+    Utf8Str strName = aName;
+
+    LogFlowThisFunc(("aName=\"%s\",aBaseFolder=\"%s\"\n", strName.c_str(), strBase.c_str()));
+
+    com::Guid id;
+    bool fDirectoryIncludesUUID = false;
+    if (!aCreateFlags.isEmpty())
+    {
+        size_t uPos = 0;
+        com::Utf8Str strKey;
+        com::Utf8Str strValue;
+        while ((uPos = aCreateFlags.parseKeyValue(strKey, strValue, uPos)) != com::Utf8Str::npos)
+        {
+            if (strKey == "UUID")
+                id = strValue.c_str();
+            else if (strKey == "directoryIncludesUUID")
+                fDirectoryIncludesUUID = (strValue == "1");
+        }
+    }
+
+    if (id.isZero())
+        fDirectoryIncludesUUID = false;
+    else if (!id.isValid())
+    {
+        /* do something else */
+        return setError(E_INVALIDARG,
+                 tr("'%s' is not a valid Guid"),
+                 id.toStringCurly().c_str());
+    }
+
+    Utf8Str strGroup(aGroup);
+    if (strGroup.isEmpty())
+        strGroup = "/";
+    HRESULT hrc = i_validateMachineGroup(strGroup, true);
+    if (FAILED(hrc))
+        return hrc;
+
+    /* Compose the settings file name using the following scheme:
+     *
+     *     <base_folder><group>/<machine_name>/<machine_name>.xml
+     *
+     * If a non-null and non-empty base folder is specified, the default
+     * machine folder will be used as a base folder.
+     * We sanitise the machine name to a safe white list of characters before
+     * using it.
+     */
+    Utf8Str strDirName(strName);
+    if (fDirectoryIncludesUUID)
+        strDirName += Utf8StrFmt(" (%RTuuid)", id.raw());
+    sanitiseMachineFilename(strName);
+    sanitiseMachineFilename(strDirName);
+
+    if (strBase.isEmpty())
+        /* we use the non-full folder value below to keep the path relative */
+        i_getDefaultMachineFolder(strBase);
+
+    i_calculateFullPath(strBase, strBase);
+
+    /* eliminate toplevel group to avoid // in the result */
+    if (strGroup == "/")
+        strGroup.setNull();
+    aFile = com::Utf8StrFmt("%s%s%c%s%c%s.vbox",
+                            strBase.c_str(),
+                            strGroup.c_str(),
+                            RTPATH_DELIMITER,
+                            strDirName.c_str(),
+                            RTPATH_DELIMITER,
+                            strName.c_str());
+    return S_OK;
+}
+
+/**
+ * Remove characters from a machine file name which can be problematic on
+ * particular systems.
+ * @param  strName  The file name to sanitise.
+ */
+void sanitiseMachineFilename(Utf8Str &strName)
+{
+    if (strName.isEmpty())
+        return;
+
+    /* Set of characters which should be safe for use in filenames: some basic
+     * ASCII, Unicode from Latin-1 alphabetic to the end of Hangul.  We try to
+     * skip anything that could count as a control character in Windows or
+     * *nix, or be otherwise difficult for shells to handle (I would have
+     * preferred to remove the space and brackets too).  We also remove all
+     * characters which need UTF-16 surrogate pairs for Windows's benefit.
+     */
+    static RTUNICP const s_uszValidRangePairs[] =
+    {
+        ' ', ' ',
+        '(', ')',
+        '-', '.',
+        '0', '9',
+        'A', 'Z',
+        'a', 'z',
+        '_', '_',
+        0xa0, 0xd7af,
+        '\0'
+    };
+
+    char *pszName = strName.mutableRaw();
+    ssize_t cReplacements = RTStrPurgeComplementSet(pszName, s_uszValidRangePairs, '_');
+    Assert(cReplacements >= 0);
+    NOREF(cReplacements);
+
+    /* No leading dot or dash. */
+    if (pszName[0] == '.' || pszName[0] == '-')
+        pszName[0] = '_';
+
+    /* No trailing dot. */
+    if (pszName[strName.length() - 1] == '.')
+        pszName[strName.length() - 1] = '_';
+
+    /* Mangle leading and trailing spaces. */
+    for (size_t i = 0; pszName[i] == ' '; ++i)
+        pszName[i] = '_';
+    for (size_t i = strName.length() - 1; i && pszName[i] == ' '; --i)
+        pszName[i] = '_';
+}
+
+#ifdef DEBUG
+typedef DECLCALLBACKTYPE(void, FNTESTPRINTF,(const char *, ...));
+/** Simple unit test/operation examples for sanitiseMachineFilename(). */
+static unsigned testSanitiseMachineFilename(FNTESTPRINTF *pfnPrintf)
+{
+    unsigned cErrors = 0;
+
+    /** Expected results of sanitising given file names. */
+    static struct
+    {
+        /** The test file name to be sanitised (Utf-8). */
+        const char *pcszIn;
+        /** The expected sanitised output (Utf-8). */
+        const char *pcszOutExpected;
+    } aTest[] =
+    {
+        { "OS/2 2.1", "OS_2 2.1" },
+        { "-!My VM!-", "__My VM_-" },
+        { "\xF0\x90\x8C\xB0", "____" },
+        { "  My VM  ", "__My VM__" },
+        { ".My VM.", "_My VM_" },
+        { "My VM", "My VM" }
+    };
+    for (unsigned i = 0; i < RT_ELEMENTS(aTest); ++i)
+    {
+        Utf8Str str(aTest[i].pcszIn);
+        sanitiseMachineFilename(str);
+        if (str.compare(aTest[i].pcszOutExpected))
+        {
+            ++cErrors;
+            pfnPrintf("%s: line %d, expected %s, actual %s\n",
+                      __PRETTY_FUNCTION__, i, aTest[i].pcszOutExpected,
+                      str.c_str());
+        }
+    }
+    return cErrors;
+}
+
+/** @todo Proper testcase. */
+/** @todo Do we have a better method of doing init functions? */
+namespace
+{
+    class TestSanitiseMachineFilename
+    {
+    public:
+        TestSanitiseMachineFilename(void)
+        {
+            Assert(!testSanitiseMachineFilename(RTAssertMsg2));
+        }
+    };
+    TestSanitiseMachineFilename s_TestSanitiseMachineFilename;
+}
+#endif
+
+/** @note Locks mSystemProperties object for reading. */
+HRESULT VirtualBox::createMachine(const com::Utf8Str &aSettingsFile,
+                                  const com::Utf8Str &aName,
+                                  const std::vector<com::Utf8Str> &aGroups,
+                                  const com::Utf8Str &aOsTypeId,
+                                  const com::Utf8Str &aFlags,
+                                  const com::Utf8Str &aCipher,
+                                  const com::Utf8Str &aPasswordId,
+                                  const com::Utf8Str &aPassword,
+                                  ComPtr<IMachine> &aMachine)
+{
+    LogFlowThisFuncEnter();
+    LogFlowThisFunc(("aSettingsFile=\"%s\", aName=\"%s\", aOsTypeId =\"%s\", aCreateFlags=\"%s\"\n",
+                     aSettingsFile.c_str(), aName.c_str(), aOsTypeId.c_str(), aFlags.c_str()));
+
+    StringsList llGroups;
+    HRESULT hrc = i_convertMachineGroups(aGroups, &llGroups);
+    if (FAILED(hrc))
+        return hrc;
+
+    /** @todo r=bird: Would be goot to rewrite this parsing using offset into
+     *        aFlags and drop all the C pointers, strchr, misguided RTStrStr and
+     *        tedious copying of substrings. */
+    Utf8Str strCreateFlags(aFlags); /** @todo r=bird: WTF is the point of this copy? */
+    Guid id;
+    bool fForceOverwrite = false;
+    bool fDirectoryIncludesUUID = false;
+    if (!strCreateFlags.isEmpty())
+    {
+        const char *pcszNext = strCreateFlags.c_str();
+        while (*pcszNext != '\0')
+        {
+            Utf8Str strFlag;
+            const char *pcszComma = strchr(pcszNext, ','); /*clueless version: RTStrStr(pcszNext, ","); */
+            if (!pcszComma)
+                strFlag = pcszNext;
+            else
+                strFlag.assign(pcszNext, (size_t)(pcszComma - pcszNext));
+
+            const char *pcszEqual = strchr(strFlag.c_str(), '='); /* more cluelessness: RTStrStr(strFlag.c_str(), "="); */
+            /* skip over everything which doesn't contain '=' */
+            if (pcszEqual && pcszEqual != strFlag.c_str())
+            {
+                Utf8Str strKey(strFlag.c_str(), (size_t)(pcszEqual - strFlag.c_str()));
+                Utf8Str strValue(strFlag.c_str() + (pcszEqual - strFlag.c_str() + 1));
+
+                if (strKey == "UUID")
+                    id = strValue.c_str();
+                else if (strKey == "forceOverwrite")
+                    fForceOverwrite = (strValue == "1");
+                else if (strKey == "directoryIncludesUUID")
+                    fDirectoryIncludesUUID = (strValue == "1");
+            }
+
+            if (!pcszComma)
+                pcszNext += strFlag.length();  /* you can just 'break' out here... */
+            else
+                pcszNext += strFlag.length() + 1;
+        }
+    }
+
+    /* Create UUID if none was specified. */
+    if (id.isZero())
+        id.create();
+    else if (!id.isValid())
+    {
+        /* do something else */
+        return setError(E_INVALIDARG, tr("'%s' is not a valid Guid"), id.toStringCurly().c_str());
+    }
+
+    /* NULL settings file means compose automatically */
+    Utf8Str strSettingsFile(aSettingsFile);
+    if (strSettingsFile.isEmpty())
+    {
+        Utf8Str strNewCreateFlags(Utf8StrFmt("UUID=%RTuuid", id.raw()));
+        if (fDirectoryIncludesUUID)
+            strNewCreateFlags += ",directoryIncludesUUID=1";
+
+        com::Utf8Str blstr;
+        hrc = composeMachineFilename(aName,
+                                     llGroups.front(),
+                                     strNewCreateFlags,
+                                     blstr /* aBaseFolder */,
+                                     strSettingsFile);
+        if (FAILED(hrc)) return hrc;
+    }
+
+    /* create a new object */
+    ComObjPtr<Machine> machine;
+    hrc = machine.createObject();
+    if (FAILED(hrc)) return hrc;
+
+    ComObjPtr<GuestOSType> osType;
+    if (!aOsTypeId.isEmpty())
+        i_findGuestOSType(aOsTypeId, osType);
+
+    /* initialize the machine object */
+    hrc = machine->init(this,
+                        strSettingsFile,
+                        aName,
+                        llGroups,
+                        aOsTypeId,
+                        osType,
+                        id,
+                        fForceOverwrite,
+                        fDirectoryIncludesUUID,
+                        aCipher,
+                        aPasswordId,
+                        aPassword);
+    if (SUCCEEDED(hrc))
+    {
+        /* set the return value */
+        machine.queryInterfaceTo(aMachine.asOutParam());
+        AssertComRC(hrc);
+
+#ifdef VBOX_WITH_EXTPACK
+        /* call the extension pack hooks */
+        m->ptrExtPackManager->i_callAllVmCreatedHooks(machine);
+#endif
+    }
+
+    LogFlowThisFuncLeave();
+
+    return hrc;
+}
+
+HRESULT VirtualBox::openMachine(const com::Utf8Str &aSettingsFile,
+                                const com::Utf8Str &aPassword,
+                                ComPtr<IMachine> &aMachine)
+{
+    /* create a new object */
+    ComObjPtr<Machine> machine;
+    HRESULT hrc = machine.createObject();
+    if (SUCCEEDED(hrc))
+    {
+        /* initialize the machine object */
+        hrc = machine->initFromSettings(this, aSettingsFile, NULL /* const Guid *aId */, aPassword);
+        if (SUCCEEDED(hrc))
+        {
+            /* set the return value */
+            machine.queryInterfaceTo(aMachine.asOutParam());
+            ComAssertComRC(hrc);
+        }
+    }
+
+    return hrc;
+}
+
+/** @note Locks objects! */
+HRESULT VirtualBox::registerMachine(const ComPtr<IMachine> &aMachine)
+{
+    Bstr name;
+    HRESULT hrc = aMachine->COMGETTER(Name)(name.asOutParam());
+    if (FAILED(hrc)) return hrc;
+
+    /* We can safely cast child to Machine * here because only Machine
+     * implementations of IMachine can be among our children. */
+    IMachine *aM = aMachine;
+    Machine *pMachine = static_cast<Machine*>(aM);
+
+    AutoCaller machCaller(pMachine);
+    ComAssertComRCRetRC(machCaller.hrc());
+
+    hrc = i_registerMachine(pMachine);
+    /* fire an event */
+    if (SUCCEEDED(hrc))
+        i_onMachineRegistered(pMachine->i_getId(), TRUE);
+
+    return hrc;
+}
+
+/** @note Locks this object for reading, then some machine objects for reading. */
+HRESULT VirtualBox::findMachine(const com::Utf8Str &aSettingsFile,
+                                ComPtr<IMachine> &aMachine)
+{
+    LogFlowThisFuncEnter();
+    LogFlowThisFunc(("aSettingsFile=\"%s\", aMachine={%p}\n", aSettingsFile.c_str(), &aMachine));
+
+    /* start with not found */
+    HRESULT hrc = S_OK;
+    ComObjPtr<Machine> pMachineFound;
+
+    Guid id(aSettingsFile);
+    Utf8Str strFile(aSettingsFile);
+    if (id.isValid() && !id.isZero())
+        hrc = i_findMachine(id,
+                            true /* fPermitInaccessible */,
+                            true /* setError */,
+                            &pMachineFound);
+        // returns VBOX_E_OBJECT_NOT_FOUND if not found and sets error
+    else
+    {
+        hrc = i_findMachineByName(strFile,
+                                  true /* setError */,
+                                  &pMachineFound);
+        // returns VBOX_E_OBJECT_NOT_FOUND if not found and sets error
+    }
+
+    /* this will set (*machine) to NULL if machineObj is null */
+    pMachineFound.queryInterfaceTo(aMachine.asOutParam());
+
+    LogFlowThisFunc(("aName=\"%s\", aMachine=%p, hrc=%08X\n", aSettingsFile.c_str(), &aMachine, hrc));
+    LogFlowThisFuncLeave();
+
+    return hrc;
+}
+
+HRESULT VirtualBox::getMachinesByGroups(const std::vector<com::Utf8Str> &aGroups,
+                                        std::vector<ComPtr<IMachine> > &aMachines)
+{
+    StringsList llGroups;
+    HRESULT hrc = i_convertMachineGroups(aGroups, &llGroups);
+    if (FAILED(hrc))
+        return hrc;
+
+    /* we want to rely on sorted groups during compare, to save time */
+    llGroups.sort();
+
+    /* get copy of all machine references, to avoid holding the list lock */
+    MachinesOList::MyList allMachines;
+    AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+    allMachines = m->allMachines.getList();
+
+    std::vector<ComObjPtr<IMachine> > saMachines;
+    saMachines.resize(0);
+    for (MachinesOList::MyList::const_iterator it = allMachines.begin();
+         it != allMachines.end();
+         ++it)
+    {
+        const ComObjPtr<Machine> &pMachine = *it;
+        AutoCaller autoMachineCaller(pMachine);
+        if (FAILED(autoMachineCaller.hrc()))
+            continue;
+        AutoReadLock mlock(pMachine COMMA_LOCKVAL_SRC_POS);
+
+        if (pMachine->i_isAccessible())
+        {
+            const StringsList &thisGroups = pMachine->i_getGroups();
+            for (StringsList::const_iterator it2 = thisGroups.begin();
+                 it2 != thisGroups.end();
+                 ++it2)
+            {
+                const Utf8Str &group = *it2;
+                bool fAppended = false;
+                for (StringsList::const_iterator it3 = llGroups.begin();
+                     it3 != llGroups.end();
+                     ++it3)
+                {
+                    int order = it3->compare(group);
+                    if (order == 0)
+                    {
+                        saMachines.push_back(static_cast<IMachine *>(pMachine));
+                        fAppended = true;
+                        break;
+                    }
+                    else if (order > 0)
+                        break;
+                    else
+                        continue;
+                }
+                /* avoid duplicates and save time */
+                if (fAppended)
+                    break;
+            }
+        }
+    }
+    aMachines.resize(saMachines.size());
+    size_t i = 0;
+    for(i = 0; i < saMachines.size(); ++i)
+        saMachines[i].queryInterfaceTo(aMachines[i].asOutParam());
+
+    return S_OK;
+}
+
+HRESULT VirtualBox::getMachineStates(const std::vector<ComPtr<IMachine> > &aMachines,
+                                     std::vector<MachineState_T> &aStates)
+{
+    com::SafeIfaceArray<IMachine> saMachines(aMachines);
+    aStates.resize(aMachines.size());
+    for (size_t i = 0; i < saMachines.size(); i++)
+    {
+        ComPtr<IMachine> pMachine = saMachines[i];
+        MachineState_T state = MachineState_Null;
+        if (!pMachine.isNull())
+        {
+            HRESULT hrc = pMachine->COMGETTER(State)(&state);
+            if (hrc == E_ACCESSDENIED)
+                hrc = S_OK;
+            AssertComRC(hrc);
+        }
+        aStates[i] = state;
+    }
+    return S_OK;
+}
+
+HRESULT VirtualBox::createUnattendedInstaller(ComPtr<IUnattended> &aUnattended)
+{
+#ifdef VBOX_WITH_UNATTENDED
+    ComObjPtr<Unattended> ptrUnattended;
+    HRESULT hrc = ptrUnattended.createObject();
+    if (SUCCEEDED(hrc))
+    {
+        AutoReadLock wlock(this COMMA_LOCKVAL_SRC_POS);
+        hrc = ptrUnattended->initUnattended(this);
+        if (SUCCEEDED(hrc))
+            hrc = ptrUnattended.queryInterfaceTo(aUnattended.asOutParam());
+    }
+    return hrc;
+#else
+    NOREF(aUnattended);
+    return E_NOTIMPL;
+#endif
+}
+
+HRESULT VirtualBox::createMedium(const com::Utf8Str &aFormat,
+                                 const com::Utf8Str &aLocation,
+                                 AccessMode_T aAccessMode,
+                                 DeviceType_T aDeviceType,
+                                 ComPtr<IMedium> &aMedium)
+{
+    NOREF(aAccessMode); /**< @todo r=klaus make use of access mode */
+
+    HRESULT hrc = S_OK;
+
+    ComObjPtr<Medium> medium;
+    medium.createObject();
+    com::Utf8Str format = aFormat;
+
+    switch (aDeviceType)
+    {
+        case DeviceType_HardDisk:
+        {
+
+            /* we don't access non-const data members so no need to lock */
+            if (format.isEmpty())
+                i_getDefaultHardDiskFormat(format);
+
+            hrc = medium->init(this,
+                               format,
+                               aLocation,
+                               Guid::Empty /* media registry: none yet */,
+                               aDeviceType);
+        }
+        break;
+
+        case DeviceType_DVD:
+        case DeviceType_Floppy:
+        {
+
+            if (format.isEmpty())
+                return setError(E_INVALIDARG, tr("Format must be Valid Type%s"), format.c_str());
+
+            // enforce read-only for DVDs even if caller specified ReadWrite
+            if (aDeviceType == DeviceType_DVD)
+                aAccessMode = AccessMode_ReadOnly;
+
+             hrc = medium->init(this,
+                                format,
+                                aLocation,
+                                Guid::Empty /* media registry: none yet */,
+                                aDeviceType);
+
+         }
+         break;
+
+         default:
+             return setError(E_INVALIDARG, tr("Device type must be HardDisk, DVD or Floppy %d"), aDeviceType);
+    }
+
+    if (SUCCEEDED(hrc))
+    {
+        medium.queryInterfaceTo(aMedium.asOutParam());
+        com::Guid uMediumId = medium->i_getId();
+        if (uMediumId.isValid() && !uMediumId.isZero())
+            i_onMediumRegistered(uMediumId, medium->i_getDeviceType(), TRUE);
+    }
+
+    return hrc;
+}
+
+HRESULT VirtualBox::openMedium(const com::Utf8Str &aLocation,
+                               DeviceType_T aDeviceType,
+                               AccessMode_T aAccessMode,
+                               BOOL aForceNewUuid,
+                               ComPtr<IMedium> &aMedium)
+{
+    HRESULT hrc = S_OK;
+    Guid id(aLocation);
+    ComObjPtr<Medium> pMedium;
+
+    // have to get write lock as the whole find/update sequence must be done
+    // in one critical section, otherwise there are races which can lead to
+    // multiple Medium objects with the same content
+    AutoWriteLock treeLock(i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    // check if the device type is correct, and see if a medium for the
+    // given path has already initialized; if so, return that
+    switch (aDeviceType)
+    {
+        case DeviceType_HardDisk:
+            if (id.isValid() && !id.isZero())
+                hrc = i_findHardDiskById(id, false /* setError */, &pMedium);
+            else
+                hrc = i_findHardDiskByLocation(aLocation, false, /* aSetError */ &pMedium);
+        break;
+
+        case DeviceType_Floppy:
+        case DeviceType_DVD:
+            if (id.isValid() && !id.isZero())
+                hrc = i_findDVDOrFloppyImage(aDeviceType, &id, Utf8Str::Empty, false /* setError */, &pMedium);
+            else
+                hrc = i_findDVDOrFloppyImage(aDeviceType, NULL, aLocation, false /* setError */, &pMedium);
+
+            // enforce read-only for DVDs even if caller specified ReadWrite
+            if (aDeviceType == DeviceType_DVD)
+                aAccessMode = AccessMode_ReadOnly;
+        break;
+
+        default:
+            return setError(E_INVALIDARG, tr("Device type must be HardDisk, DVD or Floppy %d"), aDeviceType);
+    }
+
+    bool fMediumRegistered = false;
+    if (pMedium.isNull())
+    {
+        pMedium.createObject();
+        treeLock.release();
+        hrc = pMedium->init(this,
+                            aLocation,
+                            (aAccessMode == AccessMode_ReadWrite) ? Medium::OpenReadWrite : Medium::OpenReadOnly,
+                            !!aForceNewUuid,
+                            aDeviceType);
+        treeLock.acquire();
+
+        if (SUCCEEDED(hrc))
+        {
+            hrc = i_registerMedium(pMedium, &pMedium, treeLock);
+
+            treeLock.release();
+
+            /* Note that it's important to call uninit() on failure to register
+             * because the differencing hard disk would have been already associated
+             * with the parent and this association needs to be broken. */
+
+            if (FAILED(hrc))
+            {
+                pMedium->uninit();
+                hrc = VBOX_E_OBJECT_NOT_FOUND;
+            }
+            else
+                fMediumRegistered = true;
+        }
+        else if (hrc != VBOX_E_INVALID_OBJECT_STATE)
+            hrc = VBOX_E_OBJECT_NOT_FOUND;
+    }
+
+    if (SUCCEEDED(hrc))
+    {
+        pMedium.queryInterfaceTo(aMedium.asOutParam());
+        if (fMediumRegistered)
+            i_onMediumRegistered(pMedium->i_getId(), pMedium->i_getDeviceType() ,TRUE);
+    }
+
+    return hrc;
+}
+
+
+/** @note Locks this object for reading. */
+HRESULT VirtualBox::getGuestOSType(const com::Utf8Str &aId,
+                                   ComPtr<IGuestOSType> &aType)
+{
+    ComObjPtr<GuestOSType> pType;
+    HRESULT hrc = i_findGuestOSType(aId, pType);
+    pType.queryInterfaceTo(aType.asOutParam());
+    return hrc;
+}
+
+HRESULT VirtualBox::createSharedFolder(const com::Utf8Str &aName,
+                                       const com::Utf8Str &aHostPath,
+                                       BOOL aWritable,
+                                       BOOL aAutomount,
+                                       const com::Utf8Str &aAutoMountPoint)
+{
+    NOREF(aName);
+    NOREF(aHostPath);
+    NOREF(aWritable);
+    NOREF(aAutomount);
+    NOREF(aAutoMountPoint);
+
+    return setError(E_NOTIMPL, tr("Not yet implemented"));
+}
+
+HRESULT VirtualBox::removeSharedFolder(const com::Utf8Str &aName)
+{
+    NOREF(aName);
+    return setError(E_NOTIMPL, tr("Not yet implemented"));
+}
+
+/**
+ *  @note Locks this object for reading.
+ */
+HRESULT VirtualBox::getExtraDataKeys(std::vector<com::Utf8Str> &aKeys)
+{
+    using namespace settings;
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    aKeys.resize(m->pMainConfigFile->mapExtraDataItems.size());
+    size_t i = 0;
+    for (StringsMap::const_iterator it = m->pMainConfigFile->mapExtraDataItems.begin();
+         it != m->pMainConfigFile->mapExtraDataItems.end(); ++it, ++i)
+        aKeys[i] = it->first;
+
+    return S_OK;
+}
+
+/**
+ *  @note Locks this object for reading.
+ */
+HRESULT VirtualBox::getExtraData(const com::Utf8Str &aKey,
+                                 com::Utf8Str &aValue)
+{
+    settings::StringsMap::const_iterator it = m->pMainConfigFile->mapExtraDataItems.find(aKey);
+    if (it != m->pMainConfigFile->mapExtraDataItems.end())
+        // found:
+        aValue = it->second; // source is a Utf8Str
+
+    /* return the result to caller (may be empty) */
+
+    return S_OK;
+}
+
+/**
+ *  @note Locks this object for writing.
+ */
+HRESULT VirtualBox::setExtraData(const com::Utf8Str &aKey,
+                                 const com::Utf8Str &aValue)
+{
+    Utf8Str strKey(aKey);
+    Utf8Str strValue(aValue);
+    Utf8Str strOldValue;            // empty
+    HRESULT hrc = S_OK;
+
+    /* Because control characters in aKey have caused problems in the settings
+     * they are rejected unless the key should be deleted. */
+    if (!strValue.isEmpty())
+    {
+        for (size_t i = 0; i < strKey.length(); ++i)
+        {
+            char ch = strKey[i];
+            if (RTLocCIsCntrl(ch))
+                return E_INVALIDARG;
+        }
+    }
+
+    // locking note: we only hold the read lock briefly to look up the old value,
+    // then release it and call the onExtraCanChange callbacks. There is a small
+    // chance of a race insofar as the callback might be called twice if two callers
+    // change the same key at the same time, but that's a much better solution
+    // than the deadlock we had here before. The actual changing of the extradata
+    // is then performed under the write lock and race-free.
+
+    // look up the old value first; if nothing has changed then we need not do anything
+    {
+        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); // hold read lock only while looking up
+        settings::StringsMap::const_iterator it = m->pMainConfigFile->mapExtraDataItems.find(strKey);
+        if (it != m->pMainConfigFile->mapExtraDataItems.end())
+            strOldValue = it->second;
+    }
+
+    bool fChanged;
+    if ((fChanged = (strOldValue != strValue)))
+    {
+        // ask for permission from all listeners outside the locks;
+        // onExtraDataCanChange() only briefly requests the VirtualBox
+        // lock to copy the list of callbacks to invoke
+        Bstr error;
+
+        if (!i_onExtraDataCanChange(Guid::Empty, Bstr(aKey).raw(), Bstr(aValue).raw(), error))
+        {
+            const char *sep = error.isEmpty() ? "" : ": ";
+            Log1WarningFunc(("Someone vetoed! Change refused%s%ls\n", sep, error.raw()));
+            return setError(E_ACCESSDENIED,
+                            tr("Could not set extra data because someone refused the requested change of '%s' to '%s'%s%ls"),
+                            strKey.c_str(),
+                            strValue.c_str(),
+                            sep,
+                            error.raw());
+        }
+
+        // data is changing and change not vetoed: then write it out under the lock
+
+        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+        if (strValue.isEmpty())
+            m->pMainConfigFile->mapExtraDataItems.erase(strKey);
+        else
+            m->pMainConfigFile->mapExtraDataItems[strKey] = strValue;
+                // creates a new key if needed
+
+        /* save settings on success */
+        hrc = i_saveSettings();
+        if (FAILED(hrc)) return hrc;
+    }
+
+    // fire notification outside the lock
+    if (fChanged)
+        i_onExtraDataChanged(Guid::Empty, Bstr(aKey).raw(), Bstr(aValue).raw());
+
+    return hrc;
+}
+
+/**
+ *
+ */
+HRESULT VirtualBox::setSettingsSecret(const com::Utf8Str &aPassword)
+{
+    i_storeSettingsKey(aPassword);
+    i_decryptSettings();
+    return S_OK;
+}
+
+int VirtualBox::i_decryptMediumSettings(Medium *pMedium)
+{
+    Bstr bstrCipher;
+    HRESULT hrc = pMedium->GetProperty(Bstr("InitiatorSecretEncrypted").raw(),
+                                       bstrCipher.asOutParam());
+    if (SUCCEEDED(hrc))
+    {
+        Utf8Str strPlaintext;
+        int vrc = i_decryptSetting(&strPlaintext, bstrCipher);
+        if (RT_SUCCESS(vrc))
+            pMedium->i_setPropertyDirect("InitiatorSecret", strPlaintext);
+        else
+            return vrc;
+    }
+    return VINF_SUCCESS;
+}
+
+/**
+ * Decrypt all encrypted settings.
+ *
+ * So far we only have encrypted iSCSI initiator secrets so we just go through
+ * all hard disk media and determine the plain 'InitiatorSecret' from
+ * 'InitiatorSecretEncrypted. The latter is stored as Base64 because medium
+ * properties need to be null-terminated strings.
+ */
+int VirtualBox::i_decryptSettings()
+{
+    bool fFailure = false;
+    AutoReadLock al(m->allHardDisks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+    for (MediaList::const_iterator mt = m->allHardDisks.begin();
+         mt != m->allHardDisks.end();
+         ++mt)
+    {
+        ComObjPtr<Medium> pMedium = *mt;
+        AutoCaller medCaller(pMedium);
+        if (FAILED(medCaller.hrc()))
+            continue;
+        AutoWriteLock mlock(pMedium COMMA_LOCKVAL_SRC_POS);
+        int vrc = i_decryptMediumSettings(pMedium);
+        if (RT_FAILURE(vrc))
+            fFailure = true;
+    }
+    if (!fFailure)
+    {
+        for (MediaList::const_iterator mt = m->allHardDisks.begin();
+             mt != m->allHardDisks.end();
+             ++mt)
+        {
+            i_onMediumConfigChanged(*mt);
+        }
+    }
+    return fFailure ? VERR_INVALID_PARAMETER : VINF_SUCCESS;
+}
+
+/**
+ * Encode.
+ *
+ * @param aPlaintext      plaintext to be encrypted
+ * @param aCiphertext     resulting ciphertext (base64-encoded)
+ */
+int VirtualBox::i_encryptSetting(const Utf8Str &aPlaintext, Utf8Str *aCiphertext)
+{
+    uint8_t abCiphertext[32];
+    char    szCipherBase64[128];
+    size_t  cchCipherBase64;
+    int vrc = i_encryptSettingBytes((uint8_t*)aPlaintext.c_str(), abCiphertext, aPlaintext.length()+1, sizeof(abCiphertext));
+    if (RT_SUCCESS(vrc))
+    {
+        vrc = RTBase64Encode(abCiphertext, sizeof(abCiphertext), szCipherBase64, sizeof(szCipherBase64), &cchCipherBase64);
+        if (RT_SUCCESS(vrc))
+            *aCiphertext = szCipherBase64;
+    }
+    return vrc;
+}
+
+/**
+ * Decode.
+ *
+ * @param aPlaintext      resulting plaintext
+ * @param aCiphertext     ciphertext (base64-encoded) to decrypt
+ */
+int VirtualBox::i_decryptSetting(Utf8Str *aPlaintext, const Utf8Str &aCiphertext)
+{
+    uint8_t abPlaintext[64];
+    uint8_t abCiphertext[64];
+    size_t  cbCiphertext;
+    int vrc = RTBase64Decode(aCiphertext.c_str(),
+                             abCiphertext, sizeof(abCiphertext),
+                             &cbCiphertext, NULL);
+    if (RT_SUCCESS(vrc))
+    {
+        vrc = i_decryptSettingBytes(abPlaintext, abCiphertext, cbCiphertext);
+        if (RT_SUCCESS(vrc))
+        {
+            for (unsigned i = 0; i < cbCiphertext; i++)
+            {
+                /* sanity check: null-terminated string? */
+                if (abPlaintext[i] == '\0')
+                {
+                    /* sanity check: valid UTF8 string? */
+                    if (RTStrIsValidEncoding((const char*)abPlaintext))
+                    {
+                        *aPlaintext = Utf8Str((const char*)abPlaintext);
+                        return VINF_SUCCESS;
+                    }
+                }
+            }
+            vrc = VERR_INVALID_MAGIC;
+        }
+    }
+    return vrc;
+}
+
+/**
+ * Encrypt secret bytes. Use the m->SettingsCipherKey as key.
+ *
+ * @param aPlaintext      clear text to be encrypted
+ * @param aCiphertext     resulting encrypted text
+ * @param aPlaintextSize  size of the plaintext
+ * @param aCiphertextSize size of the ciphertext
+ */
+int VirtualBox::i_encryptSettingBytes(const uint8_t *aPlaintext, uint8_t *aCiphertext,
+                                    size_t aPlaintextSize, size_t aCiphertextSize) const
+{
+    unsigned i, j;
+    uint8_t aBytes[64];
+
+    if (!m->fSettingsCipherKeySet)
+        return VERR_INVALID_STATE;
+
+    if (aCiphertextSize > sizeof(aBytes))
+        return VERR_BUFFER_OVERFLOW;
+
+    if (aCiphertextSize < 32)
+        return VERR_INVALID_PARAMETER;
+
+    AssertCompile(sizeof(m->SettingsCipherKey) >= 32);
+
+    /* store the first 8 bytes of the cipherkey for verification */
+    for (i = 0, j = 0; i < 8; i++, j++)
+        aCiphertext[i] = m->SettingsCipherKey[j];
+
+    for (unsigned k = 0; k < aPlaintextSize && i < aCiphertextSize; i++, k++)
+    {
+        aCiphertext[i] = (aPlaintext[k] ^ m->SettingsCipherKey[j]);
+        if (++j >= sizeof(m->SettingsCipherKey))
+            j = 0;
+    }
+
+    /* fill with random data to have a minimal length (salt) */
+    if (i < aCiphertextSize)
+    {
+        RTRandBytes(aBytes, aCiphertextSize - i);
+        for (int k = 0; i < aCiphertextSize; i++, k++)
+        {
+            aCiphertext[i] = aBytes[k] ^ m->SettingsCipherKey[j];
+            if (++j >= sizeof(m->SettingsCipherKey))
+                j = 0;
+        }
+    }
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Decrypt secret bytes. Use the m->SettingsCipherKey as key.
+ *
+ * @param aPlaintext      resulting plaintext
+ * @param aCiphertext     ciphertext to be decrypted
+ * @param aCiphertextSize size of the ciphertext == size of the plaintext
+ */
+int VirtualBox::i_decryptSettingBytes(uint8_t *aPlaintext,
+                                      const uint8_t *aCiphertext, size_t aCiphertextSize) const
+{
+    unsigned i, j;
+
+    if (!m->fSettingsCipherKeySet)
+        return VERR_INVALID_STATE;
+
+    if (aCiphertextSize < 32)
+        return VERR_INVALID_PARAMETER;
+
+    /* key verification */
+    for (i = 0, j = 0; i < 8; i++, j++)
+        if (aCiphertext[i] != m->SettingsCipherKey[j])
+            return VERR_INVALID_MAGIC;
+
+    /* poison */
+    memset(aPlaintext, 0xff, aCiphertextSize);
+    for (int k = 0; i < aCiphertextSize; i++, k++)
+    {
+        aPlaintext[k] = aCiphertext[i] ^ m->SettingsCipherKey[j];
+        if (++j >= sizeof(m->SettingsCipherKey))
+            j = 0;
+    }
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Store a settings key.
+ *
+ * @param aKey          the key to store
+ */
+void VirtualBox::i_storeSettingsKey(const Utf8Str &aKey)
+{
+    RTSha512(aKey.c_str(), aKey.length(), m->SettingsCipherKey);
+    m->fSettingsCipherKeySet = true;
+}
+
+// public methods only for internal purposes
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef DEBUG
+void VirtualBox::i_dumpAllBackRefs()
+{
+    {
+        AutoReadLock al(m->allHardDisks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+        for (MediaList::const_iterator mt = m->allHardDisks.begin();
+             mt != m->allHardDisks.end();
+             ++mt)
+        {
+            ComObjPtr<Medium> pMedium = *mt;
+            pMedium->i_dumpBackRefs();
+        }
+    }
+    {
+        AutoReadLock al(m->allDVDImages.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+        for (MediaList::const_iterator mt = m->allDVDImages.begin();
+             mt != m->allDVDImages.end();
+             ++mt)
+        {
+            ComObjPtr<Medium> pMedium = *mt;
+            pMedium->i_dumpBackRefs();
+        }
+    }
+}
+#endif
+
+/**
+ *  Posts an event to the event queue that is processed asynchronously
+ *  on a dedicated thread.
+ *
+ *  Posting events to the dedicated event queue is useful to perform secondary
+ *  actions outside any object locks -- for example, to iterate over a list
+ *  of callbacks and inform them about some change caused by some object's
+ *  method call.
+ *
+ *  @param event    event to post; must have been allocated using |new|, will
+ *                  be deleted automatically by the event thread after processing
+ *
+ *  @note Doesn't lock any object.
+ */
+HRESULT VirtualBox::i_postEvent(Event *event)
+{
+    AssertReturn(event, E_FAIL);
+
+    HRESULT hrc;
+    AutoCaller autoCaller(this);
+    if (SUCCEEDED((hrc = autoCaller.hrc())))
+    {
+        if (getObjectState().getState() != ObjectState::Ready)
+            Log1WarningFunc(("VirtualBox has been uninitialized (state=%d), the event is discarded!\n",
+                             getObjectState().getState()));
+            // return S_OK
+        else if (    (m->pAsyncEventQ)
+                  && (m->pAsyncEventQ->postEvent(event))
+                )
+            return S_OK;
+        else
+            hrc = E_FAIL;
+    }
+
+    // in any event of failure, we must clean up here, or we'll leak;
+    // the caller has allocated the object using new()
+    delete event;
+    return hrc;
+}
+
+/**
+ * Adds a progress to the global collection of pending operations.
+ * Usually gets called upon progress object initialization.
+ *
+ * @param aProgress Operation to add to the collection.
+ *
+ * @note Doesn't lock objects.
+ */
+HRESULT VirtualBox::i_addProgress(IProgress *aProgress)
+{
+    CheckComArgNotNull(aProgress);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
+
+    Bstr id;
+    HRESULT hrc = aProgress->COMGETTER(Id)(id.asOutParam());
+    AssertComRCReturnRC(hrc);
+
+    /* protect mProgressOperations */
+    AutoWriteLock safeLock(m->mtxProgressOperations COMMA_LOCKVAL_SRC_POS);
+
+    m->mapProgressOperations.insert(ProgressMap::value_type(Guid(id), aProgress));
+    return S_OK;
+}
+
+/**
+ * Removes the progress from the global collection of pending operations.
+ * Usually gets called upon progress completion.
+ *
+ * @param aId   UUID of the progress operation to remove
+ *
+ * @note Doesn't lock objects.
+ */
+HRESULT VirtualBox::i_removeProgress(IN_GUID aId)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
+
+    ComPtr<IProgress> progress;
+
+    /* protect mProgressOperations */
+    AutoWriteLock safeLock(m->mtxProgressOperations COMMA_LOCKVAL_SRC_POS);
+
+    size_t cnt = m->mapProgressOperations.erase(aId);
+    Assert(cnt == 1);
+    NOREF(cnt);
+
+    return S_OK;
+}
+
+#ifdef RT_OS_WINDOWS
+
+class StartSVCHelperClientData : public ThreadTask
+{
+public:
+    StartSVCHelperClientData()
+    {
+        LogFlowFuncEnter();
+        m_strTaskName = "SVCHelper";
+        threadVoidData = NULL;
+        initialized = false;
+    }
+
+    virtual ~StartSVCHelperClientData()
+    {
+        LogFlowFuncEnter();
+        if (threadVoidData!=NULL)
+        {
+            delete threadVoidData;
+            threadVoidData=NULL;
+        }
+    };
+
+    void handler()
+    {
+        VirtualBox::i_SVCHelperClientThreadTask(this);
+    }
+
+    const ComPtr<Progress>& GetProgressObject() const {return progress;}
+
+    bool init(VirtualBox* aVbox,
+              Progress* aProgress,
+              bool aPrivileged,
+              VirtualBox::PFN_SVC_HELPER_CLIENT_T aFunc,
+              void *aUser)
+    {
+        LogFlowFuncEnter();
+        that = aVbox;
+        progress = aProgress;
+        privileged = aPrivileged;
+        func = aFunc;
+        user = aUser;
+
+        initThreadVoidData();
+
+        initialized = true;
+
+        return initialized;
+    }
+
+    bool isOk() const{ return initialized;}
+
+    bool initialized;
+    ComObjPtr<VirtualBox> that;
+    ComObjPtr<Progress> progress;
+    bool privileged;
+    VirtualBox::PFN_SVC_HELPER_CLIENT_T func;
+    void *user;
+    ThreadVoidData *threadVoidData;
+
+private:
+    bool initThreadVoidData()
+    {
+        LogFlowFuncEnter();
+        threadVoidData = static_cast<ThreadVoidData*>(user);
+        return true;
+    }
+};
+
+/**
+ *  Helper method that starts a worker thread that:
+ *  - creates a pipe communication channel using SVCHlpClient;
+ *  - starts an SVC Helper process that will inherit this channel;
+ *  - executes the supplied function by passing it the created SVCHlpClient
+ *    and opened instance to communicate to the Helper process and the given
+ *    Progress object.
+ *
+ *  The user function is supposed to communicate to the helper process
+ *  using the \a aClient argument to do the requested job and optionally expose
+ *  the progress through the \a aProgress object. The user function should never
+ *  call notifyComplete() on it: this will be done automatically using the
+ *  result code returned by the function.
+ *
+ *  Before the user function is started, the communication channel passed to
+ *  the \a aClient argument is fully set up, the function should start using
+ *  its write() and read() methods directly.
+ *
+ *  The \a aVrc parameter of the user function may be used to return an error
+ *  code if it is related to communication errors (for example, returned by
+ *  the SVCHlpClient members when they fail). In this case, the correct error
+ *  message using this value will be reported to the caller. Note that the
+ *  value of \a aVrc is inspected only if the user function itself returns
+ *  success.
+ *
+ *  If a failure happens anywhere before the user function would be normally
+ *  called, it will be called anyway in special "cleanup only" mode indicated
+ *  by \a aClient, \a aProgress and \a aVrc arguments set to NULL. In this mode,
+ *  all the function is supposed to do is to cleanup its aUser argument if
+ *  necessary (it's assumed that the ownership of this argument is passed to
+ *  the user function once #startSVCHelperClient() returns a success, thus
+ *  making it responsible for the cleanup).
+ *
+ *  After the user function returns, the thread will send the SVCHlpMsg::Null
+ *  message to indicate a process termination.
+ *
+ *  @param  aPrivileged |true| to start the SVC Helper process as a privileged
+ *                      user that can perform administrative tasks
+ *  @param  aFunc       user function to run
+ *  @param  aUser       argument to the user function
+ *  @param  aProgress   progress object that will track operation completion
+ *
+ *  @note aPrivileged is currently ignored (due to some unsolved problems in
+ *        Vista) and the process will be started as a normal (unprivileged)
+ *        process.
+ *
+ *  @note Doesn't lock anything.
+ */
+HRESULT VirtualBox::i_startSVCHelperClient(bool aPrivileged,
+                                           PFN_SVC_HELPER_CLIENT_T aFunc,
+                                           void *aUser, Progress *aProgress)
+{
+    LogFlowFuncEnter();
+    AssertReturn(aFunc, E_POINTER);
+    AssertReturn(aProgress, E_POINTER);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
+
+    /* create the i_SVCHelperClientThreadTask() argument */
+
+    HRESULT hrc = S_OK;
+    StartSVCHelperClientData *pTask = NULL;
+    try
+    {
+        pTask = new StartSVCHelperClientData();
+
+        pTask->init(this, aProgress, aPrivileged, aFunc, aUser);
+
+        if (!pTask->isOk())
+        {
+            delete pTask;
+            LogRel(("Could not init StartSVCHelperClientData object \n"));
+            throw E_FAIL;
+        }
+
+        //this function delete pTask in case of exceptions, so there is no need in the call of delete operator
+        hrc = pTask->createThreadWithType(RTTHREADTYPE_MAIN_WORKER);
+
+    }
+    catch(std::bad_alloc &)
+    {
+        hrc = setError(E_OUTOFMEMORY);
+    }
+    catch(...)
+    {
+        LogRel(("Could not create thread for StartSVCHelperClientData \n"));
+        hrc = E_FAIL;
+    }
+
+    return hrc;
+}
+
+/**
+ *  Worker thread for startSVCHelperClient().
+ */
+/* static */
+void VirtualBox::i_SVCHelperClientThreadTask(StartSVCHelperClientData *pTask)
+{
+    LogFlowFuncEnter();
+    HRESULT hrc = S_OK;
+    bool userFuncCalled = false;
+
+    do
+    {
+        AssertBreakStmt(pTask, hrc = E_POINTER);
+        AssertReturnVoid(!pTask->progress.isNull());
+
+        /* protect VirtualBox from uninitialization */
+        AutoCaller autoCaller(pTask->that);
+        if (!autoCaller.isOk())
+        {
+            /* it's too late */
+            hrc = autoCaller.hrc();
+            break;
+        }
+
+        int vrc = VINF_SUCCESS;
+
+        Guid id;
+        id.create();
+        SVCHlpClient client;
+        vrc = client.create(Utf8StrFmt("VirtualBox\\SVCHelper\\{%RTuuid}",
+                                       id.raw()).c_str());
+        if (RT_FAILURE(vrc))
+        {
+            hrc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not create the communication channel (%Rrc)"), vrc);
+            break;
+        }
+
+        /* get the path to the executable */
+        char exePathBuf[RTPATH_MAX];
+        char *exePath = RTProcGetExecutablePath(exePathBuf, RTPATH_MAX);
+        if (!exePath)
+        {
+            hrc = pTask->that->setError(E_FAIL, tr("Cannot get executable name"));
+            break;
+        }
+
+        Utf8Str argsStr = Utf8StrFmt("/Helper %s", client.name().c_str());
+
+        LogFlowFunc(("Starting '\"%s\" %s'...\n", exePath, argsStr.c_str()));
+
+        RTPROCESS pid = NIL_RTPROCESS;
+
+        if (pTask->privileged)
+        {
+            /* Attempt to start a privileged process using the Run As dialog */
+
+            Bstr file = exePath;
+            Bstr parameters = argsStr;
+
+            SHELLEXECUTEINFO shExecInfo;
+
+            shExecInfo.cbSize = sizeof(SHELLEXECUTEINFO);
+
+            shExecInfo.fMask = NULL;
+            shExecInfo.hwnd = NULL;
+            shExecInfo.lpVerb = L"runas";
+            shExecInfo.lpFile = file.raw();
+            shExecInfo.lpParameters = parameters.raw();
+            shExecInfo.lpDirectory = NULL;
+            shExecInfo.nShow = SW_NORMAL;
+            shExecInfo.hInstApp = NULL;
+
+            if (!ShellExecuteEx(&shExecInfo))
+            {
+                int vrc2 = RTErrConvertFromWin32(GetLastError());
+                /* hide excessive details in case of a frequent error
+                 * (pressing the Cancel button to close the Run As dialog) */
+                if (vrc2 == VERR_CANCELLED)
+                    hrc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Operation canceled by the user"));
+                else
+                    hrc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not launch a privileged process '%s' (%Rrc)"), exePath, vrc2);
+                break;
+            }
+        }
+        else
+        {
+            const char *args[] = { exePath, "/Helper", client.name().c_str(), 0 };
+            vrc = RTProcCreate(exePath, args, RTENV_DEFAULT, 0, &pid);
+            if (RT_FAILURE(vrc))
+            {
+                hrc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not launch a process '%s' (%Rrc)"), exePath, vrc);
+                break;
+            }
+        }
+
+        /* wait for the client to connect */
+        vrc = client.connect();
+        if (RT_SUCCESS(vrc))
+        {
+            /* start the user supplied function */
+            hrc = pTask->func(&client, pTask->progress, pTask->user, &vrc);
+            userFuncCalled = true;
+        }
+
+        /* send the termination signal to the process anyway */
+        {
+            int vrc2 = client.write(SVCHlpMsg::Null);
+            if (RT_SUCCESS(vrc))
+                vrc = vrc2;
+        }
+
+        if (SUCCEEDED(hrc) && RT_FAILURE(vrc))
+        {
+            hrc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not operate the communication channel (%Rrc)"), vrc);
+            break;
+        }
+    }
+    while (0);
+
+    if (FAILED(hrc) && !userFuncCalled)
+    {
+        /* call the user function in the "cleanup only" mode
+         * to let it free resources passed to in aUser */
+        pTask->func(NULL, NULL, pTask->user, NULL);
+    }
+
+    pTask->progress->i_notifyComplete(hrc);
+
+    LogFlowFuncLeave();
+}
+
+#endif /* RT_OS_WINDOWS */
+
+/**
+ *  Sends a signal to the client watcher to rescan the set of machines
+ *  that have open sessions.
+ *
+ *  @note Doesn't lock anything.
+ */
+void VirtualBox::i_updateClientWatcher()
+{
+    AutoCaller autoCaller(this);
+    AssertComRCReturnVoid(autoCaller.hrc());
+
+    AssertPtrReturnVoid(m->pClientWatcher);
+    m->pClientWatcher->update();
+}
+
+/**
+ *  Adds the given child process ID to the list of processes to be reaped.
+ *  This call should be followed by #i_updateClientWatcher() to take the effect.
+ *
+ *  @note Doesn't lock anything.
+ */
+void VirtualBox::i_addProcessToReap(RTPROCESS pid)
+{
+    AutoCaller autoCaller(this);
+    AssertComRCReturnVoid(autoCaller.hrc());
+
+    AssertPtrReturnVoid(m->pClientWatcher);
+    m->pClientWatcher->addProcess(pid);
+}
+
+/**
+ * VD plugin load
+ */
+int VirtualBox::i_loadVDPlugin(const char *pszPluginLibrary)
+{
+    return m->pSystemProperties->i_loadVDPlugin(pszPluginLibrary);
+}
+
+/**
+ * VD plugin unload
+ */
+int VirtualBox::i_unloadVDPlugin(const char *pszPluginLibrary)
+{
+    return m->pSystemProperties->i_unloadVDPlugin(pszPluginLibrary);
+}
+
+/**
+ *  @note Doesn't lock any object.
+ */
+void VirtualBox::i_onMediumRegistered(const Guid &aMediumId, const DeviceType_T aDevType, const BOOL aRegistered)
+{
+    ComPtr<IEvent> ptrEvent;
+    HRESULT hrc = ::CreateMediumRegisteredEvent(ptrEvent.asOutParam(), m->pEventSource,
+                                                aMediumId.toString(), aDevType, aRegistered);
+    AssertComRCReturnVoid(hrc);
+    i_postEvent(new AsyncEvent(this, ptrEvent));
+}
+
+void VirtualBox::i_onMediumConfigChanged(IMedium *aMedium)
+{
+    ComPtr<IEvent> ptrEvent;
+    HRESULT hrc = ::CreateMediumConfigChangedEvent(ptrEvent.asOutParam(), m->pEventSource, aMedium);
+    AssertComRCReturnVoid(hrc);
+    i_postEvent(new AsyncEvent(this, ptrEvent));
+}
+
+void VirtualBox::i_onMediumChanged(IMediumAttachment *aMediumAttachment)
+{
+    ComPtr<IEvent> ptrEvent;
+    HRESULT hrc = ::CreateMediumChangedEvent(ptrEvent.asOutParam(), m->pEventSource, aMediumAttachment);
+    AssertComRCReturnVoid(hrc);
+    i_postEvent(new AsyncEvent(this, ptrEvent));
+}
+
+/**
+ *  @note Doesn't lock any object.
+ */
+void VirtualBox::i_onStorageControllerChanged(const Guid &aMachineId, const com::Utf8Str &aControllerName)
+{
+    ComPtr<IEvent> ptrEvent;
+    HRESULT hrc = ::CreateStorageControllerChangedEvent(ptrEvent.asOutParam(), m->pEventSource,
+                                                        aMachineId.toString(), aControllerName);
+    AssertComRCReturnVoid(hrc);
+    i_postEvent(new AsyncEvent(this, ptrEvent));
+}
+
+void VirtualBox::i_onStorageDeviceChanged(IMediumAttachment *aStorageDevice, const BOOL fRemoved, const BOOL fSilent)
+{
+    ComPtr<IEvent> ptrEvent;
+    HRESULT hrc = ::CreateStorageDeviceChangedEvent(ptrEvent.asOutParam(), m->pEventSource, aStorageDevice, fRemoved, fSilent);
+    AssertComRCReturnVoid(hrc);
+    i_postEvent(new AsyncEvent(this, ptrEvent));
+}
+
+/**
+ *  @note Doesn't lock any object.
+ */
+void VirtualBox::i_onMachineStateChanged(const Guid &aId, MachineState_T aState)
+{
+    ComPtr<IEvent> ptrEvent;
+    HRESULT hrc = ::CreateMachineStateChangedEvent(ptrEvent.asOutParam(), m->pEventSource, aId.toString(), aState);
+    AssertComRCReturnVoid(hrc);
+    i_postEvent(new AsyncEvent(this, ptrEvent));
+}
+
+/**
+ *  @note Doesn't lock any object.
+ */
+void VirtualBox::i_onMachineDataChanged(const Guid &aId, BOOL aTemporary)
+{
+    ComPtr<IEvent> ptrEvent;
+    HRESULT hrc = ::CreateMachineDataChangedEvent(ptrEvent.asOutParam(), m->pEventSource, aId.toString(), aTemporary);
+    AssertComRCReturnVoid(hrc);
+    i_postEvent(new AsyncEvent(this, ptrEvent));
+}
+
+/**
+ *  @note Doesn't lock any object.
+ */
+void VirtualBox::i_onMachineGroupsChanged(const Guid &aId)
+{
+    ComPtr<IEvent> ptrEvent;
+    HRESULT hrc = ::CreateMachineGroupsChangedEvent(ptrEvent.asOutParam(), m->pEventSource, aId.toString(), FALSE /*aDummy*/);
+    AssertComRCReturnVoid(hrc);
+    i_postEvent(new AsyncEvent(this, ptrEvent));
+}
+
+/**
+ *  @note Locks this object for reading.
+ */
+BOOL VirtualBox::i_onExtraDataCanChange(const Guid &aId, const Utf8Str &aKey, const Utf8Str &aValue, Bstr &aError)
+{
+    LogFlowThisFunc(("machine={%RTuuid} aKey={%s} aValue={%s}\n", aId.raw(), aKey.c_str(), aValue.c_str()));
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturn(autoCaller.hrc(), FALSE);
+
+    ComPtr<IEvent> ptrEvent;
+    HRESULT hrc = ::CreateExtraDataCanChangeEvent(ptrEvent.asOutParam(), m->pEventSource, aId.toString(), aKey, aValue);
+    AssertComRCReturn(hrc, TRUE);
+
+    VBoxEventDesc EvtDesc(ptrEvent, m->pEventSource);
+    BOOL fDelivered = EvtDesc.fire(3000); /* Wait up to 3 secs for delivery */
+    //Assert(fDelivered);
+    BOOL fAllowChange = TRUE;
+    if (fDelivered)
+    {
+        ComPtr<IExtraDataCanChangeEvent> ptrCanChangeEvent = ptrEvent;
+        Assert(ptrCanChangeEvent);
+
+        BOOL fVetoed = FALSE;
+        ptrCanChangeEvent->IsVetoed(&fVetoed);
+        fAllowChange = !fVetoed;
+
+        if (!fAllowChange)
+        {
+            SafeArray<BSTR> aVetos;
+            ptrCanChangeEvent->GetVetos(ComSafeArrayAsOutParam(aVetos));
+            if (aVetos.size() > 0)
+                aError = aVetos[0];
+        }
+    }
+
+    LogFlowThisFunc(("fAllowChange=%RTbool\n", fAllowChange));
+    return fAllowChange;
+}
+
+/**
+ *  @note Doesn't lock any object.
+ */
+void VirtualBox::i_onExtraDataChanged(const Guid &aId, const Utf8Str &aKey, const Utf8Str &aValue)
+{
+    ComPtr<IEvent> ptrEvent;
+    HRESULT hrc = ::CreateExtraDataChangedEvent(ptrEvent.asOutParam(), m->pEventSource, aId.toString(), aKey, aValue);
+    AssertComRCReturnVoid(hrc);
+    i_postEvent(new AsyncEvent(this, ptrEvent));
+}
+
+/**
+ *  @note Doesn't lock any object.
+ */
+void VirtualBox::i_onMachineRegistered(const Guid &aId, BOOL aRegistered)
+{
+    ComPtr<IEvent> ptrEvent;
+    HRESULT hrc = ::CreateMachineRegisteredEvent(ptrEvent.asOutParam(), m->pEventSource, aId.toString(), aRegistered);
+    AssertComRCReturnVoid(hrc);
+    i_postEvent(new AsyncEvent(this, ptrEvent));
+}
+
+/**
+ *  @note Doesn't lock any object.
+ */
+void VirtualBox::i_onSessionStateChanged(const Guid &aId, SessionState_T aState)
+{
+    ComPtr<IEvent> ptrEvent;
+    HRESULT hrc = ::CreateSessionStateChangedEvent(ptrEvent.asOutParam(), m->pEventSource, aId.toString(), aState);
+    AssertComRCReturnVoid(hrc);
+    i_postEvent(new AsyncEvent(this, ptrEvent));
+}
+
+/**
+ *  @note Doesn't lock any object.
+ */
+void VirtualBox::i_onSnapshotTaken(const Guid &aMachineId, const Guid &aSnapshotId)
+{
+    ComPtr<IEvent> ptrEvent;
+    HRESULT hrc = ::CreateSnapshotTakenEvent(ptrEvent.asOutParam(), m->pEventSource,
+                                             aMachineId.toString(), aSnapshotId.toString());
+    AssertComRCReturnVoid(hrc);
+    i_postEvent(new AsyncEvent(this, ptrEvent));
+}
+
+/**
+ *  @note Doesn't lock any object.
+ */
+void VirtualBox::i_onSnapshotDeleted(const Guid &aMachineId, const Guid &aSnapshotId)
+{
+    ComPtr<IEvent> ptrEvent;
+    HRESULT hrc = ::CreateSnapshotDeletedEvent(ptrEvent.asOutParam(), m->pEventSource,
+                                               aMachineId.toString(), aSnapshotId.toString());
+    AssertComRCReturnVoid(hrc);
+    i_postEvent(new AsyncEvent(this, ptrEvent));
+}
+
+/**
+ *  @note Doesn't lock any object.
+ */
+void VirtualBox::i_onSnapshotRestored(const Guid &aMachineId, const Guid &aSnapshotId)
+{
+    ComPtr<IEvent> ptrEvent;
+    HRESULT hrc = ::CreateSnapshotRestoredEvent(ptrEvent.asOutParam(), m->pEventSource,
+                                                aMachineId.toString(), aSnapshotId.toString());
+    AssertComRCReturnVoid(hrc);
+    i_postEvent(new AsyncEvent(this, ptrEvent));
+}
+
+/**
+ *  @note Doesn't lock any object.
+ */
+void VirtualBox::i_onSnapshotChanged(const Guid &aMachineId, const Guid &aSnapshotId)
+{
+    ComPtr<IEvent> ptrEvent;
+    HRESULT hrc = ::CreateSnapshotChangedEvent(ptrEvent.asOutParam(), m->pEventSource,
+                                               aMachineId.toString(), aSnapshotId.toString());
+    AssertComRCReturnVoid(hrc);
+    i_postEvent(new AsyncEvent(this, ptrEvent));
+}
+
+/**
+ *  @note Doesn't lock any object.
+ */
+void VirtualBox::i_onGuestPropertyChanged(const Guid &aMachineId, const Utf8Str &aName, const Utf8Str &aValue,
+                                          const Utf8Str &aFlags, const BOOL fWasDeleted)
+{
+    ComPtr<IEvent> ptrEvent;
+    HRESULT hrc = ::CreateGuestPropertyChangedEvent(ptrEvent.asOutParam(), m->pEventSource,
+                                                    aMachineId.toString(), aName, aValue, aFlags, fWasDeleted);
+    AssertComRCReturnVoid(hrc);
+    i_postEvent(new AsyncEvent(this, ptrEvent));
+}
+
+/**
+ *  @note Doesn't lock any object.
+ */
+void VirtualBox::i_onNatRedirectChanged(const Guid &aMachineId, ULONG ulSlot, bool fRemove, const Utf8Str &aName,
+                                        NATProtocol_T aProto, const Utf8Str &aHostIp, uint16_t aHostPort,
+                                        const Utf8Str &aGuestIp, uint16_t aGuestPort)
+{
+    ::FireNATRedirectEvent(m->pEventSource, aMachineId.toString(), ulSlot, fRemove, aName, aProto, aHostIp,
+                           aHostPort, aGuestIp, aGuestPort);
+}
+
+/** @todo Unused!!  */
+void VirtualBox::i_onNATNetworkChanged(const Utf8Str &aName)
+{
+    ::FireNATNetworkChangedEvent(m->pEventSource, aName);
+}
+
+void VirtualBox::i_onNATNetworkStartStop(const Utf8Str &aName, BOOL fStart)
+{
+    ::FireNATNetworkStartStopEvent(m->pEventSource, aName, fStart);
+}
+
+void VirtualBox::i_onNATNetworkSetting(const Utf8Str &aNetworkName, BOOL aEnabled,
+                                       const Utf8Str &aNetwork, const Utf8Str &aGateway,
+                                       BOOL aAdvertiseDefaultIpv6RouteEnabled,
+                                       BOOL fNeedDhcpServer)
+{
+    ::FireNATNetworkSettingEvent(m->pEventSource, aNetworkName, aEnabled, aNetwork, aGateway,
+                                 aAdvertiseDefaultIpv6RouteEnabled, fNeedDhcpServer);
+}
+
+void VirtualBox::i_onNATNetworkPortForward(const Utf8Str &aNetworkName, BOOL create, BOOL fIpv6,
+                                           const Utf8Str &aRuleName, NATProtocol_T proto,
+                                           const Utf8Str &aHostIp, LONG aHostPort,
+                                           const Utf8Str &aGuestIp, LONG aGuestPort)
+{
+    ::FireNATNetworkPortForwardEvent(m->pEventSource, aNetworkName, create, fIpv6, aRuleName, proto,
+                                     aHostIp, aHostPort, aGuestIp, aGuestPort);
+}
+
+
+void VirtualBox::i_onHostNameResolutionConfigurationChange()
+{
+    if (m->pEventSource)
+        ::FireHostNameResolutionConfigurationChangeEvent(m->pEventSource);
+}
+
+
+int VirtualBox::i_natNetworkRefInc(const Utf8Str &aNetworkName)
+{
+    AutoWriteLock safeLock(*spMtxNatNetworkNameToRefCountLock COMMA_LOCKVAL_SRC_POS);
+
+    if (!sNatNetworkNameToRefCount[aNetworkName])
+    {
+        ComPtr<INATNetwork> nat;
+        HRESULT hrc = findNATNetworkByName(aNetworkName, nat);
+        if (FAILED(hrc)) return -1;
+
+        hrc = nat->Start();
+        if (SUCCEEDED(hrc))
+            LogRel(("Started NAT network '%s'\n", aNetworkName.c_str()));
+        else
+            LogRel(("Error %Rhrc starting NAT network '%s'\n", hrc, aNetworkName.c_str()));
+        AssertComRCReturn(hrc, -1);
+    }
+
+    sNatNetworkNameToRefCount[aNetworkName]++;
+
+    return sNatNetworkNameToRefCount[aNetworkName];
+}
+
+
+int VirtualBox::i_natNetworkRefDec(const Utf8Str &aNetworkName)
+{
+    AutoWriteLock safeLock(*spMtxNatNetworkNameToRefCountLock COMMA_LOCKVAL_SRC_POS);
+
+    if (!sNatNetworkNameToRefCount[aNetworkName])
+        return 0;
+
+    sNatNetworkNameToRefCount[aNetworkName]--;
+
+    if (!sNatNetworkNameToRefCount[aNetworkName])
+    {
+        ComPtr<INATNetwork> nat;
+        HRESULT hrc = findNATNetworkByName(aNetworkName, nat);
+        if (FAILED(hrc)) return -1;
+
+        hrc = nat->Stop();
+        if (SUCCEEDED(hrc))
+            LogRel(("Stopped NAT network '%s'\n", aNetworkName.c_str()));
+        else
+            LogRel(("Error %Rhrc stopping NAT network '%s'\n", hrc, aNetworkName.c_str()));
+        AssertComRCReturn(hrc, -1);
+    }
+
+    return sNatNetworkNameToRefCount[aNetworkName];
+}
+
+
+/*
+ * Export this to NATNetwork so that its setters can refuse to change
+ * essential network settings when an VBoxNatNet instance is running.
+ */
+RWLockHandle *VirtualBox::i_getNatNetLock() const
+{
+    return spMtxNatNetworkNameToRefCountLock;
+}
+
+
+/*
+ * Export this to NATNetwork so that its setters can refuse to change
+ * essential network settings when an VBoxNatNet instance is running.
+ * The caller is expected to hold a read lock on i_getNatNetLock().
+ */
+bool VirtualBox::i_isNatNetStarted(const Utf8Str &aNetworkName) const
+{
+    return sNatNetworkNameToRefCount[aNetworkName] > 0;
+}
+
+
+void VirtualBox::i_onCloudProviderListChanged(BOOL aRegistered)
+{
+    ::FireCloudProviderListChangedEvent(m->pEventSource, aRegistered);
+}
+
+
+void VirtualBox::i_onCloudProviderRegistered(const Utf8Str &aProviderId, BOOL aRegistered)
+{
+    ::FireCloudProviderRegisteredEvent(m->pEventSource, aProviderId, aRegistered);
+}
+
+
+void VirtualBox::i_onCloudProviderUninstall(const Utf8Str &aProviderId)
+{
+    HRESULT hrc;
+
+    ComPtr<IEvent> pEvent;
+    hrc = CreateCloudProviderUninstallEvent(pEvent.asOutParam(),
+                                            m->pEventSource, aProviderId);
+    if (FAILED(hrc))
+        return;
+
+    BOOL fDelivered = FALSE;
+    hrc = m->pEventSource->FireEvent(pEvent, /* :timeout */ 10000, &fDelivered);
+    if (FAILED(hrc))
+        return;
+}
+
+void VirtualBox::i_onLanguageChanged(const Utf8Str &aLanguageId)
+{
+    ComPtr<IEvent> ptrEvent;
+    HRESULT hrc = ::CreateLanguageChangedEvent(ptrEvent.asOutParam(), m->pEventSource, aLanguageId);
+    AssertComRCReturnVoid(hrc);
+    i_postEvent(new AsyncEvent(this, ptrEvent));
+}
+
+void VirtualBox::i_onProgressCreated(const Guid &aId, BOOL aCreated)
+{
+    ::FireProgressCreatedEvent(m->pEventSource, aId.toString(), aCreated);
+}
+
+#ifdef VBOX_WITH_UPDATE_AGENT
+/**
+ *  @note Doesn't lock any object.
+ */
+void VirtualBox::i_onUpdateAgentAvailable(IUpdateAgent *aAgent,
+                                          const Utf8Str &aVer, UpdateChannel_T aChannel, UpdateSeverity_T aSev,
+                                          const Utf8Str &aDownloadURL, const Utf8Str &aWebURL, const Utf8Str &aReleaseNotes)
+{
+    ::FireUpdateAgentAvailableEvent(m->pEventSource, aAgent, aVer, aChannel, aSev,
+                                    aDownloadURL, aWebURL, aReleaseNotes);
+}
+
+/**
+ *  @note Doesn't lock any object.
+ */
+void VirtualBox::i_onUpdateAgentError(IUpdateAgent *aAgent, const Utf8Str &aErrMsg, LONG aRc)
+{
+    ::FireUpdateAgentErrorEvent(m->pEventSource, aAgent, aErrMsg, aRc);
+}
+
+/**
+ *  @note Doesn't lock any object.
+ */
+void VirtualBox::i_onUpdateAgentStateChanged(IUpdateAgent *aAgent, UpdateState_T aState)
+{
+    ::FireUpdateAgentStateChangedEvent(m->pEventSource, aAgent, aState);
+}
+
+/**
+ *  @note Doesn't lock any object.
+ */
+void VirtualBox::i_onUpdateAgentSettingsChanged(IUpdateAgent *aAgent, const Utf8Str &aAttributeHint)
+{
+    ::FireUpdateAgentSettingsChangedEvent(m->pEventSource, aAgent, aAttributeHint);
+}
+#endif /* VBOX_WITH_UPDATE_AGENT */
+
+/**
+ *  @note Locks the list of other objects for reading.
+ */
+ComObjPtr<GuestOSType> VirtualBox::i_getUnknownOSType()
+{
+    ComObjPtr<GuestOSType> type;
+
+    /* unknown type must always be the first */
+    ComAssertRet(m->allGuestOSTypes.size() > 0, type);
+
+    return m->allGuestOSTypes.front();
+}
+
+/**
+ * Returns the list of opened machines (machines having VM sessions opened,
+ * ignoring other sessions) and optionally the list of direct session controls.
+ *
+ * @param aMachines     Where to put opened machines (will be empty if none).
+ * @param aControls     Where to put direct session controls (optional).
+ *
+ * @note The returned lists contain smart pointers. So, clear it as soon as
+ * it becomes no more necessary to release instances.
+ *
+ * @note It can be possible that a session machine from the list has been
+ * already uninitialized, so do a usual AutoCaller/AutoReadLock sequence
+ * when accessing unprotected data directly.
+ *
+ * @note Locks objects for reading.
+ */
+void VirtualBox::i_getOpenedMachines(SessionMachinesList &aMachines,
+                                     InternalControlList *aControls /*= NULL*/)
+{
+    AutoCaller autoCaller(this);
+    AssertComRCReturnVoid(autoCaller.hrc());
+
+    aMachines.clear();
+    if (aControls)
+        aControls->clear();
+
+    AutoReadLock alock(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    for (MachinesOList::iterator it = m->allMachines.begin();
+         it != m->allMachines.end();
+         ++it)
+    {
+        ComObjPtr<SessionMachine> sm;
+        ComPtr<IInternalSessionControl> ctl;
+        if ((*it)->i_isSessionOpenVM(sm, &ctl))
+        {
+            aMachines.push_back(sm);
+            if (aControls)
+                aControls->push_back(ctl);
+        }
+    }
+}
+
+/**
+ * Gets a reference to the machine list. This is the real thing, not a copy,
+ * so bad things will happen if the caller doesn't hold the necessary lock.
+ *
+ * @returns reference to machine list
+ *
+ * @note Caller must hold the VirtualBox object lock at least for reading.
+ */
+VirtualBox::MachinesOList &VirtualBox::i_getMachinesList(void)
+{
+    return m->allMachines;
+}
+
+/**
+ *  Searches for a machine object with the given ID in the collection
+ *  of registered machines.
+ *
+ * @param aId Machine UUID to look for.
+ * @param fPermitInaccessible If true, inaccessible machines will be found;
+ *                  if false, this will fail if the given machine is inaccessible.
+ * @param aSetError If true, set errorinfo if the machine is not found.
+ * @param aMachine Returned machine, if found.
+ * @return
+ */
+HRESULT VirtualBox::i_findMachine(const Guid &aId,
+                                  bool fPermitInaccessible,
+                                  bool aSetError,
+                                  ComObjPtr<Machine> *aMachine /* = NULL */)
+{
+    HRESULT hrc = VBOX_E_OBJECT_NOT_FOUND;
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    {
+        AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+        for (MachinesOList::iterator it = m->allMachines.begin();
+             it != m->allMachines.end();
+             ++it)
+        {
+            ComObjPtr<Machine> pMachine = *it;
+
+            if (!fPermitInaccessible)
+            {
+                // skip inaccessible machines
+                AutoCaller machCaller(pMachine);
+                if (FAILED(machCaller.hrc()))
+                    continue;
+            }
+
+            if (pMachine->i_getId() == aId)
+            {
+                hrc = S_OK;
+                if (aMachine)
+                    *aMachine = pMachine;
+                break;
+            }
+        }
+    }
+
+    if (aSetError && FAILED(hrc))
+        hrc = setError(hrc, tr("Could not find a registered machine with UUID {%RTuuid}"), aId.raw());
+
+    return hrc;
+}
+
+/**
+ * Searches for a machine object with the given name or location in the
+ * collection of registered machines.
+ *
+ * @param aName Machine name or location to look for.
+ * @param aSetError If true, set errorinfo if the machine is not found.
+ * @param aMachine Returned machine, if found.
+ * @return
+ */
+HRESULT VirtualBox::i_findMachineByName(const Utf8Str &aName,
+                                        bool  aSetError,
+                                        ComObjPtr<Machine> *aMachine /* = NULL */)
+{
+    HRESULT hrc = VBOX_E_OBJECT_NOT_FOUND;
+
+    AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+    for (MachinesOList::iterator it = m->allMachines.begin();
+         it != m->allMachines.end();
+         ++it)
+    {
+        ComObjPtr<Machine> &pMachine = *it;
+        AutoCaller machCaller(pMachine);
+        if (!machCaller.isOk())
+            continue;       // we can't ask inaccessible machines for their names
+
+        AutoReadLock machLock(pMachine COMMA_LOCKVAL_SRC_POS);
+        if (pMachine->i_getName() == aName)
+        {
+            hrc = S_OK;
+            if (aMachine)
+                *aMachine = pMachine;
+            break;
+        }
+        if (!RTPathCompare(pMachine->i_getSettingsFileFull().c_str(), aName.c_str()))
+        {
+            hrc = S_OK;
+            if (aMachine)
+                *aMachine = pMachine;
+            break;
+        }
+    }
+
+    if (aSetError && FAILED(hrc))
+        hrc = setError(hrc, tr("Could not find a registered machine named '%s'"), aName.c_str());
+
+    return hrc;
+}
+
+static HRESULT i_validateMachineGroupHelper(const Utf8Str &aGroup, bool fPrimary, VirtualBox *pVirtualBox)
+{
+    /* empty strings are invalid */
+    if (aGroup.isEmpty())
+        return E_INVALIDARG;
+    /* the toplevel group is valid */
+    if (aGroup == "/")
+        return S_OK;
+    /* any other strings of length 1 are invalid */
+    if (aGroup.length() == 1)
+        return E_INVALIDARG;
+    /* must start with a slash */
+    if (aGroup.c_str()[0] != '/')
+        return E_INVALIDARG;
+    /* must not end with a slash */
+    if (aGroup.c_str()[aGroup.length() - 1] == '/')
+        return E_INVALIDARG;
+    /* check the group components */
+    const char *pStr = aGroup.c_str() + 1;  /* first char is /, skip it */
+    while (pStr)
+    {
+        char *pSlash = RTStrStr(pStr, "/");
+        if (pSlash)
+        {
+            /* no empty components (or // sequences in other words) */
+            if (pSlash == pStr)
+                return E_INVALIDARG;
+            /* check if the machine name rules are violated, because that means
+             * the group components are too close to the limits. */
+            Utf8Str tmp((const char *)pStr, (size_t)(pSlash - pStr));
+            Utf8Str tmp2(tmp);
+            sanitiseMachineFilename(tmp);
+            if (tmp != tmp2)
+                return E_INVALIDARG;
+            if (fPrimary)
+            {
+                HRESULT hrc = pVirtualBox->i_findMachineByName(tmp, false /* aSetError */);
+                if (SUCCEEDED(hrc))
+                    return VBOX_E_VM_ERROR;
+            }
+            pStr = pSlash + 1;
+        }
+        else
+        {
+            /* check if the machine name rules are violated, because that means
+             * the group components is too close to the limits. */
+            Utf8Str tmp(pStr);
+            Utf8Str tmp2(tmp);
+            sanitiseMachineFilename(tmp);
+            if (tmp != tmp2)
+                return E_INVALIDARG;
+            pStr = NULL;
+        }
+    }
+    return S_OK;
+}
+
+/**
+ * Validates a machine group.
+ *
+ * @param aGroup    Machine group.
+ * @param fPrimary  Set if this is the primary group.
+ *
+ * @return S_OK or E_INVALIDARG
+ */
+HRESULT VirtualBox::i_validateMachineGroup(const Utf8Str &aGroup, bool fPrimary)
+{
+    HRESULT hrc = i_validateMachineGroupHelper(aGroup, fPrimary, this);
+    if (FAILED(hrc))
+    {
+        if (hrc == VBOX_E_VM_ERROR)
+            hrc = setError(E_INVALIDARG, tr("Machine group '%s' conflicts with a virtual machine name"), aGroup.c_str());
+        else
+            hrc = setError(hrc, tr("Invalid machine group '%s'"), aGroup.c_str());
+    }
+    return hrc;
+}
+
+/**
+ * Takes a list of machine groups, and sanitizes/validates it.
+ *
+ * @param aMachineGroups    Array with the machine groups.
+ * @param pllMachineGroups  Pointer to list of strings for the result.
+ *
+ * @return S_OK or E_INVALIDARG
+ */
+HRESULT VirtualBox::i_convertMachineGroups(const std::vector<com::Utf8Str> aMachineGroups, StringsList *pllMachineGroups)
+{
+    pllMachineGroups->clear();
+    if (aMachineGroups.size())
+    {
+        for (size_t i = 0; i < aMachineGroups.size(); i++)
+        {
+            Utf8Str group(aMachineGroups[i]);
+            if (group.length() == 0)
+                group = "/";
+
+            HRESULT hrc = i_validateMachineGroup(group, i == 0);
+            if (FAILED(hrc))
+                return hrc;
+
+            /* no duplicates please */
+            if (   find(pllMachineGroups->begin(), pllMachineGroups->end(), group)
+                == pllMachineGroups->end())
+                pllMachineGroups->push_back(group);
+        }
+        if (pllMachineGroups->size() == 0)
+            pllMachineGroups->push_back("/");
+    }
+    else
+        pllMachineGroups->push_back("/");
+
+    return S_OK;
+}
+
+/**
+ * Searches for a Medium object with the given ID in the list of registered
+ * hard disks.
+ *
+ * @param aId           ID of the hard disk. Must not be empty.
+ * @param aSetError     If @c true , the appropriate error info is set in case
+ *                      when the hard disk is not found.
+ * @param aHardDisk     Where to store the found hard disk object (can be NULL).
+ *
+ * @return S_OK, E_INVALIDARG or VBOX_E_OBJECT_NOT_FOUND when not found.
+ *
+ * @note Locks the media tree for reading.
+ */
+HRESULT VirtualBox::i_findHardDiskById(const Guid &aId,
+                                       bool aSetError,
+                                       ComObjPtr<Medium> *aHardDisk /*= NULL*/)
+{
+    AssertReturn(!aId.isZero(), E_INVALIDARG);
+
+    // we use the hard disks map, but it is protected by the
+    // hard disk _list_ lock handle
+    AutoReadLock alock(m->allHardDisks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    HardDiskMap::const_iterator it = m->mapHardDisks.find(aId);
+    if (it != m->mapHardDisks.end())
+    {
+        if (aHardDisk)
+            *aHardDisk = (*it).second;
+        return S_OK;
+    }
+
+    if (aSetError)
+        return setError(VBOX_E_OBJECT_NOT_FOUND,
+                        tr("Could not find an open hard disk with UUID {%RTuuid}"),
+                        aId.raw());
+
+    return VBOX_E_OBJECT_NOT_FOUND;
+}
+
+/**
+ * Searches for a Medium object with the given ID or location in the list of
+ * registered hard disks. If both ID and location are specified, the first
+ * object that matches either of them (not necessarily both) is returned.
+ *
+ * @param strLocation   Full location specification. Must not be empty.
+ * @param aSetError     If @c true , the appropriate error info is set in case
+ *                      when the hard disk is not found.
+ * @param aHardDisk     Where to store the found hard disk object (can be NULL).
+ *
+ * @return S_OK, E_INVALIDARG or VBOX_E_OBJECT_NOT_FOUND when not found.
+ *
+ * @note Locks the media tree for reading.
+ */
+HRESULT VirtualBox::i_findHardDiskByLocation(const Utf8Str &strLocation,
+                                             bool aSetError,
+                                             ComObjPtr<Medium> *aHardDisk /*= NULL*/)
+{
+    AssertReturn(!strLocation.isEmpty(), E_INVALIDARG);
+
+    // we use the hard disks map, but it is protected by the
+    // hard disk _list_ lock handle
+    AutoReadLock alock(m->allHardDisks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    for (HardDiskMap::const_iterator it = m->mapHardDisks.begin();
+         it != m->mapHardDisks.end();
+         ++it)
+    {
+        const ComObjPtr<Medium> &pHD = (*it).second;
+
+        AutoCaller autoCaller(pHD);
+        if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
+        AutoWriteLock mlock(pHD COMMA_LOCKVAL_SRC_POS);
+
+        Utf8Str strLocationFull = pHD->i_getLocationFull();
+
+        if (0 == RTPathCompare(strLocationFull.c_str(), strLocation.c_str()))
+        {
+            if (aHardDisk)
+                *aHardDisk = pHD;
+            return S_OK;
+        }
+    }
+
+    if (aSetError)
+        return setError(VBOX_E_OBJECT_NOT_FOUND,
+                        tr("Could not find an open hard disk with location '%s'"),
+                        strLocation.c_str());
+
+    return VBOX_E_OBJECT_NOT_FOUND;
+}
+
+/**
+ * Searches for a Medium object with the given ID or location in the list of
+ * registered DVD or floppy images, depending on the @a mediumType argument.
+ * If both ID and file path are specified, the first object that matches either
+ * of them (not necessarily both) is returned.
+ *
+ * @param mediumType Must be either DeviceType_DVD or DeviceType_Floppy.
+ * @param aId       ID of the image file (unused when NULL).
+ * @param aLocation Full path to the image file (unused when NULL).
+ * @param aSetError If @c true, the appropriate error info is set in case when
+ *                  the image is not found.
+ * @param aImage    Where to store the found image object (can be NULL).
+ *
+ * @return S_OK when found or E_INVALIDARG or VBOX_E_OBJECT_NOT_FOUND when not found.
+ *
+ * @note Locks the media tree for reading.
+ */
+HRESULT VirtualBox::i_findDVDOrFloppyImage(DeviceType_T mediumType,
+                                           const Guid *aId,
+                                           const Utf8Str &aLocation,
+                                           bool aSetError,
+                                           ComObjPtr<Medium> *aImage /* = NULL */)
+{
+    AssertReturn(aId || !aLocation.isEmpty(), E_INVALIDARG);
+
+    Utf8Str location;
+    if (!aLocation.isEmpty())
+    {
+        int vrc = i_calculateFullPath(aLocation, location);
+        if (RT_FAILURE(vrc))
+            return setError(VBOX_E_FILE_ERROR,
+                            tr("Invalid image file location '%s' (%Rrc)"),
+                            aLocation.c_str(),
+                            vrc);
+    }
+
+    MediaOList *pMediaList;
+
+    switch (mediumType)
+    {
+        case DeviceType_DVD:
+            pMediaList = &m->allDVDImages;
+        break;
+
+        case DeviceType_Floppy:
+            pMediaList = &m->allFloppyImages;
+        break;
+
+        default:
+            return E_INVALIDARG;
+    }
+
+    AutoReadLock alock(pMediaList->getLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    bool found = false;
+
+    for (MediaList::const_iterator it = pMediaList->begin();
+         it != pMediaList->end();
+         ++it)
+    {
+        // no AutoCaller, registered image life time is bound to this
+        Medium *pMedium = *it;
+        AutoReadLock imageLock(pMedium COMMA_LOCKVAL_SRC_POS);
+        const Utf8Str &strLocationFull = pMedium->i_getLocationFull();
+
+        found =     (    aId
+                      && pMedium->i_getId() == *aId)
+                 || (    !aLocation.isEmpty()
+                      && RTPathCompare(location.c_str(),
+                                       strLocationFull.c_str()) == 0);
+        if (found)
+        {
+            if (pMedium->i_getDeviceType() != mediumType)
+            {
+                if (mediumType == DeviceType_DVD)
+                    return setError(E_INVALIDARG,
+                                    tr("Cannot mount DVD medium '%s' as floppy"), strLocationFull.c_str());
+                else
+                    return setError(E_INVALIDARG,
+                                    tr("Cannot mount floppy medium '%s' as DVD"), strLocationFull.c_str());
+            }
+
+            if (aImage)
+                *aImage = pMedium;
+            break;
+        }
+    }
+
+    HRESULT hrc = found ? S_OK : VBOX_E_OBJECT_NOT_FOUND;
+
+    if (aSetError && !found)
+    {
+        if (aId)
+            setError(hrc,
+                     tr("Could not find an image file with UUID {%RTuuid} in the media registry ('%s')"),
+                     aId->raw(),
+                     m->strSettingsFilePath.c_str());
+        else
+            setError(hrc,
+                     tr("Could not find an image file with location '%s' in the media registry ('%s')"),
+                     aLocation.c_str(),
+                     m->strSettingsFilePath.c_str());
+    }
+
+    return hrc;
+}
+
+/**
+ * Searches for an IMedium object that represents the given UUID.
+ *
+ * If the UUID is empty (indicating an empty drive), this sets pMedium
+ * to NULL and returns S_OK.
+ *
+ * If the UUID refers to a host drive of the given device type, this
+ * sets pMedium to the object from the list in IHost and returns S_OK.
+ *
+ * If the UUID is an image file, this sets pMedium to the object that
+ * findDVDOrFloppyImage() returned.
+ *
+ * If none of the above apply, this returns VBOX_E_OBJECT_NOT_FOUND.
+ *
+ * @param mediumType Must be DeviceType_DVD or DeviceType_Floppy.
+ * @param uuid UUID to search for; must refer to a host drive or an image file or be null.
+ * @param fRefresh Whether to refresh the list of host drives in IHost (see Host::getDrives())
+ * @param aSetError
+ * @param pMedium out: IMedium object found.
+ * @return
+ */
+HRESULT VirtualBox::i_findRemoveableMedium(DeviceType_T mediumType,
+                                           const Guid &uuid,
+                                           bool fRefresh,
+                                           bool aSetError,
+                                           ComObjPtr<Medium> &pMedium)
+{
+    if (uuid.isZero())
+    {
+        // that's easy
+        pMedium.setNull();
+        return S_OK;
+    }
+    else if (!uuid.isValid())
+    {
+        /* handling of case invalid GUID */
+        return setError(VBOX_E_OBJECT_NOT_FOUND,
+                            tr("Guid '%s' is invalid"),
+                            uuid.toString().c_str());
+    }
+
+    // first search for host drive with that UUID
+    HRESULT hrc = m->pHost->i_findHostDriveById(mediumType, uuid, fRefresh, pMedium);
+    if (hrc == VBOX_E_OBJECT_NOT_FOUND)
+                // then search for an image with that UUID
+        hrc = i_findDVDOrFloppyImage(mediumType, &uuid, Utf8Str::Empty, aSetError, &pMedium);
+
+    return hrc;
+}
+
+/* Look for a GuestOSType object */
+HRESULT VirtualBox::i_findGuestOSType(const Utf8Str &strOSType,
+                                      ComObjPtr<GuestOSType> &guestOSType)
+{
+    guestOSType.setNull();
+
+    AssertMsg(m->allGuestOSTypes.size() != 0,
+              ("Guest OS types array must be filled"));
+
+    AutoReadLock alock(m->allGuestOSTypes.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+    for (GuestOSTypesOList::const_iterator it = m->allGuestOSTypes.begin();
+         it != m->allGuestOSTypes.end();
+         ++it)
+    {
+        const Utf8Str &typeId = (*it)->i_id();
+        AssertMsg(!typeId.isEmpty(), ("ID must not be NULL"));
+        if (strOSType.compare(typeId, Utf8Str::CaseInsensitive) == 0)
+        {
+            guestOSType = *it;
+            return S_OK;
+        }
+    }
+
+    return setError(VBOX_E_OBJECT_NOT_FOUND,
+                    tr("'%s' is not a valid Guest OS type"),
+                    strOSType.c_str());
+}
+
+/**
+ * Returns the constant pseudo-machine UUID that is used to identify the
+ * global media registry.
+ *
+ * Starting with VirtualBox 4.0 each medium remembers in its instance data
+ * in which media registry it is saved (if any): this can either be a machine
+ * UUID, if it's in a per-machine media registry, or this global ID.
+ *
+ * This UUID is only used to identify the VirtualBox object while VirtualBox
+ * is running. It is a compile-time constant and not saved anywhere.
+ *
+ * @return
+ */
+const Guid& VirtualBox::i_getGlobalRegistryId() const
+{
+    return m->uuidMediaRegistry;
+}
+
+const ComObjPtr<Host>& VirtualBox::i_host() const
+{
+    return m->pHost;
+}
+
+SystemProperties* VirtualBox::i_getSystemProperties() const
+{
+    return m->pSystemProperties;
+}
+
+CloudProviderManager *VirtualBox::i_getCloudProviderManager() const
+{
+    return m->pCloudProviderManager;
+}
+
+#ifdef VBOX_WITH_EXTPACK
+/**
+ * Getter that SystemProperties and others can use to talk to the extension
+ * pack manager.
+ */
+ExtPackManager* VirtualBox::i_getExtPackManager() const
+{
+    return m->ptrExtPackManager;
+}
+#endif
+
+/**
+ * Getter that machines can talk to the autostart database.
+ */
+AutostartDb* VirtualBox::i_getAutostartDb() const
+{
+    return m->pAutostartDb;
+}
+
+#ifdef VBOX_WITH_RESOURCE_USAGE_API
+const ComObjPtr<PerformanceCollector>& VirtualBox::i_performanceCollector() const
+{
+    return m->pPerformanceCollector;
+}
+#endif /* VBOX_WITH_RESOURCE_USAGE_API */
+
+/**
+ * Returns the default machine folder from the system properties
+ * with proper locking.
+ */
+void VirtualBox::i_getDefaultMachineFolder(Utf8Str &str) const
+{
+    AutoReadLock propsLock(m->pSystemProperties COMMA_LOCKVAL_SRC_POS);
+    str = m->pSystemProperties->m->strDefaultMachineFolder;
+}
+
+/**
+ * Returns the default hard disk format from the system properties
+ * with proper locking.
+ */
+void VirtualBox::i_getDefaultHardDiskFormat(Utf8Str &str) const
+{
+    AutoReadLock propsLock(m->pSystemProperties COMMA_LOCKVAL_SRC_POS);
+    str = m->pSystemProperties->m->strDefaultHardDiskFormat;
+}
+
+const Utf8Str& VirtualBox::i_homeDir() const
+{
+    return m->strHomeDir;
+}
+
+/**
+ * Calculates the absolute path of the given path taking the VirtualBox home
+ * directory as the current directory.
+ *
+ * @param  strPath  Path to calculate the absolute path for.
+ * @param  aResult  Where to put the result (used only on success, can be the
+ *                  same Utf8Str instance as passed in @a aPath).
+ * @return IPRT result.
+ *
+ * @note Doesn't lock any object.
+ */
+int VirtualBox::i_calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult)
+{
+    AutoCaller autoCaller(this);
+    AssertComRCReturn(autoCaller.hrc(), VERR_GENERAL_FAILURE);
+
+    /* no need to lock since strHomeDir is const */
+
+    char szFolder[RTPATH_MAX];
+    size_t cbFolder = sizeof(szFolder);
+    int vrc = RTPathAbsEx(m->strHomeDir.c_str(),
+                          strPath.c_str(),
+                          RTPATH_STR_F_STYLE_HOST,
+                          szFolder,
+                          &cbFolder);
+    if (RT_SUCCESS(vrc))
+        aResult = szFolder;
+
+    return vrc;
+}
+
+/**
+ * Copies strSource to strTarget, making it relative to the VirtualBox config folder
+ * if it is a subdirectory thereof, or simply copying it otherwise.
+ *
+ * @param strSource Path to evalue and copy.
+ * @param strTarget Buffer to receive target path.
+ */
+void VirtualBox::i_copyPathRelativeToConfig(const Utf8Str &strSource,
+                                            Utf8Str &strTarget)
+{
+    AutoCaller autoCaller(this);
+    AssertComRCReturnVoid(autoCaller.hrc());
+
+    // no need to lock since mHomeDir is const
+
+    // use strTarget as a temporary buffer to hold the machine settings dir
+    strTarget = m->strHomeDir;
+    if (RTPathStartsWith(strSource.c_str(), strTarget.c_str()))
+        // is relative: then append what's left
+        strTarget.append(strSource.c_str() + strTarget.length());     // include '/'
+    else
+        // is not relative: then overwrite
+        strTarget = strSource;
+}
+
+// private methods
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Checks if there is a hard disk, DVD or floppy image with the given ID or
+ * location already registered.
+ *
+ * On return, sets @a aConflict to the string describing the conflicting medium,
+ * or sets it to @c Null if no conflicting media is found. Returns S_OK in
+ * either case. A failure is unexpected.
+ *
+ * @param aId           UUID to check.
+ * @param aLocation     Location to check.
+ * @param aConflict     Where to return parameters of the conflicting medium.
+ * @param ppMedium      Medium reference in case this is simply a duplicate.
+ *
+ * @note Locks the media tree and media objects for reading.
+ */
+HRESULT VirtualBox::i_checkMediaForConflicts(const Guid &aId,
+                                             const Utf8Str &aLocation,
+                                             Utf8Str &aConflict,
+                                             ComObjPtr<Medium> *ppMedium)
+{
+    AssertReturn(!aId.isZero() && !aLocation.isEmpty(), E_FAIL);
+    AssertReturn(ppMedium, E_INVALIDARG);
+
+    aConflict.setNull();
+    ppMedium->setNull();
+
+    AutoReadLock alock(i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    HRESULT hrc = S_OK;
+
+    ComObjPtr<Medium> pMediumFound;
+    const char *pcszType = NULL;
+
+    if (aId.isValid() && !aId.isZero())
+        hrc = i_findHardDiskById(aId, false /* aSetError */, &pMediumFound);
+    if (FAILED(hrc) && !aLocation.isEmpty())
+        hrc = i_findHardDiskByLocation(aLocation, false /* aSetError */, &pMediumFound);
+    if (SUCCEEDED(hrc))
+        pcszType = tr("hard disk");
+
+    if (!pcszType)
+    {
+        hrc = i_findDVDOrFloppyImage(DeviceType_DVD, &aId, aLocation, false /* aSetError */, &pMediumFound);
+        if (SUCCEEDED(hrc))
+            pcszType = tr("CD/DVD image");
+    }
+
+    if (!pcszType)
+    {
+        hrc = i_findDVDOrFloppyImage(DeviceType_Floppy, &aId, aLocation, false /* aSetError */, &pMediumFound);
+        if (SUCCEEDED(hrc))
+            pcszType = tr("floppy image");
+    }
+
+    if (pcszType && pMediumFound)
+    {
+        /* Note: no AutoCaller since bound to this */
+        AutoReadLock mlock(pMediumFound COMMA_LOCKVAL_SRC_POS);
+
+        Utf8Str strLocFound = pMediumFound->i_getLocationFull();
+        Guid idFound = pMediumFound->i_getId();
+
+        if (    (RTPathCompare(strLocFound.c_str(), aLocation.c_str()) == 0)
+             && (idFound == aId)
+           )
+            *ppMedium = pMediumFound;
+
+        aConflict = Utf8StrFmt(tr("%s '%s' with UUID {%RTuuid}"),
+                               pcszType,
+                               strLocFound.c_str(),
+                               idFound.raw());
+    }
+
+    return S_OK;
+}
+
+/**
+ * Checks whether the given UUID is already in use by one medium for the
+ * given device type.
+ *
+ * @returns true if the UUID is already in use
+ *          fale otherwise
+ * @param   aId           The UUID to check.
+ * @param   deviceType    The device type the UUID is going to be checked for
+ *                        conflicts.
+ */
+bool VirtualBox::i_isMediaUuidInUse(const Guid &aId, DeviceType_T deviceType)
+{
+    /* A zero UUID is invalid here, always claim that it is already used. */
+    AssertReturn(!aId.isZero(), true);
+
+    AutoReadLock alock(i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    bool fInUse = false;
+
+    ComObjPtr<Medium> pMediumFound;
+
+    HRESULT hrc;
+    switch (deviceType)
+    {
+        case DeviceType_HardDisk:
+            hrc = i_findHardDiskById(aId, false /* aSetError */, &pMediumFound);
+            break;
+        case DeviceType_DVD:
+            hrc = i_findDVDOrFloppyImage(DeviceType_DVD, &aId, Utf8Str::Empty, false /* aSetError */, &pMediumFound);
+            break;
+        case DeviceType_Floppy:
+            hrc = i_findDVDOrFloppyImage(DeviceType_Floppy, &aId, Utf8Str::Empty, false /* aSetError */, &pMediumFound);
+            break;
+        default:
+            AssertMsgFailed(("Invalid device type %d\n", deviceType));
+            hrc = S_OK;
+            break;
+    }
+
+    if (SUCCEEDED(hrc) && pMediumFound)
+        fInUse = true;
+
+    return fInUse;
+}
+
+/**
+ * Called from Machine::prepareSaveSettings() when it has detected
+ * that a machine has been renamed. Such renames will require
+ * updating the global media registry during the
+ * VirtualBox::i_saveSettings() that follows later.
+*
+ * When a machine is renamed, there may well be media (in particular,
+ * diff images for snapshots) in the global registry that will need
+ * to have their paths updated. Before 3.2, Machine::saveSettings
+ * used to call VirtualBox::i_saveSettings implicitly, which was both
+ * unintuitive and caused locking order problems. Now, we remember
+ * such pending name changes with this method so that
+ * VirtualBox::i_saveSettings() can process them properly.
+ */
+void VirtualBox::i_rememberMachineNameChangeForMedia(const Utf8Str &strOldConfigDir,
+                                                     const Utf8Str &strNewConfigDir)
+{
+    AutoWriteLock mediaLock(i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    Data::PendingMachineRename pmr;
+    pmr.strConfigDirOld = strOldConfigDir;
+    pmr.strConfigDirNew = strNewConfigDir;
+    m->llPendingMachineRenames.push_back(pmr);
+}
+
+static DECLCALLBACK(int) fntSaveMediaRegistries(void *pvUser);
+
+class SaveMediaRegistriesDesc : public ThreadTask
+{
+
+public:
+    SaveMediaRegistriesDesc()
+    {
+        m_strTaskName = "SaveMediaReg";
+    }
+    virtual ~SaveMediaRegistriesDesc(void) { }
+
+private:
+    void handler()
+    {
+        try
+        {
+            fntSaveMediaRegistries(this);
+        }
+        catch(...)
+        {
+            LogRel(("Exception in the function fntSaveMediaRegistries()\n"));
+        }
+    }
+
+    MediaList llMedia;
+    ComObjPtr<VirtualBox> pVirtualBox;
+
+    friend DECLCALLBACK(int) fntSaveMediaRegistries(void *pvUser);
+    friend void VirtualBox::i_saveMediaRegistry(settings::MediaRegistry &mediaRegistry,
+                                                const Guid &uuidRegistry,
+                                                const Utf8Str &strMachineFolder);
+};
+
+DECLCALLBACK(int) fntSaveMediaRegistries(void *pvUser)
+{
+    SaveMediaRegistriesDesc *pDesc = (SaveMediaRegistriesDesc *)pvUser;
+    if (!pDesc)
+    {
+        LogRelFunc(("Thread for saving media registries lacks parameters\n"));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    for (MediaList::const_iterator it = pDesc->llMedia.begin();
+         it != pDesc->llMedia.end();
+         ++it)
+    {
+        Medium *pMedium = *it;
+        pMedium->i_markRegistriesModified();
+    }
+
+    pDesc->pVirtualBox->i_saveModifiedRegistries();
+
+    pDesc->llMedia.clear();
+    pDesc->pVirtualBox.setNull();
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Goes through all known media (hard disks, floppies and DVDs) and saves
+ * those into the given settings::MediaRegistry structures whose registry
+ * ID match the given UUID.
+ *
+ * Before actually writing to the structures, all media paths (not just the
+ * ones for the given registry) are updated if machines have been renamed
+ * since the last call.
+ *
+ * This gets called from two contexts:
+ *
+ *  -- VirtualBox::i_saveSettings() with the UUID of the global registry
+ *     (VirtualBox::Data.uuidRegistry); this will save those media
+ *     which had been loaded from the global registry or have been
+ *     attached to a "legacy" machine which can't save its own registry;
+ *
+ *  -- Machine::saveSettings() with the UUID of a machine, if a medium
+ *     has been attached to a machine created with VirtualBox 4.0 or later.
+ *
+ * Media which have only been temporarily opened without having been
+ * attached to a machine have a NULL registry UUID and therefore don't
+ * get saved.
+ *
+ * This locks the media tree. Throws HRESULT on errors!
+ *
+ * @param mediaRegistry Settings structure to fill.
+ * @param uuidRegistry The UUID of the media registry; either a machine UUID
+ *        (if machine registry) or the UUID of the global registry.
+ * @param strMachineFolder The machine folder for relative paths, if machine registry, or an empty string otherwise.
+ */
+void VirtualBox::i_saveMediaRegistry(settings::MediaRegistry &mediaRegistry,
+                                     const Guid &uuidRegistry,
+                                     const Utf8Str &strMachineFolder)
+{
+    // lock all media for the following; use a write lock because we're
+    // modifying the PendingMachineRenamesList, which is protected by this
+    AutoWriteLock mediaLock(i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    // if a machine was renamed, then we'll need to refresh media paths
+    if (m->llPendingMachineRenames.size())
+    {
+        // make a single list from the three media lists so we don't need three loops
+        MediaList llAllMedia;
+        // with hard disks, we must use the map, not the list, because the list only has base images
+        for (HardDiskMap::iterator it = m->mapHardDisks.begin(); it != m->mapHardDisks.end(); ++it)
+            llAllMedia.push_back(it->second);
+        for (MediaList::iterator it = m->allDVDImages.begin(); it != m->allDVDImages.end(); ++it)
+            llAllMedia.push_back(*it);
+        for (MediaList::iterator it = m->allFloppyImages.begin(); it != m->allFloppyImages.end(); ++it)
+            llAllMedia.push_back(*it);
+
+        SaveMediaRegistriesDesc *pDesc = new SaveMediaRegistriesDesc();
+        for (MediaList::iterator it = llAllMedia.begin();
+             it != llAllMedia.end();
+             ++it)
+        {
+            Medium *pMedium = *it;
+            for (Data::PendingMachineRenamesList::iterator it2 = m->llPendingMachineRenames.begin();
+                 it2 != m->llPendingMachineRenames.end();
+                 ++it2)
+            {
+                const Data::PendingMachineRename &pmr = *it2;
+                HRESULT hrc = pMedium->i_updatePath(pmr.strConfigDirOld, pmr.strConfigDirNew);
+                if (SUCCEEDED(hrc))
+                {
+                    // Remember which medium objects has been changed,
+                    // to trigger saving their registries later.
+                    pDesc->llMedia.push_back(pMedium);
+                } else if (hrc == VBOX_E_FILE_ERROR)
+                    /* nothing */;
+                else
+                    AssertComRC(hrc);
+            }
+        }
+        // done, don't do it again until we have more machine renames
+        m->llPendingMachineRenames.clear();
+
+        if (pDesc->llMedia.size())
+        {
+            // Handle the media registry saving in a separate thread, to
+            // avoid giant locking problems and passing up the list many
+            // levels up to whoever triggered saveSettings, as there are
+            // lots of places which would need to handle saving more settings.
+            pDesc->pVirtualBox = this;
+
+            //the function createThread() takes ownership of pDesc
+            //so there is no need to use delete operator for pDesc
+            //after calling this function
+            HRESULT hrc = pDesc->createThread();
+            pDesc = NULL;
+
+            if (FAILED(hrc))
+            {
+                // failure means that settings aren't saved, but there isn't
+                // much we can do besides avoiding memory leaks
+                LogRelFunc(("Failed to create thread for saving media registries (%Rhr)\n", hrc));
+            }
+        }
+        else
+            delete pDesc;
+    }
+
+    struct {
+        MediaOList &llSource;
+        settings::MediaList &llTarget;
+    } s[] =
+    {
+        // hard disks
+        { m->allHardDisks, mediaRegistry.llHardDisks },
+        // CD/DVD images
+        { m->allDVDImages, mediaRegistry.llDvdImages },
+        // floppy images
+        { m->allFloppyImages, mediaRegistry.llFloppyImages }
+    };
+
+    for (size_t i = 0; i < RT_ELEMENTS(s); ++i)
+    {
+        MediaOList &llSource = s[i].llSource;
+        settings::MediaList &llTarget = s[i].llTarget;
+        llTarget.clear();
+        for (MediaList::const_iterator it = llSource.begin();
+             it != llSource.end();
+             ++it)
+        {
+            Medium *pMedium = *it;
+            AutoCaller autoCaller(pMedium);
+            if (FAILED(autoCaller.hrc())) throw autoCaller.hrc();
+            AutoReadLock mlock(pMedium COMMA_LOCKVAL_SRC_POS);
+
+            if (pMedium->i_isInRegistry(uuidRegistry))
+            {
+                llTarget.push_back(settings::Medium::Empty);
+                HRESULT hrc = pMedium->i_saveSettings(llTarget.back(), strMachineFolder); // this recurses into child hard disks
+                if (FAILED(hrc))
+                {
+                    llTarget.pop_back();
+                    throw hrc;
+                }
+            }
+        }
+    }
+}
+
+/**
+ *  Helper function which actually writes out VirtualBox.xml, the main configuration file.
+ *  Gets called from the public VirtualBox::SaveSettings() as well as from various other
+ *  places internally when settings need saving.
+ *
+ *  @note Caller must have locked the VirtualBox object for writing and must not hold any
+ *    other locks since this locks all kinds of member objects and trees temporarily,
+ *    which could cause conflicts.
+ */
+HRESULT VirtualBox::i_saveSettings()
+{
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
+    AssertReturn(!m->strSettingsFilePath.isEmpty(), E_FAIL);
+
+    i_unmarkRegistryModified(i_getGlobalRegistryId());
+
+    HRESULT hrc = S_OK;
+
+    try
+    {
+        // machines
+        m->pMainConfigFile->llMachines.clear();
+        {
+            AutoReadLock machinesLock(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+            for (MachinesOList::iterator it = m->allMachines.begin();
+                 it != m->allMachines.end();
+                 ++it)
+            {
+                Machine *pMachine = *it;
+                // save actual machine registry entry
+                settings::MachineRegistryEntry mre;
+                hrc = pMachine->i_saveRegistryEntry(mre);
+                m->pMainConfigFile->llMachines.push_back(mre);
+            }
+        }
+
+        i_saveMediaRegistry(m->pMainConfigFile->mediaRegistry,
+                            m->uuidMediaRegistry,         // global media registry ID
+                            Utf8Str::Empty);              // strMachineFolder
+
+        m->pMainConfigFile->llDhcpServers.clear();
+        {
+            AutoReadLock dhcpLock(m->allDHCPServers.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+            for (DHCPServersOList::const_iterator it = m->allDHCPServers.begin();
+                 it != m->allDHCPServers.end();
+                 ++it)
+            {
+                settings::DHCPServer d;
+                hrc = (*it)->i_saveSettings(d);
+                if (FAILED(hrc)) throw hrc;
+                m->pMainConfigFile->llDhcpServers.push_back(d);
+            }
+        }
+
+#ifdef VBOX_WITH_NAT_SERVICE
+        /* Saving NAT Network configuration */
+        m->pMainConfigFile->llNATNetworks.clear();
+        {
+            AutoReadLock natNetworkLock(m->allNATNetworks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+            for (NATNetworksOList::const_iterator it = m->allNATNetworks.begin();
+                 it != m->allNATNetworks.end();
+                 ++it)
+            {
+                settings::NATNetwork n;
+                hrc = (*it)->i_saveSettings(n);
+                if (FAILED(hrc)) throw hrc;
+                m->pMainConfigFile->llNATNetworks.push_back(n);
+            }
+        }
+#endif
+
+#ifdef VBOX_WITH_VMNET
+        m->pMainConfigFile->llHostOnlyNetworks.clear();
+        {
+            AutoReadLock hostOnlyNetworkLock(m->allHostOnlyNetworks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+            for (HostOnlyNetworksOList::const_iterator it = m->allHostOnlyNetworks.begin();
+                 it != m->allHostOnlyNetworks.end();
+                 ++it)
+            {
+                settings::HostOnlyNetwork n;
+                hrc = (*it)->i_saveSettings(n);
+                if (FAILED(hrc)) throw hrc;
+                m->pMainConfigFile->llHostOnlyNetworks.push_back(n);
+            }
+        }
+#endif /* VBOX_WITH_VMNET */
+
+#ifdef VBOX_WITH_CLOUD_NET
+        m->pMainConfigFile->llCloudNetworks.clear();
+        {
+            AutoReadLock cloudNetworkLock(m->allCloudNetworks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+            for (CloudNetworksOList::const_iterator it = m->allCloudNetworks.begin();
+                 it != m->allCloudNetworks.end();
+                 ++it)
+            {
+                settings::CloudNetwork n;
+                hrc = (*it)->i_saveSettings(n);
+                if (FAILED(hrc)) throw hrc;
+                m->pMainConfigFile->llCloudNetworks.push_back(n);
+            }
+        }
+#endif /* VBOX_WITH_CLOUD_NET */
+        // leave extra data alone, it's still in the config file
+
+        // host data (USB filters)
+        hrc = m->pHost->i_saveSettings(m->pMainConfigFile->host);
+        if (FAILED(hrc)) throw hrc;
+
+        hrc = m->pSystemProperties->i_saveSettings(m->pMainConfigFile->systemProperties);
+        if (FAILED(hrc)) throw hrc;
+
+        // and write out the XML, still under the lock
+        m->pMainConfigFile->write(m->strSettingsFilePath);
+    }
+    catch (HRESULT hrcXcpt)
+    {
+        /* we assume that error info is set by the thrower */
+        hrc = hrcXcpt;
+    }
+    catch (...)
+    {
+        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
+    }
+
+    return hrc;
+}
+
+/**
+ *  Helper to register the machine.
+ *
+ *  When called during VirtualBox startup, adds the given machine to the
+ *  collection of registered machines. Otherwise tries to mark the machine
+ *  as registered, and, if succeeded, adds it to the collection and
+ *  saves global settings.
+ *
+ *  @note The caller must have added itself as a caller of the @a aMachine
+ *  object if calls this method not on VirtualBox startup.
+ *
+ *  @param aMachine     machine to register
+ *
+ *  @note Locks objects!
+ */
+HRESULT VirtualBox::i_registerMachine(Machine *aMachine)
+{
+    ComAssertRet(aMachine, E_INVALIDARG);
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
+
+    HRESULT hrc = S_OK;
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    {
+        ComObjPtr<Machine> pMachine;
+        hrc = i_findMachine(aMachine->i_getId(),
+                            true /* fPermitInaccessible */,
+                            false /* aDoSetError */,
+                            &pMachine);
+        if (SUCCEEDED(hrc))
+        {
+            /* sanity */
+            AutoLimitedCaller machCaller(pMachine);
+            AssertComRC(machCaller.hrc());
+
+            return setError(E_INVALIDARG,
+                            tr("Registered machine with UUID {%RTuuid} ('%s') already exists"),
+                            aMachine->i_getId().raw(),
+                            pMachine->i_getSettingsFileFull().c_str());
+        }
+
+        ComAssertRet(hrc == VBOX_E_OBJECT_NOT_FOUND, hrc);
+        hrc = S_OK;
+    }
+
+    if (getObjectState().getState() != ObjectState::InInit)
+    {
+        hrc = aMachine->i_prepareRegister();
+        if (FAILED(hrc)) return hrc;
+    }
+
+    /* add to the collection of registered machines */
+    m->allMachines.addChild(aMachine);
+
+    if (getObjectState().getState() != ObjectState::InInit)
+        hrc = i_saveSettings();
+
+    return hrc;
+}
+
+/**
+ * Remembers the given medium object by storing it in either the global
+ * medium registry or a machine one.
+ *
+ * @note Caller must hold the media tree lock for writing; in addition, this
+ * locks @a pMedium for reading
+ *
+ * @param pMedium   Medium object to remember.
+ * @param ppMedium  Actually stored medium object. Can be different if due
+ *                  to an unavoidable race there was a duplicate Medium object
+ *                  created.
+ * @param mediaTreeLock Reference to the AutoWriteLock holding the media tree
+ *                  lock, necessary to release it in the right spot.
+ * @param fCalledFromMediumInit Flag whether this is called from Medium::init().
+ * @return
+ */
+HRESULT VirtualBox::i_registerMedium(const ComObjPtr<Medium> &pMedium,
+                                     ComObjPtr<Medium> *ppMedium,
+                                     AutoWriteLock &mediaTreeLock,
+                                     bool fCalledFromMediumInit)
+{
+    AssertReturn(pMedium != NULL, E_INVALIDARG);
+    AssertReturn(ppMedium != NULL, E_INVALIDARG);
+
+    // caller must hold the media tree write lock
+    Assert(i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    AutoCaller mediumCaller(pMedium);
+    AssertComRCReturnRC(mediumCaller.hrc());
+
+    bool fAddToGlobalRegistry = false;
+    const char *pszDevType = NULL;
+    Guid regId;
+    ObjectsList<Medium> *pall = NULL;
+    DeviceType_T devType;
+    {
+        AutoReadLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
+        devType = pMedium->i_getDeviceType();
+
+        if (!pMedium->i_getFirstRegistryMachineId(regId))
+            fAddToGlobalRegistry = true;
+    }
+    switch (devType)
+    {
+        case DeviceType_HardDisk:
+            pall = &m->allHardDisks;
+            pszDevType = tr("hard disk");
+            break;
+        case DeviceType_DVD:
+            pszDevType = tr("DVD image");
+            pall = &m->allDVDImages;
+            break;
+        case DeviceType_Floppy:
+            pszDevType = tr("floppy image");
+            pall = &m->allFloppyImages;
+            break;
+        default:
+            AssertMsgFailedReturn(("invalid device type %d", devType), E_INVALIDARG);
+    }
+
+    Guid id;
+    Utf8Str strLocationFull;
+    ComObjPtr<Medium> pParent;
+    {
+        AutoReadLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
+        id = pMedium->i_getId();
+        strLocationFull = pMedium->i_getLocationFull();
+        pParent = pMedium->i_getParent();
+
+        /*
+         * If a separate thread has called Medium::close() for this medium at the same
+         * time as this i_registerMedium() call then there is a window of opportunity in
+         * Medium::i_close() where the media tree lock is dropped before calling
+         * Medium::uninit() (which reacquires the lock) that we can end up here attempting
+         * to register a medium which is in the process of being closed.  In addition, if
+         * this is a differencing medium and Medium::close() is in progress for one its
+         * parent media then we are similarly operating on a media registry in flux.  In
+         * either case registering a medium just before calling Medium::uninit() will
+         * lead to an inconsistent media registry so bail out here since Medium::close()
+         * got to this medium (or one of its parents) first.
+         */
+        if (devType == DeviceType_HardDisk)
+        {
+            ComObjPtr<Medium> pTmpMedium = pMedium;
+            while (pTmpMedium.isNotNull())
+            {
+                AutoCaller mediumAC(pTmpMedium);
+                if (FAILED(mediumAC.hrc())) return mediumAC.hrc();
+                AutoReadLock mlock(pTmpMedium COMMA_LOCKVAL_SRC_POS);
+
+                if (pTmpMedium->i_isClosing())
+                    return setError(E_INVALIDARG,
+                                    tr("Cannot register %s '%s' {%RTuuid} because it is in the process of being closed"),
+                                    pszDevType,
+                                    pTmpMedium->i_getLocationFull().c_str(),
+                                    pTmpMedium->i_getId().raw());
+
+                pTmpMedium = pTmpMedium->i_getParent();
+            }
+        }
+    }
+
+    HRESULT hrc;
+
+    Utf8Str strConflict;
+    ComObjPtr<Medium> pDupMedium;
+    hrc = i_checkMediaForConflicts(id, strLocationFull, strConflict, &pDupMedium);
+    if (FAILED(hrc)) return hrc;
+
+    if (pDupMedium.isNull())
+    {
+        if (strConflict.length())
+            return setError(E_INVALIDARG,
+                            tr("Cannot register the %s '%s' {%RTuuid} because a %s already exists"),
+                            pszDevType,
+                            strLocationFull.c_str(),
+                            id.raw(),
+                            strConflict.c_str(),
+                            m->strSettingsFilePath.c_str());
+
+        // add to the collection if it is a base medium
+        if (pParent.isNull())
+            pall->getList().push_back(pMedium);
+
+        // store all hard disks (even differencing images) in the map
+        if (devType == DeviceType_HardDisk)
+            m->mapHardDisks[id] = pMedium;
+    }
+
+    /*
+     * If we have been called from Medium::initFromSettings() then the Medium object's
+     * AutoCaller status will be 'InInit' which means that when making the assigment to
+     * ppMedium below the Medium object will not call Medium::uninit().  By excluding
+     * this code path from releasing and reacquiring the media tree lock we avoid a
+     * potential deadlock with other threads which may be operating on the
+     * disks/DVDs/floppies in the VM's media registry at the same time such as
+     * Machine::unregister().
+     */
+    if (!fCalledFromMediumInit)
+    {
+        // pMedium may be the last reference to the Medium object, and the
+        // caller may have specified the same ComObjPtr as the output parameter.
+        // In this case the assignment will uninit the object, and we must not
+        // have a caller pending.
+        mediumCaller.release();
+        // release media tree lock, must not be held at uninit time.
+        mediaTreeLock.release();
+        // must not hold the media tree write lock any more
+        Assert(!i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
+    }
+
+    *ppMedium = pDupMedium.isNull() ? pMedium : pDupMedium;
+
+    if (fAddToGlobalRegistry)
+    {
+        AutoWriteLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
+        if (  fCalledFromMediumInit
+            ? (*ppMedium)->i_addRegistryNoCallerCheck(m->uuidMediaRegistry)
+            : (*ppMedium)->i_addRegistry(m->uuidMediaRegistry))
+            i_markRegistryModified(m->uuidMediaRegistry);
+    }
+
+    // Restore the initial lock state, so that no unexpected lock changes are
+    // done by this method, which would need adjustments everywhere.
+    if (!fCalledFromMediumInit)
+        mediaTreeLock.acquire();
+
+    return hrc;
+}
+
+/**
+ * Removes the given medium from the respective registry.
+ *
+ * @param pMedium    Hard disk object to remove.
+ *
+ * @note Caller must hold the media tree lock for writing; in addition, this locks @a pMedium for reading
+ */
+HRESULT VirtualBox::i_unregisterMedium(Medium *pMedium)
+{
+    AssertReturn(pMedium != NULL, E_INVALIDARG);
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    AutoCaller mediumCaller(pMedium);
+    AssertComRCReturnRC(mediumCaller.hrc());
+
+    // caller must hold the media tree write lock
+    Assert(i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
+
+    Guid id;
+    ComObjPtr<Medium> pParent;
+    DeviceType_T devType;
+    {
+        AutoReadLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
+        id = pMedium->i_getId();
+        pParent = pMedium->i_getParent();
+        devType = pMedium->i_getDeviceType();
+    }
+
+    ObjectsList<Medium> *pall = NULL;
+    switch (devType)
+    {
+        case DeviceType_HardDisk:
+            pall = &m->allHardDisks;
+            break;
+        case DeviceType_DVD:
+            pall = &m->allDVDImages;
+            break;
+        case DeviceType_Floppy:
+            pall = &m->allFloppyImages;
+            break;
+        default:
+            AssertMsgFailedReturn(("invalid device type %d", devType), E_INVALIDARG);
+    }
+
+    // remove from the collection if it is a base medium
+    if (pParent.isNull())
+        pall->getList().remove(pMedium);
+
+    // remove all hard disks (even differencing images) from map
+    if (devType == DeviceType_HardDisk)
+    {
+        size_t cnt = m->mapHardDisks.erase(id);
+        Assert(cnt == 1);
+        NOREF(cnt);
+    }
+
+    return S_OK;
+}
+
+/**
+ * Unregisters all Medium objects which belong to the given machine registry.
+ * Gets called from Machine::uninit() just before the machine object dies
+ * and must only be called with a machine UUID as the registry ID.
+ *
+ * Locks the media tree.
+ *
+ * @param uuidMachine Medium registry ID (always a machine UUID)
+ * @return
+ */
+HRESULT VirtualBox::i_unregisterMachineMedia(const Guid &uuidMachine)
+{
+    Assert(!uuidMachine.isZero() && uuidMachine.isValid());
+
+    LogFlowFuncEnter();
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    MediaList llMedia2Close;
+
+    {
+        AutoWriteLock tlock(i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+        for (MediaOList::iterator it = m->allHardDisks.getList().begin();
+             it != m->allHardDisks.getList().end();
+             ++it)
+        {
+            ComObjPtr<Medium> pMedium = *it;
+            AutoCaller medCaller(pMedium);
+            if (FAILED(medCaller.hrc())) return medCaller.hrc();
+            AutoReadLock medlock(pMedium COMMA_LOCKVAL_SRC_POS);
+            Log(("Looking at medium %RTuuid\n", pMedium->i_getId().raw()));
+
+            /* If the medium is still in the registry then either some code is
+             * seriously buggy (unregistering a VM removes it automatically),
+             * or the reference to a Machine object is destroyed without ever
+             * being registered. The second condition checks if a medium is
+             * in no registry, which indicates (set by unregistering) that a
+             * medium is not used by any other VM and thus can be closed. */
+            Guid dummy;
+            if (   pMedium->i_isInRegistry(uuidMachine)
+                || !pMedium->i_getFirstRegistryMachineId(dummy))
+            {
+                /* Collect all medium objects into llMedia2Close,
+                 * in right order for closing. */
+                MediaList llMediaTodo;
+                llMediaTodo.push_back(pMedium);
+
+                while (llMediaTodo.size() > 0)
+                {
+                    ComObjPtr<Medium> pCurrent = llMediaTodo.front();
+                    llMediaTodo.pop_front();
+
+                    /* Add to front, order must be children then parent. */
+                    Log(("Pushing medium %RTuuid (front)\n", pCurrent->i_getId().raw()));
+                    llMedia2Close.push_front(pCurrent);
+
+                    /* process all children */
+                    MediaList::const_iterator itBegin = pCurrent->i_getChildren().begin();
+                    MediaList::const_iterator itEnd = pCurrent->i_getChildren().end();
+                    for (MediaList::const_iterator it2 = itBegin; it2 != itEnd; ++it2)
+                        llMediaTodo.push_back(*it2);
+                }
+            }
+        }
+    }
+
+    for (MediaList::iterator it = llMedia2Close.begin();
+         it != llMedia2Close.end();
+         ++it)
+    {
+        ComObjPtr<Medium> pMedium = *it;
+        Log(("Closing medium %RTuuid\n", pMedium->i_getId().raw()));
+        AutoCaller mac(pMedium);
+        HRESULT hrc = pMedium->i_close(mac);
+        if (FAILED(hrc))
+            return hrc;
+    }
+
+    LogFlowFuncLeave();
+
+    return S_OK;
+}
+
+/**
+ * Removes the given machine object from the internal list of registered machines.
+ * Called from Machine::Unregister().
+ * @param pMachine
+ * @param aCleanupMode  How to handle medium attachments. For
+ *      CleanupMode_UnregisterOnly the associated medium objects will be
+ *      closed when the Machine object is uninitialized, otherwise they will
+ *      go to the global registry if no better registry is found.
+ * @param id  UUID of the machine. Must be passed by caller because machine may be dead by this time.
+ * @return
+ */
+HRESULT VirtualBox::i_unregisterMachine(Machine *pMachine,
+                                        CleanupMode_T aCleanupMode,
+                                        const Guid &id)
+{
+    // remove from the collection of registered machines
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+    m->allMachines.removeChild(pMachine);
+    // save the global registry
+    HRESULT hrc = i_saveSettings();
+    alock.release();
+
+    /*
+     * Now go over all known media and checks if they were registered in the
+     * media registry of the given machine. Each such medium is then moved to
+     * a different media registry to make sure it doesn't get lost since its
+     * media registry is about to go away.
+     *
+     * This fixes the following use case: Image A.vdi of machine A is also used
+     * by machine B, but registered in the media registry of machine A. If machine
+     * A is deleted, A.vdi must be moved to the registry of B, or else B will
+     * become inaccessible.
+     */
+    {
+        AutoReadLock tlock(i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
+        // iterate over the list of *base* images
+        for (MediaOList::iterator it = m->allHardDisks.getList().begin();
+             it != m->allHardDisks.getList().end();
+             ++it)
+        {
+            ComObjPtr<Medium> &pMedium = *it;
+            AutoCaller medCaller(pMedium);
+            if (FAILED(medCaller.hrc())) return medCaller.hrc();
+            AutoWriteLock mlock(pMedium COMMA_LOCKVAL_SRC_POS);
+
+            if (pMedium->i_removeRegistryAll(id))
+            {
+                // machine ID was found in base medium's registry list:
+                // move this base image and all its children to another registry then
+                // 1) first, find a better registry to add things to
+                const Guid *puuidBetter = pMedium->i_getAnyMachineBackref(id);
+                if (puuidBetter)
+                {
+                    // 2) better registry found: then use that
+                    pMedium->i_addRegistryAll(*puuidBetter);
+                    // 3) and make sure the registry is saved below
+                    mlock.release();
+                    tlock.release();
+                    i_markRegistryModified(*puuidBetter);
+                    tlock.acquire();
+                    mlock.acquire();
+                }
+                else if (aCleanupMode != CleanupMode_UnregisterOnly)
+                {
+                    pMedium->i_addRegistryAll(i_getGlobalRegistryId());
+                    mlock.release();
+                    tlock.release();
+                    i_markRegistryModified(i_getGlobalRegistryId());
+                    tlock.acquire();
+                    mlock.acquire();
+                }
+            }
+        }
+    }
+
+    i_saveModifiedRegistries();
+
+    /* fire an event */
+    i_onMachineRegistered(id, FALSE);
+
+    return hrc;
+}
+
+/**
+ * Marks the registry for @a uuid as modified, so that it's saved in a later
+ * call to saveModifiedRegistries().
+ *
+ * @param uuid
+ */
+void VirtualBox::i_markRegistryModified(const Guid &uuid)
+{
+    if (uuid == i_getGlobalRegistryId())
+        ASMAtomicIncU64(&m->uRegistryNeedsSaving);
+    else
+    {
+        ComObjPtr<Machine> pMachine;
+        HRESULT hrc = i_findMachine(uuid, false /* fPermitInaccessible */, false /* aSetError */, &pMachine);
+        if (SUCCEEDED(hrc))
+        {
+            AutoCaller machineCaller(pMachine);
+            if (SUCCEEDED(machineCaller.hrc()) && pMachine->i_isAccessible())
+                ASMAtomicIncU64(&pMachine->uRegistryNeedsSaving);
+        }
+    }
+}
+
+/**
+ * Marks the registry for @a uuid as unmodified, so that it's not saved in
+ * a later call to saveModifiedRegistries().
+ *
+ * @param uuid
+ */
+void VirtualBox::i_unmarkRegistryModified(const Guid &uuid)
+{
+    uint64_t uOld;
+    if (uuid == i_getGlobalRegistryId())
+    {
+        for (;;)
+        {
+            uOld = ASMAtomicReadU64(&m->uRegistryNeedsSaving);
+            if (!uOld)
+                break;
+            if (ASMAtomicCmpXchgU64(&m->uRegistryNeedsSaving, 0, uOld))
+                break;
+            ASMNopPause();
+        }
+    }
+    else
+    {
+        ComObjPtr<Machine> pMachine;
+        HRESULT hrc = i_findMachine(uuid, false /* fPermitInaccessible */, false /* aSetError */, &pMachine);
+        if (SUCCEEDED(hrc))
+        {
+            AutoCaller machineCaller(pMachine);
+            if (SUCCEEDED(machineCaller.hrc()))
+            {
+                for (;;)
+                {
+                    uOld = ASMAtomicReadU64(&pMachine->uRegistryNeedsSaving);
+                    if (!uOld)
+                        break;
+                    if (ASMAtomicCmpXchgU64(&pMachine->uRegistryNeedsSaving, 0, uOld))
+                        break;
+                    ASMNopPause();
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Saves all settings files according to the modified flags in the Machine
+ * objects and in the VirtualBox object.
+ *
+ * This locks machines and the VirtualBox object as necessary, so better not
+ * hold any locks before calling this.
+ */
+void VirtualBox::i_saveModifiedRegistries()
+{
+    HRESULT hrc = S_OK;
+    bool fNeedsGlobalSettings = false;
+    uint64_t uOld;
+
+    {
+        AutoReadLock alock(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+        for (MachinesOList::iterator it = m->allMachines.begin();
+             it != m->allMachines.end();
+             ++it)
+        {
+            const ComObjPtr<Machine> &pMachine = *it;
+
+            for (;;)
+            {
+                uOld = ASMAtomicReadU64(&pMachine->uRegistryNeedsSaving);
+                if (!uOld)
+                    break;
+                if (ASMAtomicCmpXchgU64(&pMachine->uRegistryNeedsSaving, 0, uOld))
+                    break;
+                ASMNopPause();
+            }
+            if (uOld)
+            {
+                AutoCaller autoCaller(pMachine);
+                if (FAILED(autoCaller.hrc()))
+                    continue;
+                /* object is already dead, no point in saving settings */
+                if (getObjectState().getState() != ObjectState::Ready)
+                    continue;
+                AutoWriteLock mlock(pMachine COMMA_LOCKVAL_SRC_POS);
+                hrc = pMachine->i_saveSettings(&fNeedsGlobalSettings, mlock,
+                                               Machine::SaveS_Force);           // caller said save, so stop arguing
+            }
+        }
+    }
+
+    for (;;)
+    {
+        uOld = ASMAtomicReadU64(&m->uRegistryNeedsSaving);
+        if (!uOld)
+            break;
+        if (ASMAtomicCmpXchgU64(&m->uRegistryNeedsSaving, 0, uOld))
+            break;
+        ASMNopPause();
+    }
+    if (uOld || fNeedsGlobalSettings)
+    {
+        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+        hrc = i_saveSettings();
+    }
+    NOREF(hrc); /* XXX */
+}
+
+
+/* static */
+const com::Utf8Str &VirtualBox::i_getVersionNormalized()
+{
+    return sVersionNormalized;
+}
+
+/**
+ * Checks if the path to the specified file exists, according to the path
+ * information present in the file name. Optionally the path is created.
+ *
+ * Note that the given file name must contain the full path otherwise the
+ * extracted relative path will be created based on the current working
+ * directory which is normally unknown.
+ *
+ * @param strFileName   Full file name which path is checked/created.
+ * @param fCreate       Flag if the path should be created if it doesn't exist.
+ *
+ * @return Extended error information on failure to check/create the path.
+ */
+/* static */
+HRESULT VirtualBox::i_ensureFilePathExists(const Utf8Str &strFileName, bool fCreate)
+{
+    Utf8Str strDir(strFileName);
+    strDir.stripFilename();
+    if (!RTDirExists(strDir.c_str()))
+    {
+        if (fCreate)
+        {
+            int vrc = RTDirCreateFullPath(strDir.c_str(), 0700);
+            if (RT_FAILURE(vrc))
+                return i_setErrorStaticBoth(VBOX_E_IPRT_ERROR, vrc,
+                                            tr("Could not create the directory '%s' (%Rrc)"),
+                                            strDir.c_str(),
+                                            vrc);
+        }
+        else
+            return i_setErrorStaticBoth(VBOX_E_IPRT_ERROR, VERR_FILE_NOT_FOUND,
+                                        tr("Directory '%s' does not exist"), strDir.c_str());
+    }
+
+    return S_OK;
+}
+
+const Utf8Str& VirtualBox::i_settingsFilePath()
+{
+    return m->strSettingsFilePath;
+}
+
+/**
+ * Returns the lock handle which protects the machines list. As opposed
+ * to version 3.1 and earlier, these lists are no longer protected by the
+ * VirtualBox lock, but by this more specialized lock. Mind the locking
+ * order: always request this lock after the VirtualBox object lock but
+ * before the locks of any machine object. See AutoLock.h.
+ */
+RWLockHandle& VirtualBox::i_getMachinesListLockHandle()
+{
+    return m->lockMachines;
+}
+
+/**
+ * Returns the lock handle which protects the media trees (hard disks,
+ * DVDs, floppies). As opposed to version 3.1 and earlier, these lists
+ * are no longer protected by the VirtualBox lock, but by this more
+ * specialized lock. Mind the locking order: always request this lock
+ * after the VirtualBox object lock but before the locks of the media
+ * objects contained in these lists. See AutoLock.h.
+ */
+RWLockHandle& VirtualBox::i_getMediaTreeLockHandle()
+{
+    return m->lockMedia;
+}
+
+/**
+ *  Thread function that handles custom events posted using #i_postEvent().
+ */
+// static
+DECLCALLBACK(int) VirtualBox::AsyncEventHandler(RTTHREAD thread, void *pvUser)
+{
+    LogFlowFuncEnter();
+
+    AssertReturn(pvUser, VERR_INVALID_POINTER);
+
+    HRESULT hrc = com::Initialize();
+    if (FAILED(hrc))
+        return VERR_COM_UNEXPECTED;
+
+    int vrc = VINF_SUCCESS;
+
+    try
+    {
+        /* Create an event queue for the current thread. */
+        EventQueue *pEventQueue = new EventQueue();
+        AssertPtr(pEventQueue);
+
+        /* Return the queue to the one who created this thread. */
+        *(static_cast <EventQueue **>(pvUser)) = pEventQueue;
+
+        /* signal that we're ready. */
+        RTThreadUserSignal(thread);
+
+        /*
+         * In case of spurious wakeups causing VERR_TIMEOUTs and/or other return codes
+         * we must not stop processing events and delete the pEventQueue object. This must
+         * be done ONLY when we stop this loop via interruptEventQueueProcessing().
+         * See @bugref{5724}.
+         */
+        for (;;)
+        {
+            vrc = pEventQueue->processEventQueue(RT_INDEFINITE_WAIT);
+            if (vrc == VERR_INTERRUPTED)
+            {
+                LogFlow(("Event queue processing ended with vrc=%Rrc\n", vrc));
+                vrc = VINF_SUCCESS; /* Set success when exiting. */
+                break;
+            }
+        }
+
+        delete pEventQueue;
+    }
+    catch (std::bad_alloc &ba)
+    {
+        vrc = VERR_NO_MEMORY;
+        NOREF(ba);
+    }
+
+    com::Shutdown();
+
+    LogFlowFuncLeaveRC(vrc);
+    return vrc;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+#if 0 /* obsoleted by AsyncEvent */
+/**
+ * Prepare the event using the overwritten #prepareEventDesc method and fire.
+ *
+ *  @note Locks the managed VirtualBox object for reading but leaves the lock
+ *        before iterating over callbacks and calling their methods.
+ */
+void *VirtualBox::CallbackEvent::handler()
+{
+    if (!mVirtualBox)
+        return NULL;
+
+    AutoCaller autoCaller(mVirtualBox);
+    if (!autoCaller.isOk())
+    {
+        Log1WarningFunc(("VirtualBox has been uninitialized (state=%d), the callback event is discarded!\n",
+                         mVirtualBox->getObjectState().getState()));
+        /* We don't need mVirtualBox any more, so release it */
+        mVirtualBox = NULL;
+        return NULL;
+    }
+
+    {
+        VBoxEventDesc evDesc;
+        prepareEventDesc(mVirtualBox->m->pEventSource, evDesc);
+
+        evDesc.fire(/* don't wait for delivery */0);
+    }
+
+    mVirtualBox = NULL; /* Not needed any longer. Still make sense to do this? */
+    return NULL;
+}
+#endif
+
+/**
+ * Called on the event handler thread.
+ *
+ * @note Locks the managed VirtualBox object for reading but leaves the lock
+ *       before iterating over callbacks and calling their methods.
+ */
+void *VirtualBox::AsyncEvent::handler()
+{
+    if (mVirtualBox)
+    {
+        AutoCaller autoCaller(mVirtualBox);
+        if (autoCaller.isOk())
+        {
+            VBoxEventDesc EvtDesc(mEvent, mVirtualBox->m->pEventSource);
+            EvtDesc.fire(/* don't wait for delivery */0);
+        }
+        else
+            Log1WarningFunc(("VirtualBox has been uninitialized (state=%d), the callback event is discarded!\n",
+                             mVirtualBox->getObjectState().getState()));
+        mVirtualBox = NULL; /* Old code did this, not really necessary, but whatever. */
+    }
+    mEvent.setNull();
+    return NULL;
+}
+
+//STDMETHODIMP VirtualBox::CreateDHCPServerForInterface(/*IHostNetworkInterface * aIinterface,*/ IDHCPServer ** aServer)
+//{
+//    return E_NOTIMPL;
+//}
+
+HRESULT VirtualBox::createDHCPServer(const com::Utf8Str &aName,
+                                     ComPtr<IDHCPServer> &aServer)
+{
+    ComObjPtr<DHCPServer> dhcpServer;
+    dhcpServer.createObject();
+    HRESULT hrc = dhcpServer->init(this, aName);
+    if (FAILED(hrc)) return hrc;
+
+    hrc = i_registerDHCPServer(dhcpServer, true);
+    if (FAILED(hrc)) return hrc;
+
+    dhcpServer.queryInterfaceTo(aServer.asOutParam());
+
+    return hrc;
+}
+
+HRESULT VirtualBox::findDHCPServerByNetworkName(const com::Utf8Str &aName,
+                                                ComPtr<IDHCPServer> &aServer)
+{
+    ComPtr<DHCPServer> found;
+
+    AutoReadLock alock(m->allDHCPServers.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    for (DHCPServersOList::const_iterator it = m->allDHCPServers.begin();
+         it != m->allDHCPServers.end();
+         ++it)
+    {
+        Bstr bstrNetworkName;
+        HRESULT hrc = (*it)->COMGETTER(NetworkName)(bstrNetworkName.asOutParam());
+        if (FAILED(hrc)) return hrc;
+
+        if (Utf8Str(bstrNetworkName) == aName)
+        {
+            found = *it;
+            break;
+        }
+    }
+
+    if (!found)
+        return E_INVALIDARG;
+    return found.queryInterfaceTo(aServer.asOutParam());
+}
+
+HRESULT VirtualBox::removeDHCPServer(const ComPtr<IDHCPServer> &aServer)
+{
+    IDHCPServer *aP = aServer;
+    return i_unregisterDHCPServer(static_cast<DHCPServer *>(aP));
+}
+
+/**
+ * Remembers the given DHCP server in the settings.
+ *
+ * @param aDHCPServer   DHCP server object to remember.
+ * @param aSaveSettings @c true to save settings to disk (default).
+ *
+ * When @a aSaveSettings is @c true, this operation may fail because of the
+ * failed #i_saveSettings() method it calls. In this case, the dhcp server object
+ * will not be remembered. It is therefore the responsibility of the caller to
+ * call this method as the last step of some action that requires registration
+ * in order to make sure that only fully functional dhcp server objects get
+ * registered.
+ *
+ * @note Locks this object for writing and @a aDHCPServer for reading.
+ */
+HRESULT VirtualBox::i_registerDHCPServer(DHCPServer *aDHCPServer,
+                                         bool aSaveSettings /*= true*/)
+{
+    AssertReturn(aDHCPServer != NULL, E_INVALIDARG);
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    // Acquire a lock on the VirtualBox object early to avoid lock order issues
+    // when we call i_saveSettings() later on.
+    AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
+    // need it below, in findDHCPServerByNetworkName (reading) and in
+    // m->allDHCPServers.addChild, so need to get it here to avoid lock
+    // order trouble with dhcpServerCaller
+    AutoWriteLock alock(m->allDHCPServers.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    AutoCaller dhcpServerCaller(aDHCPServer);
+    AssertComRCReturnRC(dhcpServerCaller.hrc());
+
+    Bstr bstrNetworkName;
+    HRESULT hrc = aDHCPServer->COMGETTER(NetworkName)(bstrNetworkName.asOutParam());
+    if (FAILED(hrc)) return hrc;
+
+    ComPtr<IDHCPServer> existing;
+    hrc = findDHCPServerByNetworkName(Utf8Str(bstrNetworkName), existing);
+    if (SUCCEEDED(hrc))
+        return E_INVALIDARG;
+    hrc = S_OK;
+
+    m->allDHCPServers.addChild(aDHCPServer);
+    // we need to release the list lock before we attempt to acquire locks
+    // on other objects in i_saveSettings (see @bugref{7500})
+    alock.release();
+
+    if (aSaveSettings)
+    {
+        // we acquired the lock on 'this' earlier to avoid lock order issues
+        hrc = i_saveSettings();
+
+        if (FAILED(hrc))
+        {
+            alock.acquire();
+            m->allDHCPServers.removeChild(aDHCPServer);
+        }
+    }
+
+    return hrc;
+}
+
+/**
+ * Removes the given DHCP server from the settings.
+ *
+ * @param aDHCPServer   DHCP server object to remove.
+ *
+ * This operation may fail because of the failed #i_saveSettings() method it
+ * calls. In this case, the DHCP server will NOT be removed from the settings
+ * when this method returns.
+ *
+ * @note Locks this object for writing.
+ */
+HRESULT VirtualBox::i_unregisterDHCPServer(DHCPServer *aDHCPServer)
+{
+    AssertReturn(aDHCPServer != NULL, E_INVALIDARG);
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    AutoCaller dhcpServerCaller(aDHCPServer);
+    AssertComRCReturnRC(dhcpServerCaller.hrc());
+
+    AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
+    AutoWriteLock alock(m->allDHCPServers.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+    m->allDHCPServers.removeChild(aDHCPServer);
+    // we need to release the list lock before we attempt to acquire locks
+    // on other objects in i_saveSettings (see @bugref{7500})
+    alock.release();
+
+    HRESULT hrc = i_saveSettings();
+
+    // undo the changes if we failed to save them
+    if (FAILED(hrc))
+    {
+        alock.acquire();
+        m->allDHCPServers.addChild(aDHCPServer);
+    }
+
+    return hrc;
+}
+
+
+/**
+ * NAT Network
+ */
+HRESULT VirtualBox::createNATNetwork(const com::Utf8Str &aNetworkName,
+                                     ComPtr<INATNetwork> &aNetwork)
+{
+#ifdef VBOX_WITH_NAT_SERVICE
+    ComObjPtr<NATNetwork> natNetwork;
+    natNetwork.createObject();
+    HRESULT hrc = natNetwork->init(this, aNetworkName);
+    if (FAILED(hrc)) return hrc;
+
+    hrc = i_registerNATNetwork(natNetwork, true);
+    if (FAILED(hrc)) return hrc;
+
+    natNetwork.queryInterfaceTo(aNetwork.asOutParam());
+
+    ::FireNATNetworkCreationDeletionEvent(m->pEventSource, aNetworkName, TRUE);
+
+    return hrc;
+#else
+    NOREF(aNetworkName);
+    NOREF(aNetwork);
+    return E_NOTIMPL;
+#endif
+}
+
+HRESULT VirtualBox::findNATNetworkByName(const com::Utf8Str &aNetworkName,
+                                         ComPtr<INATNetwork> &aNetwork)
+{
+#ifdef VBOX_WITH_NAT_SERVICE
+
+    HRESULT hrc = S_OK;
+    ComPtr<NATNetwork> found;
+
+    AutoReadLock alock(m->allNATNetworks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    for (NATNetworksOList::const_iterator it = m->allNATNetworks.begin();
+         it != m->allNATNetworks.end();
+         ++it)
+    {
+        Bstr bstrNATNetworkName;
+        hrc = (*it)->COMGETTER(NetworkName)(bstrNATNetworkName.asOutParam());
+        if (FAILED(hrc)) return hrc;
+
+        if (Utf8Str(bstrNATNetworkName) == aNetworkName)
+        {
+            found = *it;
+            break;
+        }
+    }
+
+    if (!found)
+        return E_INVALIDARG;
+    found.queryInterfaceTo(aNetwork.asOutParam());
+    return hrc;
+#else
+    NOREF(aNetworkName);
+    NOREF(aNetwork);
+    return E_NOTIMPL;
+#endif
+}
+
+HRESULT VirtualBox::removeNATNetwork(const ComPtr<INATNetwork> &aNetwork)
+{
+#ifdef VBOX_WITH_NAT_SERVICE
+    Bstr name;
+    HRESULT hrc = aNetwork->COMGETTER(NetworkName)(name.asOutParam());
+    if (FAILED(hrc))
+        return hrc;
+    INATNetwork *p = aNetwork;
+    NATNetwork *network = static_cast<NATNetwork *>(p);
+    hrc = i_unregisterNATNetwork(network, true);
+    ::FireNATNetworkCreationDeletionEvent(m->pEventSource, name.raw(), FALSE);
+    return hrc;
+#else
+    NOREF(aNetwork);
+    return E_NOTIMPL;
+#endif
+
+}
+/**
+ * Remembers the given NAT network in the settings.
+ *
+ * @param aNATNetwork    NAT Network object to remember.
+ * @param aSaveSettings @c true to save settings to disk (default).
+ *
+ *
+ * @note Locks this object for writing and @a aNATNetwork for reading.
+ */
+HRESULT VirtualBox::i_registerNATNetwork(NATNetwork *aNATNetwork,
+                                         bool aSaveSettings /*= true*/)
+{
+#ifdef VBOX_WITH_NAT_SERVICE
+    AssertReturn(aNATNetwork != NULL, E_INVALIDARG);
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    AutoCaller natNetworkCaller(aNATNetwork);
+    AssertComRCReturnRC(natNetworkCaller.hrc());
+
+    Bstr name;
+    HRESULT hrc;
+    hrc = aNATNetwork->COMGETTER(NetworkName)(name.asOutParam());
+    AssertComRCReturnRC(hrc);
+
+    /* returned value isn't 0 and aSaveSettings is true
+     * means that we create duplicate, otherwise we just load settings.
+     */
+    if (   sNatNetworkNameToRefCount[name]
+        && aSaveSettings)
+        AssertComRCReturnRC(E_INVALIDARG);
+
+    hrc = S_OK;
+
+    sNatNetworkNameToRefCount[name] = 0;
+
+    m->allNATNetworks.addChild(aNATNetwork);
+
+    if (aSaveSettings)
+    {
+        AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
+        hrc = i_saveSettings();
+        vboxLock.release();
+
+        if (FAILED(hrc))
+            i_unregisterNATNetwork(aNATNetwork, false /* aSaveSettings */);
+    }
+
+    return hrc;
+#else
+    NOREF(aNATNetwork);
+    NOREF(aSaveSettings);
+    /* No panic please (silently ignore) */
+    return S_OK;
+#endif
+}
+
+/**
+ * Removes the given NAT network from the settings.
+ *
+ * @param aNATNetwork   NAT network object to remove.
+ * @param aSaveSettings @c true to save settings to disk (default).
+ *
+ * When @a aSaveSettings is @c true, this operation may fail because of the
+ * failed #i_saveSettings() method it calls. In this case, the DHCP server
+ * will NOT be removed from the settingsi when this method returns.
+ *
+ * @note Locks this object for writing.
+ */
+HRESULT VirtualBox::i_unregisterNATNetwork(NATNetwork *aNATNetwork,
+                                           bool aSaveSettings /*= true*/)
+{
+#ifdef VBOX_WITH_NAT_SERVICE
+    AssertReturn(aNATNetwork != NULL, E_INVALIDARG);
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    AutoCaller natNetworkCaller(aNATNetwork);
+    AssertComRCReturnRC(natNetworkCaller.hrc());
+
+    Bstr name;
+    HRESULT hrc = aNATNetwork->COMGETTER(NetworkName)(name.asOutParam());
+    /* Hm, there're still running clients. */
+    if (FAILED(hrc) || sNatNetworkNameToRefCount[name])
+        AssertComRCReturnRC(E_INVALIDARG);
+
+    m->allNATNetworks.removeChild(aNATNetwork);
+
+    if (aSaveSettings)
+    {
+        AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
+        hrc = i_saveSettings();
+        vboxLock.release();
+
+        if (FAILED(hrc))
+            i_registerNATNetwork(aNATNetwork, false /* aSaveSettings */);
+    }
+
+    return hrc;
+#else
+    NOREF(aNATNetwork);
+    NOREF(aSaveSettings);
+    return E_NOTIMPL;
+#endif
+}
+
+
+HRESULT VirtualBox::findProgressById(const com::Guid &aId,
+                                     ComPtr<IProgress> &aProgressObject)
+{
+    if (!aId.isValid())
+        return setError(E_INVALIDARG,
+                        tr("The provided progress object GUID is invalid"));
+
+    /* protect mProgressOperations */
+    AutoReadLock safeLock(m->mtxProgressOperations COMMA_LOCKVAL_SRC_POS);
+
+    ProgressMap::const_iterator it = m->mapProgressOperations.find(aId);
+    if (it != m->mapProgressOperations.end())
+    {
+        aProgressObject = it->second;
+        return S_OK;
+    }
+    return setError(E_INVALIDARG,
+                    tr("The progress object with the given GUID could not be found"));
+}
+
+
+/**
+ * Retains a reference to the default cryptographic interface.
+ *
+ * @returns COM status code.
+ * @param   ppCryptoIf          Where to store the pointer to the cryptographic interface on success.
+ *
+ * @note Locks this object for writing.
+ */
+HRESULT VirtualBox::i_retainCryptoIf(PCVBOXCRYPTOIF *ppCryptoIf)
+{
+    AssertReturn(ppCryptoIf != NULL, E_INVALIDARG);
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    /*
+     * No object lock due to some lock order fun with Machine objects.
+     * There is a dedicated critical section to protect against concurrency
+     * issues when loading the module.
+     */
+    RTCritSectEnter(&m->CritSectModCrypto);
+
+    /* Try to load the extension pack module if it isn't currently. */
+    HRESULT hrc = S_OK;
+    if (m->hLdrModCrypto == NIL_RTLDRMOD)
+    {
+#ifdef VBOX_WITH_EXTPACK
+        /*
+         * Check that a crypto extension pack name is set and resolve it into a
+         * library path.
+         */
+        Utf8Str strExtPack;
+        hrc = m->pSystemProperties->getDefaultCryptoExtPack(strExtPack);
+        if (FAILED(hrc))
+        {
+            RTCritSectLeave(&m->CritSectModCrypto);
+            return hrc;
+        }
+        if (strExtPack.isEmpty())
+        {
+            RTCritSectLeave(&m->CritSectModCrypto);
+            return setError(VBOX_E_OBJECT_NOT_FOUND,
+                            tr("Ńo extension pack providing a cryptographic support module could be found"));
+        }
+
+        Utf8Str strCryptoLibrary;
+        int vrc = m->ptrExtPackManager->i_getCryptoLibraryPathForExtPack(&strExtPack, &strCryptoLibrary);
+        if (RT_SUCCESS(vrc))
+        {
+            RTERRINFOSTATIC ErrInfo;
+            vrc = SUPR3HardenedLdrLoadPlugIn(strCryptoLibrary.c_str(), &m->hLdrModCrypto, RTErrInfoInitStatic(&ErrInfo));
+            if (RT_SUCCESS(vrc))
+            {
+                /* Resolve the entry point and query the pointer to the cryptographic interface. */
+                PFNVBOXCRYPTOENTRY pfnCryptoEntry = NULL;
+                vrc = RTLdrGetSymbol(m->hLdrModCrypto, VBOX_CRYPTO_MOD_ENTRY_POINT, (void **)&pfnCryptoEntry);
+                if (RT_SUCCESS(vrc))
+                {
+                    vrc = pfnCryptoEntry(&m->pCryptoIf);
+                    if (RT_FAILURE(vrc))
+                        hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                           tr("Failed to query the interface callback table from the cryptographic support module '%s' from extension pack '%s'"),
+                                           strCryptoLibrary.c_str(), strExtPack.c_str());
+                }
+                else
+                    hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                       tr("Failed to resolve the entry point for the cryptographic support module '%s' from extension pack '%s'"),
+                                       strCryptoLibrary.c_str(), strExtPack.c_str());
+            }
+            else
+                hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                   tr("Couldn't load the cryptographic support module '%s' from extension pack '%s' (error: '%s')"),
+                                   strCryptoLibrary.c_str(), strExtPack.c_str(), ErrInfo.Core.pszMsg);
+        }
+        else
+            hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                               tr("Couldn't resolve the library path of the crpytographic support module for extension pack '%s'"),
+                               strExtPack.c_str());
+#else
+        hrc = setError(VBOX_E_NOT_SUPPORTED,
+                       tr("The cryptographic support module is not supported in this build because extension packs are not supported"));
+#endif
+    }
+
+    if (SUCCEEDED(hrc))
+    {
+        ASMAtomicIncU32(&m->cRefsCrypto);
+        *ppCryptoIf = m->pCryptoIf;
+    }
+
+    RTCritSectLeave(&m->CritSectModCrypto);
+
+    return hrc;
+}
+
+
+/**
+ * Releases the reference of the given cryptographic interface.
+ *
+ * @returns COM status code.
+ * @param   pCryptoIf           Pointer to the cryptographic interface to release.
+ *
+ * @note Locks this object for writing.
+ */
+HRESULT VirtualBox::i_releaseCryptoIf(PCVBOXCRYPTOIF pCryptoIf)
+{
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    AssertReturn(pCryptoIf == m->pCryptoIf, E_INVALIDARG);
+
+    ASMAtomicDecU32(&m->cRefsCrypto);
+    return S_OK;
+}
+
+
+/**
+ * Tries to unload any loaded cryptographic support module if it is not in use currently.
+ *
+ * @returns COM status code.
+ *
+ * @note Locks this object for writing.
+ */
+HRESULT VirtualBox::i_unloadCryptoIfModule(void)
+{
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.hrc());
+
+    AutoWriteLock wlock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (m->cRefsCrypto)
+        return setError(E_ACCESSDENIED,
+                        tr("The cryptographic support module is in use and can't be unloaded"));
+
+    RTCritSectEnter(&m->CritSectModCrypto);
+    if (m->hLdrModCrypto != NIL_RTLDRMOD)
+    {
+        int vrc = RTLdrClose(m->hLdrModCrypto);
+        AssertRC(vrc);
+        m->hLdrModCrypto = NIL_RTLDRMOD;
+    }
+    RTCritSectLeave(&m->CritSectModCrypto);
+
+    return S_OK;
+}
+
+
+#ifdef RT_OS_WINDOWS
+#include <psapi.h>
+
+/**
+ * Report versions of installed drivers to release log.
+ */
+void VirtualBox::i_reportDriverVersions()
+{
+    /** @todo r=klaus this code is very confusing, as it uses TCHAR (and
+     * randomly also _TCHAR, which sounds to me like asking for trouble),
+     * the "sz" variable prefix but "%ls" for the format string - so the whole
+     * thing is better compiled with UNICODE and _UNICODE defined. Would be
+     * far easier to read if it would be coded explicitly for the unicode
+     * case, as it won't work otherwise. */
+    DWORD   err;
+    HRESULT hrc;
+    LPVOID  aDrivers[1024];
+    LPVOID *pDrivers      = aDrivers;
+    UINT    cNeeded       = 0;
+    TCHAR   szSystemRoot[MAX_PATH];
+    TCHAR  *pszSystemRoot = szSystemRoot;
+    LPVOID  pVerInfo      = NULL;
+    DWORD   cbVerInfo     = 0;
+
+    do
+    {
+        cNeeded = GetWindowsDirectory(szSystemRoot, RT_ELEMENTS(szSystemRoot));
+        if (cNeeded == 0)
+        {
+            err = GetLastError();
+            hrc = HRESULT_FROM_WIN32(err);
+            AssertLogRelMsgFailed(("GetWindowsDirectory failed, hrc=%Rhrc (0x%x) err=%u\n",
+                                                   hrc, hrc, err));
+            break;
+        }
+        else if (cNeeded > RT_ELEMENTS(szSystemRoot))
+        {
+            /* The buffer is too small, allocate big one. */
+            pszSystemRoot = (TCHAR *)RTMemTmpAlloc(cNeeded * sizeof(_TCHAR));
+            if (!pszSystemRoot)
+            {
+                AssertLogRelMsgFailed(("RTMemTmpAlloc failed to allocate %d bytes\n", cNeeded));
+                break;
+            }
+            if (GetWindowsDirectory(pszSystemRoot, cNeeded) == 0)
+            {
+                err = GetLastError();
+                hrc = HRESULT_FROM_WIN32(err);
+                AssertLogRelMsgFailed(("GetWindowsDirectory failed, hrc=%Rhrc (0x%x) err=%u\n",
+                                                   hrc, hrc, err));
+                break;
+            }
+        }
+
+        DWORD  cbNeeded = 0;
+        if (!EnumDeviceDrivers(aDrivers, sizeof(aDrivers), &cbNeeded) || cbNeeded > sizeof(aDrivers))
+        {
+            pDrivers = (LPVOID *)RTMemTmpAlloc(cbNeeded);
+            if (!EnumDeviceDrivers(pDrivers, cbNeeded, &cbNeeded))
+            {
+                err = GetLastError();
+                hrc = HRESULT_FROM_WIN32(err);
+                AssertLogRelMsgFailed(("EnumDeviceDrivers failed, hrc=%Rhrc (0x%x) err=%u\n",
+                                                   hrc, hrc, err));
+                break;
+            }
+        }
+
+        LogRel(("Installed Drivers:\n"));
+
+        TCHAR szDriver[1024];
+        int cDrivers = cbNeeded / sizeof(pDrivers[0]);
+        for (int i = 0; i < cDrivers; i++)
+        {
+            if (GetDeviceDriverBaseName(pDrivers[i], szDriver, sizeof(szDriver) / sizeof(szDriver[0])))
+            {
+                if (_tcsnicmp(TEXT("vbox"), szDriver, 4))
+                    continue;
+            }
+            else
+                continue;
+            if (GetDeviceDriverFileName(pDrivers[i], szDriver, sizeof(szDriver) / sizeof(szDriver[0])))
+            {
+                _TCHAR szTmpDrv[1024];
+                _TCHAR *pszDrv = szDriver;
+                if (!_tcsncmp(TEXT("\\SystemRoot"), szDriver, 11))
+                {
+                    _tcscpy_s(szTmpDrv, pszSystemRoot);
+                    _tcsncat_s(szTmpDrv, szDriver + 11, sizeof(szTmpDrv) / sizeof(szTmpDrv[0]) - _tclen(pszSystemRoot));
+                    pszDrv = szTmpDrv;
+                }
+                else if (!_tcsncmp(TEXT("\\??\\"), szDriver, 4))
+                    pszDrv = szDriver + 4;
+
+                /* Allocate a buffer for version info. Reuse if large enough. */
+                DWORD cbNewVerInfo = GetFileVersionInfoSize(pszDrv, NULL);
+                if (cbNewVerInfo > cbVerInfo)
+                {
+                    if (pVerInfo)
+                        RTMemTmpFree(pVerInfo);
+                    cbVerInfo = cbNewVerInfo;
+                    pVerInfo = RTMemTmpAlloc(cbVerInfo);
+                    if (!pVerInfo)
+                    {
+                        AssertLogRelMsgFailed(("RTMemTmpAlloc failed to allocate %d bytes\n", cbVerInfo));
+                        break;
+                    }
+                }
+
+                if (GetFileVersionInfo(pszDrv, NULL, cbVerInfo, pVerInfo))
+                {
+                    UINT   cbSize = 0;
+                    LPBYTE lpBuffer = NULL;
+                    if (VerQueryValue(pVerInfo, TEXT("\\"), (VOID FAR* FAR*)&lpBuffer, &cbSize))
+                    {
+                        if (cbSize)
+                        {
+                            VS_FIXEDFILEINFO *pFileInfo = (VS_FIXEDFILEINFO *)lpBuffer;
+                            if (pFileInfo->dwSignature == 0xfeef04bd)
+                            {
+                                LogRel(("  %ls (Version: %d.%d.%d.%d)\n", pszDrv,
+                                        (pFileInfo->dwFileVersionMS >> 16) & 0xffff,
+                                        (pFileInfo->dwFileVersionMS >> 0) & 0xffff,
+                                        (pFileInfo->dwFileVersionLS >> 16) & 0xffff,
+                                        (pFileInfo->dwFileVersionLS >> 0) & 0xffff));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+    }
+    while (0);
+
+    if (pVerInfo)
+        RTMemTmpFree(pVerInfo);
+
+    if (pDrivers != aDrivers)
+        RTMemTmpFree(pDrivers);
+
+    if (pszSystemRoot != szSystemRoot)
+        RTMemTmpFree(pszSystemRoot);
+}
+#else /* !RT_OS_WINDOWS */
+void VirtualBox::i_reportDriverVersions(void)
+{
+}
+#endif /* !RT_OS_WINDOWS */
+
+#if defined(RT_OS_WINDOWS) && defined(VBOXSVC_WITH_CLIENT_WATCHER)
+
+# include <psapi.h> /* for GetProcessImageFileNameW */
+
+/**
+ * Callout from the wrapper.
+ */
+void VirtualBox::i_callHook(const char *a_pszFunction)
+{
+    RT_NOREF(a_pszFunction);
+
+    /*
+     * Let'see figure out who is calling.
+     * Note! Requires Vista+, so skip this entirely on older systems.
+     */
+    if (RTSystemGetNtVersion() >= RTSYSTEM_MAKE_NT_VERSION(6, 0, 0))
+    {
+        RPC_CALL_ATTRIBUTES_V2_W CallAttribs = { RPC_CALL_ATTRIBUTES_VERSION, RPC_QUERY_CLIENT_PID | RPC_QUERY_IS_CLIENT_LOCAL };
+        RPC_STATUS rcRpc = RpcServerInqCallAttributesW(NULL, &CallAttribs);
+        if (   rcRpc == RPC_S_OK
+            && CallAttribs.ClientPID != 0)
+        {
+            RTPROCESS const pidClient = (RTPROCESS)(uintptr_t)CallAttribs.ClientPID;
+            if (pidClient != RTProcSelf())
+            {
+                /** @todo LogRel2 later: */
+                LogRel(("i_callHook: %Rfn [ClientPID=%#zx/%zu IsClientLocal=%d ProtocolSequence=%#x CallStatus=%#x CallType=%#x OpNum=%#x InterfaceUuid=%RTuuid]\n",
+                        a_pszFunction, CallAttribs.ClientPID, CallAttribs.ClientPID, CallAttribs.IsClientLocal,
+                        CallAttribs.ProtocolSequence, CallAttribs.CallStatus, CallAttribs.CallType, CallAttribs.OpNum,
+                        &CallAttribs.InterfaceUuid));
+
+                /*
+                 * Do we know this client PID already?
+                 */
+                RTCritSectRwEnterShared(&m->WatcherCritSect);
+                WatchedClientProcessMap::iterator It = m->WatchedProcesses.find(pidClient);
+                if (It != m->WatchedProcesses.end())
+                    RTCritSectRwLeaveShared(&m->WatcherCritSect); /* Known process, nothing to do. */
+                else
+                {
+                    /* This is a new client process, start watching it. */
+                    RTCritSectRwLeaveShared(&m->WatcherCritSect);
+                    i_watchClientProcess(pidClient, a_pszFunction);
+                }
+            }
+        }
+        else
+            LogRel(("i_callHook: %Rfn - rcRpc=%#x ClientPID=%#zx/%zu !! [IsClientLocal=%d ProtocolSequence=%#x CallStatus=%#x CallType=%#x OpNum=%#x InterfaceUuid=%RTuuid]\n",
+                    a_pszFunction, rcRpc, CallAttribs.ClientPID, CallAttribs.ClientPID, CallAttribs.IsClientLocal,
+                    CallAttribs.ProtocolSequence, CallAttribs.CallStatus, CallAttribs.CallType, CallAttribs.OpNum,
+                    &CallAttribs.InterfaceUuid));
+    }
+}
+
+
+/**
+ * Watches @a a_pidClient for termination.
+ *
+ * @returns true if successfully enabled watching of it, false if not.
+ * @param   a_pidClient     The PID to watch.
+ * @param   a_pszFunction   The function we which we detected the client in.
+ */
+bool VirtualBox::i_watchClientProcess(RTPROCESS a_pidClient, const char *a_pszFunction)
+{
+    RT_NOREF_PV(a_pszFunction);
+
+    /*
+     * Open the client process.
+     */
+    HANDLE hClient = OpenProcess(SYNCHRONIZE | PROCESS_QUERY_INFORMATION, FALSE /*fInherit*/, a_pidClient);
+    if (hClient == NULL)
+        hClient = OpenProcess(SYNCHRONIZE | PROCESS_QUERY_LIMITED_INFORMATION, FALSE , a_pidClient);
+    if (hClient == NULL)
+        hClient = OpenProcess(SYNCHRONIZE, FALSE , a_pidClient);
+    AssertLogRelMsgReturn(hClient != NULL, ("pidClient=%d (%#x) err=%d\n", a_pidClient, a_pidClient, GetLastError()),
+                          m->fWatcherIsReliable = false);
+
+    /*
+     * Create a new watcher structure and try add it to the map.
+     */
+    bool fRet = true;
+    WatchedClientProcess *pWatched = new (std::nothrow) WatchedClientProcess(a_pidClient, hClient);
+    if (pWatched)
+    {
+        RTCritSectRwEnterExcl(&m->WatcherCritSect);
+
+        WatchedClientProcessMap::iterator It = m->WatchedProcesses.find(a_pidClient);
+        if (It == m->WatchedProcesses.end())
+        {
+            try
+            {
+                m->WatchedProcesses.insert(WatchedClientProcessMap::value_type(a_pidClient, pWatched));
+            }
+            catch (std::bad_alloc &)
+            {
+                fRet = false;
+            }
+            if (fRet)
+            {
+                /*
+                 * Schedule it on a watcher thread.
+                 */
+                /** @todo later. */
+                RTCritSectRwLeaveExcl(&m->WatcherCritSect);
+            }
+            else
+            {
+                RTCritSectRwLeaveExcl(&m->WatcherCritSect);
+                delete pWatched;
+                LogRel(("VirtualBox::i_watchClientProcess: out of memory inserting into client map!\n"));
+            }
+        }
+        else
+        {
+            /*
+             * Someone raced us here, we lost.
+             */
+            RTCritSectRwLeaveExcl(&m->WatcherCritSect);
+            delete pWatched;
+        }
+    }
+    else
+    {
+        LogRel(("VirtualBox::i_watchClientProcess: out of memory!\n"));
+        CloseHandle(hClient);
+        m->fWatcherIsReliable = fRet = false;
+    }
+    return fRet;
+}
+
+
+/** Logs the RPC caller info to the release log. */
+/*static*/ void VirtualBox::i_logCaller(const char *a_pszFormat, ...)
+{
+    if (RTSystemGetNtVersion() >= RTSYSTEM_MAKE_NT_VERSION(6, 0, 0))
+    {
+        char szTmp[80];
+        va_list va;
+        va_start(va, a_pszFormat);
+        RTStrPrintfV(szTmp, sizeof(szTmp), a_pszFormat, va);
+        va_end(va);
+
+        RPC_CALL_ATTRIBUTES_V2_W CallAttribs = { RPC_CALL_ATTRIBUTES_VERSION, RPC_QUERY_CLIENT_PID | RPC_QUERY_IS_CLIENT_LOCAL };
+        RPC_STATUS rcRpc = RpcServerInqCallAttributesW(NULL, &CallAttribs);
+
+        RTUTF16 wszProcName[256];
+        wszProcName[0] = '\0';
+        if (rcRpc == 0 && CallAttribs.ClientPID != 0)
+        {
+            HANDLE hProcess = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, (DWORD)(uintptr_t)CallAttribs.ClientPID);
+            if (hProcess)
+            {
+                RT_ZERO(wszProcName);
+                GetProcessImageFileNameW(hProcess, wszProcName, RT_ELEMENTS(wszProcName) - 1);
+                CloseHandle(hProcess);
+            }
+        }
+        LogRel(("%s [rcRpc=%#x ClientPID=%#zx/%zu (%ls) IsClientLocal=%d ProtocolSequence=%#x CallStatus=%#x CallType=%#x OpNum=%#x InterfaceUuid=%RTuuid]\n",
+                szTmp, rcRpc, CallAttribs.ClientPID, CallAttribs.ClientPID, wszProcName, CallAttribs.IsClientLocal,
+                CallAttribs.ProtocolSequence, CallAttribs.CallStatus, CallAttribs.CallType, CallAttribs.OpNum,
+                &CallAttribs.InterfaceUuid));
+    }
+}
+
+#endif /* RT_OS_WINDOWS && VBOXSVC_WITH_CLIENT_WATCHER */
+
+
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */