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

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

150 files changed, 34064 insertions, 0 deletions

diff --git a/src/VBox/Main/include/AdditionsFacilityImpl.h b/src/VBox/Main/include/AdditionsFacilityImpl.h
new file mode 100644
index 00000000..c6e565b1
--- /dev/null
+++ b/src/VBox/Main/include/AdditionsFacilityImpl.h
@@ -0,0 +1,110 @@
+/* $Id: AdditionsFacilityImpl.h $ */
+/** @file
+ * VirtualBox Main - Additions facility class.
+ */
+
+/*
+ * Copyright (C) 2014-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
+ */
+
+#ifndef MAIN_INCLUDED_AdditionsFacilityImpl_h
+#define MAIN_INCLUDED_AdditionsFacilityImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/time.h>
+#include "AdditionsFacilityWrap.h"
+
+class Guest;
+
+/**
+ * A Guest Additions facility.
+ */
+class ATL_NO_VTABLE AdditionsFacility :
+    public AdditionsFacilityWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(AdditionsFacility)
+
+    /** @name Initializer & uninitializer methods
+     * @{ */
+    HRESULT init(Guest *a_pParent, AdditionsFacilityType_T a_enmFacility, AdditionsFacilityStatus_T a_enmStatus,
+                 uint32_t a_fFlags, PCRTTIMESPEC a_pTimeSpecTS);
+    void    uninit();
+    HRESULT FinalConstruct();
+    void    FinalRelease();
+    /** @} */
+
+public:
+    /** @name public internal methods
+     * @{ */
+    LONG64 i_getLastUpdated() const;
+#if 0 /* unused */
+    AdditionsFacilityType_T i_getType() const;
+    AdditionsFacilityClass_T i_getClass() const;
+    const char *i_getName() const;
+#endif
+    AdditionsFacilityStatus_T i_getStatus() const;
+    bool i_update(AdditionsFacilityStatus_T a_enmStatus, uint32_t a_fFlags, PCRTTIMESPEC a_pTimeSpecTS);
+    /** @} */
+
+private:
+
+    /** @name Wrapped IAdditionsFacility properties
+     * @{ */
+    HRESULT getClassType(AdditionsFacilityClass_T *aClassType);
+    HRESULT getLastUpdated(LONG64 *aLastUpdated);
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT getStatus(AdditionsFacilityStatus_T *aStatus);
+    HRESULT getType(AdditionsFacilityType_T *aType);
+    /** @} */
+
+    struct Data
+    {
+        /** Last update timestamp. */
+        RTTIMESPEC                  mTimestamp;
+        /** The facilitie's current status. */
+        AdditionsFacilityStatus_T   mStatus;
+        /** Flags. */
+        uint32_t                    mfFlags;
+        /** The facilitie's ID/type (static). */
+        AdditionsFacilityType_T     mType;
+        /** Index into s_aFacilityInfo. */
+        size_t                      midxInfo;
+    } mData;
+
+    /** Facility <-> string mappings. */
+    struct FacilityInfo
+    {
+        /** The facilitie's name. */
+        const char              *mName; /* utf-8 */
+        /** The facilitie's type. */
+        AdditionsFacilityType_T  mType;
+        /** The facilitie's class. */
+        AdditionsFacilityClass_T mClass;
+    };
+    static const FacilityInfo s_aFacilityInfo[8];
+};
+
+#endif /* !MAIN_INCLUDED_AdditionsFacilityImpl_h */
+
diff --git a/src/VBox/Main/include/ApplianceImpl.h b/src/VBox/Main/include/ApplianceImpl.h
new file mode 100644
index 00000000..08b44549
--- /dev/null
+++ b/src/VBox/Main/include/ApplianceImpl.h
@@ -0,0 +1,366 @@
+/* $Id: ApplianceImpl.h $ */
+/** @file
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_ApplianceImpl_h
+#define MAIN_INCLUDED_ApplianceImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+/* VBox includes */
+#include "VirtualSystemDescriptionWrap.h"
+#include "ApplianceWrap.h"
+#include "MediumFormatImpl.h"
+
+/** @todo This file needs massive cleanup. Split IAppliance in a public and
+ * private classes. */
+#include "ovfreader.h"
+#include <set>
+
+/* VBox forward declarations */
+class Certificate;
+class Progress;
+class VirtualSystemDescription;
+struct VirtualSystemDescriptionEntry;
+struct LocationInfo;
+typedef struct VDINTERFACE   *PVDINTERFACE;
+typedef struct VDINTERFACEIO *PVDINTERFACEIO;
+typedef struct SHASTORAGE    *PSHASTORAGE;
+
+namespace ovf
+{
+    struct HardDiskController;
+    struct VirtualSystem;
+    class  OVFReader;
+    struct DiskImage;
+    struct EnvelopeData;
+}
+
+namespace xml
+{
+    class Document;
+    class ElementNode;
+}
+
+namespace settings
+{
+    class MachineConfigFile;
+}
+
+class ATL_NO_VTABLE Appliance :
+    public ApplianceWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(Appliance)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+
+    HRESULT init(VirtualBox *aVirtualBox);
+    void uninit();
+
+    /* public methods only for internal purposes */
+
+    static HRESULT i_setErrorStatic(HRESULT aResultCode, const char *aText, ...)
+    {
+        va_list va;
+        va_start(va, aText);
+        HRESULT hrc = setErrorInternalV(aResultCode, getStaticClassIID(), getStaticComponentName(), aText, va, false, true);
+        va_end(va);
+        return hrc;
+    }
+
+    /* private instance data */
+private:
+    // wrapped IAppliance properties
+    HRESULT getPath(com::Utf8Str &aPath);
+    HRESULT getDisks(std::vector<com::Utf8Str> &aDisks);
+    HRESULT getCertificate(ComPtr<ICertificate> &aCertificateInfo);
+    HRESULT getVirtualSystemDescriptions(std::vector<ComPtr<IVirtualSystemDescription> > &aVirtualSystemDescriptions);
+    HRESULT getMachines(std::vector<com::Utf8Str> &aMachines);
+
+    // wrapped IAppliance methods
+    HRESULT read(const com::Utf8Str &aFile,
+                 ComPtr<IProgress> &aProgress);
+    HRESULT interpret();
+    HRESULT importMachines(const std::vector<ImportOptions_T> &aOptions,
+                           ComPtr<IProgress> &aProgress);
+    HRESULT createVFSExplorer(const com::Utf8Str &aURI,
+                              ComPtr<IVFSExplorer> &aExplorer);
+    HRESULT write(const com::Utf8Str &aFormat,
+                  const std::vector<ExportOptions_T> &aOptions,
+                  const com::Utf8Str &aPath,
+                  ComPtr<IProgress> &aProgress);
+    HRESULT getWarnings(std::vector<com::Utf8Str> &aWarnings);
+    HRESULT getPasswordIds(std::vector<com::Utf8Str> &aIdentifiers);
+    HRESULT getMediumIdsForPasswordId(const com::Utf8Str &aPasswordId, std::vector<com::Guid> &aIdentifiers);
+    HRESULT addPasswords(const std::vector<com::Utf8Str> &aIdentifiers,
+                         const std::vector<com::Utf8Str> &aPasswords);
+    HRESULT createVirtualSystemDescriptions(ULONG aRequested, ULONG *aCreated);
+    /** weak VirtualBox parent */
+    VirtualBox* const mVirtualBox;
+
+    struct ImportStack;
+    class TaskOVF;
+    class TaskOPC;
+    class TaskCloud;
+
+    struct Data;            // opaque, defined in ApplianceImpl.cpp
+    Data *m;
+
+    enum SetUpProgressMode { ImportFile, ImportS3, WriteFile, WriteS3, ExportCloud, ImportCloud };
+
+    enum ApplianceState { ApplianceIdle, ApplianceImporting, ApplianceExporting };
+    void i_setApplianceState(const ApplianceState &state);
+    /** @name General stuff
+     * @{
+     */
+    bool i_isApplianceIdle();
+    HRESULT i_searchUniqueVMName(Utf8Str &aName) const;
+    HRESULT i_ensureUniqueImageFilePath(const Utf8Str &aMachineFolder,
+                                        DeviceType_T aDeviceType,
+                                        Utf8Str &aName) const;
+    HRESULT i_setUpProgress(ComObjPtr<Progress> &pProgress,
+                            const Utf8Str &strDescription,
+                            SetUpProgressMode mode);
+    void i_addWarning(const char* aWarning, ...);
+    void i_disksWeight();
+    void i_parseBucket(Utf8Str &aPath, Utf8Str &aBucket);
+
+    static void i_importOrExportThreadTask(TaskOVF *pTask);
+    static void i_exportOPCThreadTask(TaskOPC *pTask);
+    static void i_importOrExportCloudThreadTask(TaskCloud *pTask);
+
+    HRESULT i_initBackendNames();
+
+    Utf8Str i_typeOfVirtualDiskFormatFromURI(Utf8Str type) const;
+
+#if 0 /* unused */
+    std::set<Utf8Str> i_URIFromTypeOfVirtualDiskFormat(Utf8Str type);
+#endif
+
+    HRESULT i_findMediumFormatFromDiskImage(const ovf::DiskImage &di, ComObjPtr<MediumFormat>& mf);
+
+    RTVFSIOSTREAM i_manifestSetupDigestCalculationForGivenIoStream(RTVFSIOSTREAM hVfsIos, const char *pszManifestEntry,
+                                                                   bool fRead = true);
+    /** @}  */
+
+    /** @name Read stuff
+     * @{
+     */
+    HRESULT i_readImpl(const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress);
+
+    HRESULT i_readFS(TaskOVF *pTask);
+    HRESULT i_readFSOVF(TaskOVF *pTask);
+    HRESULT i_readFSOVA(TaskOVF *pTask);
+    HRESULT i_readOVFFile(TaskOVF *pTask, RTVFSIOSTREAM hIosOvf, const char *pszManifestEntry);
+    HRESULT i_readManifestFile(TaskOVF *pTask, RTVFSIOSTREAM hIosMf, const char *pszSubFileNm);
+    HRESULT i_readSignatureFile(TaskOVF *pTask, RTVFSIOSTREAM hIosCert, const char *pszSubFileNm);
+    HRESULT i_readTailProcessing(TaskOVF *pTask);
+    HRESULT i_readTailProcessingGetManifestData(void **ppvData, size_t *pcbData);
+    HRESULT i_readTailProcessingSignedData(PRTERRINFOSTATIC pErrInfo);
+    HRESULT i_readTailProcessingVerifySelfSignedOvfCert(TaskOVF *pTask, RTCRSTORE hTrustedCerts, PRTERRINFOSTATIC pErrInfo);
+    HRESULT i_readTailProcessingVerifyIssuedOvfCert(TaskOVF *pTask, RTCRSTORE hTrustedStore, PRTERRINFOSTATIC pErrInfo);
+    HRESULT i_readTailProcessingVerifyContentInfoCerts(void const *pvData, size_t cbData,
+                                                       RTCRSTORE hTrustedStore, PRTERRINFOSTATIC pErrInfo);
+    HRESULT i_readTailProcessingVerifyAnalyzeSignerInfo(void const *pvData, size_t cbData, RTCRSTORE hTrustedStore,
+                                                        uint32_t iSigner, PRTTIMESPEC pNow, int vrc,
+                                                        PRTERRINFOSTATIC pErrInfo, PRTCRSTORE phTrustedStore2);
+    HRESULT i_readTailProcessingVerifyContentInfoFailOne(const char *pszSignature, int vrc, PRTERRINFOSTATIC pErrInfo);
+
+    HRESULT i_gettingCloudData(TaskCloud *pTask);
+    /** @}  */
+
+    /** @name Import stuff
+     * @{
+     */
+    HRESULT i_importImpl(const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress);
+
+    HRESULT i_importFS(TaskOVF *pTask);
+    HRESULT i_importFSOVF(TaskOVF *pTask, AutoWriteLockBase &rWriteLock);
+    HRESULT i_importFSOVA(TaskOVF *pTask, AutoWriteLockBase &rWriteLock);
+    HRESULT i_importDoIt(TaskOVF *pTask, AutoWriteLockBase &rWriteLock, RTVFSFSSTREAM hVfsFssOva = NIL_RTVFSFSSTREAM);
+
+    HRESULT i_verifyManifestFile(ImportStack &stack);
+
+    void i_convertDiskAttachmentValues(const ovf::HardDiskController &hdc,
+                                       uint32_t ulAddressOnParent,
+                                       Utf8Str &controllerName,
+                                       int32_t &lControllerPort,
+                                       int32_t &lDevice);
+
+    void i_importOneDiskImage(const ovf::DiskImage &di,
+                              const Utf8Str &strDstPath,
+                              ComObjPtr<Medium> &pTargetMedium,
+                              ImportStack &stack);
+
+    void i_importMachineGeneric(const ovf::VirtualSystem &vsysThis,
+                                ComObjPtr<VirtualSystemDescription> &vsdescThis,
+                                ComPtr<IMachine> &pNewMachineRet,
+                                ImportStack &stack);
+    void i_importVBoxMachine(ComObjPtr<VirtualSystemDescription> &vsdescThis,
+                             ComPtr<IMachine> &pNewMachine,
+                             ImportStack &stack);
+    void i_importMachines(ImportStack &stack);
+    HRESULT i_verifyStorageControllerPortValid(const StorageControllerType_T aStorageControllerType,
+                                               const uint32_t aControllerPort,
+                                               ULONG *ulMaxPorts);
+
+    HRESULT i_preCheckImageAvailability(ImportStack &stack);
+    bool    i_importEnsureOvaLookAhead(ImportStack &stack);
+    RTVFSIOSTREAM i_importOpenSourceFile(ImportStack &stack, Utf8Str const &rstrSrcPath, const char *pszManifestEntry);
+    HRESULT i_importCreateAndWriteDestinationFile(Utf8Str const &rstrDstPath,
+                                                  RTVFSIOSTREAM hVfsIosSrc, Utf8Str const &rstrSrcLogNm);
+
+    void    i_importCopyFile(ImportStack &stack, Utf8Str const &rstrSrcPath, Utf8Str const &rstrDstPath,
+                             const char *pszManifestEntry);
+    void    i_importDecompressFile(ImportStack &stack, Utf8Str const &rstrSrcPath, Utf8Str const &rstrDstPath,
+                                   const char *pszManifestEntry);
+    HRESULT i_importCloudImpl(TaskCloud *pTask);
+    /** @} */
+
+    /** @name Write stuff
+     * @{
+     */
+    HRESULT i_writeImpl(ovf::OVFVersion_T aFormat, const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress);
+    HRESULT i_writeOPCImpl(ovf::OVFVersion_T aFormat, const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress);
+    HRESULT i_writeCloudImpl(const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress);
+
+    HRESULT i_writeFS(TaskOVF *pTask);
+    HRESULT i_writeFSOVF(TaskOVF *pTask, AutoWriteLockBase& writeLock);
+    HRESULT i_writeFSOVA(TaskOVF *pTask, AutoWriteLockBase& writeLock);
+    HRESULT i_writeFSOPC(TaskOPC *pTask);
+    HRESULT i_exportCloudImpl(TaskCloud *pTask);
+    HRESULT i_writeFSImpl(TaskOVF *pTask, AutoWriteLockBase &writeLock, RTVFSFSSTREAM hVfsFssDst);
+    HRESULT i_writeBufferToFile(RTVFSFSSTREAM hVfsFssDst, const char *pszFilename, const void *pvContent, size_t cbContent);
+
+    struct XMLStack;
+
+    void i_buildXML(AutoWriteLockBase& writeLock,
+                    xml::Document &doc,
+                    XMLStack &stack,
+                    const Utf8Str &strPath,
+                    ovf::OVFVersion_T enFormat);
+    void i_buildXMLForOneVirtualSystem(AutoWriteLockBase& writeLock,
+                                       xml::ElementNode &elmToAddVirtualSystemsTo,
+                                       std::list<xml::ElementNode*> *pllElementsWithUuidAttributes,
+                                       ComObjPtr<VirtualSystemDescription> &vsdescThis,
+                                       ovf::OVFVersion_T enFormat,
+                                       XMLStack &stack);
+    /** @} */
+
+    friend class Machine;
+    friend class Certificate;
+};
+
+void i_parseURI(Utf8Str strUri, LocationInfo &locInfo);
+
+struct VirtualSystemDescriptionEntry
+{
+    uint32_t ulIndex;                       ///< zero-based index of this entry within array
+    VirtualSystemDescriptionType_T type;    ///< type of this entry
+    Utf8Str strRef;                         ///< reference number (hard disk controllers only)
+    Utf8Str strOvf;                         ///< original OVF value (type-dependent)
+    Utf8Str strVBoxSuggested;               ///< configuration value (type-dependent); original value suggested by interpret()
+    Utf8Str strVBoxCurrent;                 ///< configuration value (type-dependent); current value, either from interpret() or setFinalValue()
+    Utf8Str strExtraConfigSuggested;        ///< extra configuration key=value strings (type-dependent); original value suggested by interpret()
+    Utf8Str strExtraConfigCurrent;          ///< extra configuration key=value strings (type-dependent); current value, either from interpret() or setFinalValue()
+
+    uint32_t ulSizeMB;                      ///< hard disk images only: a copy of ovf::DiskImage::ulSuggestedSizeMB
+    bool skipIt;                            ///< used during export to skip some parts if it's needed
+};
+
+class ATL_NO_VTABLE VirtualSystemDescription :
+    public VirtualSystemDescriptionWrap
+{
+    friend class Appliance;
+
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(VirtualSystemDescription)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    HRESULT init();
+    void uninit();
+
+    /* public methods only for internal purposes */
+    void i_addEntry(VirtualSystemDescriptionType_T aType,
+                    const Utf8Str &strRef,
+                    const Utf8Str &aOvfValue,
+                    const Utf8Str &aVBoxValue,
+                    uint32_t ulSizeMB = 0,
+                    const Utf8Str &strExtraConfig = "");
+
+    std::list<VirtualSystemDescriptionEntry*> i_findByType(VirtualSystemDescriptionType_T aType);
+    const VirtualSystemDescriptionEntry* i_findControllerFromID(const Utf8Str &id);
+    const VirtualSystemDescriptionEntry* i_findByIndex(const uint32_t aIndex);
+
+    void i_importVBoxMachineXML(const xml::ElementNode &elmMachine);
+    const settings::MachineConfigFile* i_getMachineConfig() const;
+
+    /* private instance data */
+private:
+
+    // wrapped IVirtualSystemDescription properties
+    HRESULT getCount(ULONG *aCount);
+
+    // wrapped IVirtualSystemDescription methods
+    HRESULT getDescription(std::vector<VirtualSystemDescriptionType_T> &aTypes,
+                           std::vector<com::Utf8Str> &aRefs,
+                           std::vector<com::Utf8Str> &aOVFValues,
+                           std::vector<com::Utf8Str> &aVBoxValues,
+                           std::vector<com::Utf8Str> &aExtraConfigValues);
+    HRESULT getDescriptionByType(VirtualSystemDescriptionType_T aType,
+                                 std::vector<VirtualSystemDescriptionType_T> &aTypes,
+                                 std::vector<com::Utf8Str> &aRefs,
+                                 std::vector<com::Utf8Str> &aOVFValues,
+                                 std::vector<com::Utf8Str> &aVBoxValues,
+                                 std::vector<com::Utf8Str> &aExtraConfigValues);
+    HRESULT getValuesByType(VirtualSystemDescriptionType_T aType,
+                            VirtualSystemDescriptionValueType_T aWhich,
+                            std::vector<com::Utf8Str> &aValues);
+    HRESULT setFinalValues(const std::vector<BOOL> &aEnabled,
+                           const std::vector<com::Utf8Str> &aVBoxValues,
+                           const std::vector<com::Utf8Str> &aExtraConfigValues);
+    HRESULT addDescription(VirtualSystemDescriptionType_T aType,
+                           const com::Utf8Str &aVBoxValue,
+                           const com::Utf8Str &aExtraConfigValue);
+    HRESULT removeDescriptionByType(VirtualSystemDescriptionType_T aType);
+    void i_removeByType(VirtualSystemDescriptionType_T aType);
+
+    struct Data;
+    Data *m;
+
+    friend class Machine;
+};
+
+#endif /* !MAIN_INCLUDED_ApplianceImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/ApplianceImplPrivate.h b/src/VBox/Main/include/ApplianceImplPrivate.h
new file mode 100644
index 00000000..87712811
--- /dev/null
+++ b/src/VBox/Main/include/ApplianceImplPrivate.h
@@ -0,0 +1,571 @@
+/* $Id: ApplianceImplPrivate.h $ */
+/** @file
+ * VirtualBox Appliance private data definitions
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_ApplianceImplPrivate_h
+#define MAIN_INCLUDED_ApplianceImplPrivate_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+
+class VirtualSystemDescription;
+
+#include "ovfreader.h"
+#include "SecretKeyStore.h"
+#include "ThreadTask.h"
+#include "CertificateImpl.h"
+#include <map>
+#include <vector>
+#include <iprt/manifest.h>
+#include <iprt/vfs.h>
+#include <iprt/crypto/x509.h>
+#include <iprt/crypto/pkcs7.h>
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Appliance data definition
+//
+////////////////////////////////////////////////////////////////////////////////
+
+namespace settings
+{
+    struct AttachedDevice;
+}
+
+typedef std::pair<Utf8Str, Utf8Str> STRPAIR;
+
+typedef std::vector<com::Guid> GUIDVEC;
+
+/* Describe a location for the import/export. The location could be a file on a
+ * local hard disk or a remote target based on the supported inet protocols. */
+struct LocationInfo
+{
+    LocationInfo()
+      : storageType(VFSType_File) {}
+    VFSType_T storageType; /* Which type of storage should be handled */
+    Utf8Str strProvider;   /* cloud provider name in case of export/import to Cloud */
+    Utf8Str strPath;       /* File path for the import/export */
+    Utf8Str strHostname;   /* Hostname on remote storage locations (could be empty) */
+    Utf8Str strUsername;   /* Username on remote storage locations (could be empty) */
+    Utf8Str strPassword;   /* Password on remote storage locations (could be empty) */
+};
+
+/**
+ * opaque private instance data of Appliance class
+ */
+struct Appliance::Data
+{
+    enum digest_T {SHA1, SHA256};
+
+    Data()
+      : state(Appliance::ApplianceIdle)
+      , fDigestTypes(0)
+      , hOurManifest(NIL_RTMANIFEST)
+      , fManifest(true)
+      , fDeterminedDigestTypes(false)
+      , hTheirManifest(NIL_RTMANIFEST)
+      , hMemFileTheirManifest(NIL_RTVFSFILE)
+      , fSignerCertLoaded(false)
+      , fCertificateIsSelfSigned(false)
+      , fSignatureValid(false)
+      , fCertificateValid(false)
+      , fCertificateMissingPath(true)
+      , fCertificateValidTime(false)
+      , pbSignedDigest(NULL)
+      , cbSignedDigest(0)
+      , enmSignedDigestType(RTDIGESTTYPE_INVALID)
+      , fContentInfoLoaded(false)
+      , fContentInfoOkay(false)
+      , fContentInfoSameCert(false)
+      , fContentInfoValidSignature(false)
+      , fExportISOImages(false)
+      , pReader(NULL)
+      , ulWeightForXmlOperation(0)
+      , ulWeightForManifestOperation(0)
+      , ulTotalDisksMB(0)
+      , cDisks(0)
+      , m_cPwProvided(0)
+    {
+        RT_ZERO(SignerCert);
+        RT_ZERO(ContentInfo);
+    }
+
+    ~Data()
+    {
+        if (pReader)
+        {
+            delete pReader;
+            pReader = NULL;
+        }
+        resetReadData();
+    }
+
+    /**
+     * Resets data used by read.
+     */
+    void resetReadData(void)
+    {
+        strOvfManifestEntry.setNull();
+        if (hOurManifest != NIL_RTMANIFEST)
+        {
+            RTManifestRelease(hOurManifest);
+            hOurManifest = NIL_RTMANIFEST;
+        }
+        if (hTheirManifest != NIL_RTMANIFEST)
+        {
+            RTManifestRelease(hTheirManifest);
+            hTheirManifest = NIL_RTMANIFEST;
+        }
+        if (hMemFileTheirManifest)
+        {
+            RTVfsFileRelease(hMemFileTheirManifest);
+            hMemFileTheirManifest = NIL_RTVFSFILE;
+        }
+        if (pbSignedDigest)
+        {
+            RTMemFree(pbSignedDigest);
+            pbSignedDigest = NULL;
+            cbSignedDigest = 0;
+        }
+        if (fSignerCertLoaded)
+        {
+            RTCrX509Certificate_Delete(&SignerCert);
+            fSignerCertLoaded = false;
+        }
+        RT_ZERO(SignerCert);
+        enmSignedDigestType      = RTDIGESTTYPE_INVALID;
+        fCertificateIsSelfSigned = false;
+        fSignatureValid          = false;
+        fCertificateValid        = false;
+        fCertificateMissingPath  = true;
+        fCertificateValidTime    = false;
+        fDeterminedDigestTypes   = false;
+        fDigestTypes             = RTMANIFEST_ATTR_SHA1 | RTMANIFEST_ATTR_SHA256 | RTMANIFEST_ATTR_SHA512;
+        ptrCertificateInfo.setNull();
+        strCertError.setNull();
+        if (fContentInfoLoaded)
+        {
+            RTCrPkcs7ContentInfo_Delete(&ContentInfo);
+            fContentInfoLoaded = false;
+        }
+        RT_ZERO(ContentInfo);
+    }
+
+    Appliance::ApplianceState      state;
+
+    LocationInfo        locInfo;        // location info for the currently processed OVF
+    /** The digests types to calculate (RTMANIFEST_ATTR_XXX) for the manifest.
+     * This will be a single value when exporting.  Zero, one or two.  */
+    uint32_t            fDigestTypes;
+    /** Manifest created while importing or exporting. */
+    RTMANIFEST          hOurManifest;
+
+    /** @name Write data
+     * @{ */
+    bool                fManifest;      // Create a manifest file on export
+    /** @} */
+
+    /** @name Read data
+     *  @{ */
+    /** The manifest entry name of the OVF-file. */
+    Utf8Str             strOvfManifestEntry;
+
+    /** Set if we've parsed the manifest and determined the digest types. */
+    bool                fDeterminedDigestTypes;
+
+    /** Manifest read in during read() and kept around for later verification. */
+    RTMANIFEST          hTheirManifest;
+    /** Memorized copy of the manifest file for signature checking purposes. */
+    RTVFSFILE           hMemFileTheirManifest;
+
+    /** The signer certificate from the signature file (.cert).
+     * This will be used in the future provide information about the signer via
+     * the API. */
+    RTCRX509CERTIFICATE SignerCert;
+    /** Set if the SignerCert member contains usable data. */
+    bool                fSignerCertLoaded;
+    /** Cached RTCrX509Validity_IsValidAtTimeSpec result set by read(). */
+    bool                fCertificateIsSelfSigned;
+    /** Set by read() if pbSignedDigest verified correctly against SignerCert. */
+    bool                fSignatureValid;
+    /** Set by read() when the SignerCert checked out fine. */
+    bool                fCertificateValid;
+    /** Set by read() when the SignerCert certificate path couldn't be built. */
+    bool                fCertificateMissingPath;
+    /** Set by read() when the SignerCert (+path) is valid in the temporal sense. */
+    bool                fCertificateValidTime;
+    /** For keeping certificate error messages we delay from read() to import(). */
+    Utf8Str             strCertError;
+    /** The signed digest of the manifest. */
+    uint8_t            *pbSignedDigest;
+    /** The size of the signed digest. */
+    size_t              cbSignedDigest;
+    /** The digest type used to sign the manifest. */
+    RTDIGESTTYPE        enmSignedDigestType;
+    /** The certificate info object.  This is NULL if no signature and
+     *  successfully loaded certificate. */
+    ComObjPtr<Certificate> ptrCertificateInfo;
+
+    /** The PKCS\#7/CMS signed data signing manifest, optional VBox extension.
+     * This contains at least one signature using the same certificate as above
+     * (SignerCert), but should preferrably use a different digest.  The PKCS\#7/CMS
+     * format is a lot more versatile, allow multiple signatures using different
+     * digests and certificates, optionally with counter signed timestamps.
+     * Additional intermediate certificates can also be shipped, helping to bridge
+     * the gap to a trusted root certificate installed on the recieving system.  */
+    RTCRPKCS7CONTENTINFO ContentInfo;
+    /** Set if the ContentInfo member contains usable data. */
+    bool                fContentInfoLoaded;
+    /** Set by read() if the ContentInfo member checked out okay (says nothing about
+     *  the signature or certificates within it). */
+    bool                fContentInfoOkay;
+    /** Set by read() if the ContentInfo member is using the SignerCert too. */
+    bool                fContentInfoSameCert;
+    /** Set by read() if the ContentInfo member contains valid signatures (not
+     * saying anything about valid signing certificates). */
+    bool                fContentInfoValidSignature;
+    /** Set by read() if we've already verified the signed data signature(s). */
+    bool                fContentInfoDoneVerification;
+
+    bool                fContentInfoVerifiedOkay;
+    /** @} */
+
+    bool                fExportISOImages;// when 1 the ISO images are exported
+
+    RTCList<ImportOptions_T> optListImport;
+    RTCList<ExportOptions_T> optListExport;
+
+    ovf::OVFReader      *pReader;
+
+    std::list< ComObjPtr<VirtualSystemDescription> >
+                        virtualSystemDescriptions;
+
+    std::list<Utf8Str>  llWarnings;
+
+    ULONG               ulWeightForXmlOperation;
+    ULONG               ulWeightForManifestOperation;
+    ULONG               ulTotalDisksMB;
+    ULONG               cDisks;
+
+    std::list<Guid>     llGuidsMachinesCreated;
+
+    /** Sequence of password identifiers to encrypt disk images during export. */
+    std::vector<com::Utf8Str> m_vecPasswordIdentifiers;
+    /** Map to get all medium identifiers assoicated with a given password identifier. */
+    std::map<com::Utf8Str, GUIDVEC> m_mapPwIdToMediumIds;
+    /** Secret key store used to hold the passwords during export. */
+    SecretKeyStore            *m_pSecretKeyStore;
+    /** Number of passwords provided. */
+    uint32_t                  m_cPwProvided;
+};
+
+struct Appliance::XMLStack
+{
+    std::map<Utf8Str, const VirtualSystemDescriptionEntry*> mapDisks;
+    std::list<Utf8Str> mapDiskSequence;
+    std::list<Utf8Str> mapDiskSequenceForOneVM;//temporary keeps all disks attached to one exported VM
+    std::map<Utf8Str, bool> mapNetworks;
+};
+
+class Appliance::TaskOVF : public ThreadTask
+{
+public:
+    enum TaskType
+    {
+        Read,
+        Import,
+        Write
+    };
+
+    TaskOVF(Appliance *aThat,
+            TaskType aType,
+            LocationInfo aLocInfo,
+            ComObjPtr<Progress> &aProgress)
+      : ThreadTask("TaskOVF")
+      , pAppliance(aThat)
+      , taskType(aType)
+      , locInfo(aLocInfo)
+      , pProgress(aProgress)
+      , enFormat(ovf::OVFVersion_unknown)
+      , hrc(S_OK)
+    {
+        switch (taskType)
+        {
+            case TaskOVF::Read:     m_strTaskName = "ApplRead"; break;
+            case TaskOVF::Import:   m_strTaskName = "ApplImp"; break;
+            case TaskOVF::Write:    m_strTaskName = "ApplWrit"; break;
+            default:                m_strTaskName = "ApplTask"; break;
+        }
+    }
+
+    static DECLCALLBACK(int) updateProgress(unsigned uPercent, void *pvUser);
+
+    Appliance *pAppliance;
+    TaskType taskType;
+    const LocationInfo locInfo;
+    ComObjPtr<Progress> pProgress;
+
+    ovf::OVFVersion_T enFormat;
+
+    HRESULT hrc;
+
+    void handler()
+    {
+        Appliance::i_importOrExportThreadTask(this);
+    }
+};
+
+class Appliance::TaskOPC : public ThreadTask
+{
+public:
+    enum TaskType
+    {
+        Export
+    };
+
+    TaskOPC(Appliance *aThat,
+            TaskType aType,
+            LocationInfo aLocInfo,
+            ComObjPtr<Progress> &aProgress)
+      : ThreadTask("TaskOPC")
+      , pAppliance(aThat)
+      , taskType(aType)
+      , locInfo(aLocInfo)
+      , pProgress(aProgress)
+      , hrc(S_OK)
+    {
+        m_strTaskName = "OPCExpt";
+    }
+
+    ~TaskOPC()
+    {
+    }
+
+    static DECLCALLBACK(int) updateProgress(unsigned uPercent, void *pvUser);
+
+    Appliance *pAppliance;
+    TaskType taskType;
+    const LocationInfo locInfo;
+    ComObjPtr<Progress> pProgress;
+
+    HRESULT hrc;
+
+    void handler()
+    {
+        Appliance::i_exportOPCThreadTask(this);
+    }
+};
+
+
+class Appliance::TaskCloud : public ThreadTask
+{
+public:
+    enum TaskType
+    {
+        Export,
+        Import,
+        ReadData
+    };
+
+    TaskCloud(Appliance *aThat,
+              TaskType aType,
+              LocationInfo aLocInfo,
+              ComObjPtr<Progress> &aProgress)
+      : ThreadTask("TaskCloud")
+      , pAppliance(aThat)
+      , taskType(aType)
+      , locInfo(aLocInfo)
+      , pProgress(aProgress)
+      , hrc(S_OK)
+    {
+        switch (taskType)
+        {
+            case TaskCloud::Export:    m_strTaskName = "CloudExpt"; break;
+            case TaskCloud::Import:    m_strTaskName = "CloudImpt"; break;
+            case TaskCloud::ReadData:  m_strTaskName = "CloudRead"; break;
+            default:                   m_strTaskName = "CloudTask"; break;
+        }
+    }
+
+    ~TaskCloud()
+    {
+    }
+
+    static DECLCALLBACK(int) updateProgress(unsigned uPercent, void *pvUser);
+
+    Appliance *pAppliance;
+    TaskType taskType;
+    const LocationInfo locInfo;
+    ComObjPtr<Progress> pProgress;
+
+    HRESULT hrc;
+
+    void handler()
+    {
+        Appliance::i_importOrExportCloudThreadTask(this);
+    }
+};
+
+struct MyHardDiskAttachment
+{
+    ComPtr<IMachine>    pMachine;
+    Utf8Str             controllerName;
+    int32_t             lControllerPort;        // 0-29 for SATA
+    int32_t             lDevice;                // IDE: 0 or 1, otherwise 0 always
+};
+
+/**
+ * Used by Appliance::importMachineGeneric() to store
+ * input parameters and rollback information.
+ */
+struct Appliance::ImportStack
+{
+    // input pointers
+    const LocationInfo              &locInfo;           // ptr to location info from Appliance::importFS()
+    Utf8Str                         strSourceDir;       // directory where source files reside
+    const ovf::DiskImagesMap        &mapDisks;          // ptr to disks map in OVF
+    ComObjPtr<Progress>             &pProgress;         // progress object passed into Appliance::importFS()
+
+    // input parameters from VirtualSystemDescriptions
+    Utf8Str                         strNameVBox;        // VM name
+    Utf8Str                         strSettingsFilename; // Absolute path to VM config file
+    Utf8Str                         strMachineFolder;   // Absolute path to VM folder (derived from strSettingsFilename)
+    Utf8Str                         strOsTypeVBox;      // VirtualBox guest OS type as string
+    Utf8Str                         strPrimaryGroup;    // VM primary group as string
+    Utf8Str                         strDescription;
+    uint32_t                        cCPUs;              // CPU count
+    bool                            fForceHWVirt;       // if true, we force enabling hardware virtualization
+    bool                            fForceIOAPIC;       // if true, we force enabling the IOAPIC
+    uint32_t                        ulMemorySizeMB;     // virtual machine RAM in megabytes
+    Utf8Str                         strFirmwareType;    //Firmware - BIOS or EFI
+#ifdef VBOX_WITH_USB
+    bool                            fUSBEnabled;
+#endif
+    Utf8Str                         strAudioAdapter;    // if not empty, then the guest has audio enabled, and this is the decimal
+                                                        // representation of the audio adapter (should always be "0" for AC97 presently)
+
+    // session (not initially created)
+    ComPtr<ISession>                pSession;           // session opened in Appliance::importFS() for machine manipulation
+    bool                            fSessionOpen;       // true if the pSession is currently open and needs closing
+
+    /** @name File access related stuff (TAR stream)
+     *  @{  */
+    /** OVA file system stream handle. NIL if not OVA.  */
+    RTVFSFSSTREAM                   hVfsFssOva;
+    /** OVA lookahead I/O stream object. */
+    RTVFSIOSTREAM                   hVfsIosOvaLookAhead;
+    /** OVA lookahead I/O stream object name. */
+    char                           *pszOvaLookAheadName;
+    /** @} */
+
+    // a list of images that we created/imported; this is initially empty
+    // and will be cleaned up on errors
+    std::list<MyHardDiskAttachment> llHardDiskAttachments;      // disks that were attached
+    std::map<Utf8Str, Utf8Str>      mapNewUUIDsToOriginalUUIDs;
+
+    ImportStack(const LocationInfo &aLocInfo,
+                const ovf::DiskImagesMap &aMapDisks,
+                ComObjPtr<Progress> &aProgress,
+                RTVFSFSSTREAM aVfsFssOva)
+        : locInfo(aLocInfo),
+          mapDisks(aMapDisks),
+          pProgress(aProgress),
+          cCPUs(1),
+          fForceHWVirt(false),
+          fForceIOAPIC(false),
+          ulMemorySizeMB(0),
+          fSessionOpen(false),
+          hVfsFssOva(aVfsFssOva),
+          hVfsIosOvaLookAhead(NIL_RTVFSIOSTREAM),
+          pszOvaLookAheadName(NULL)
+    {
+        if (hVfsFssOva != NIL_RTVFSFSSTREAM)
+            RTVfsFsStrmRetain(hVfsFssOva);
+
+        // disk images have to be on the same place as the OVF file. So
+        // strip the filename out of the full file path
+        strSourceDir = aLocInfo.strPath;
+        strSourceDir.stripFilename();
+    }
+
+    ~ImportStack()
+    {
+        if (hVfsFssOva != NIL_RTVFSFSSTREAM)
+        {
+            RTVfsFsStrmRelease(hVfsFssOva);
+            hVfsFssOva = NIL_RTVFSFSSTREAM;
+        }
+        if (hVfsIosOvaLookAhead != NIL_RTVFSIOSTREAM)
+        {
+            RTVfsIoStrmRelease(hVfsIosOvaLookAhead);
+            hVfsIosOvaLookAhead = NIL_RTVFSIOSTREAM;
+        }
+        if (pszOvaLookAheadName)
+        {
+            RTStrFree(pszOvaLookAheadName);
+            pszOvaLookAheadName = NULL;
+        }
+    }
+
+    HRESULT restoreOriginalUUIDOfAttachedDevice(settings::MachineConfigFile *config);
+    HRESULT saveOriginalUUIDOfAttachedDevice(settings::AttachedDevice &device, const Utf8Str &newlyUuid);
+    RTVFSIOSTREAM claimOvaLookAHead(void);
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// VirtualSystemDescription data definition
+//
+////////////////////////////////////////////////////////////////////////////////
+
+struct VirtualSystemDescription::Data
+{
+    /** item descriptions */
+    std::vector<VirtualSystemDescriptionEntry> maDescriptions;
+
+    /** VirtualBox machine this description was exported from (export only) */
+    ComPtr<Machine> pMachine;
+
+    /** machine config created from <vbox:Machine> element if found (import only) */
+    settings::MachineConfigFile *pConfig;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Internal helpers
+//
+////////////////////////////////////////////////////////////////////////////////
+
+void convertCIMOSType2VBoxOSType(Utf8Str &strType, ovf::CIMOSType_T c, const Utf8Str &cStr);
+
+ovf::CIMOSType_T convertVBoxOSType2CIMOSType(const char *pcszVBox, BOOL fLongMode);
+
+Utf8Str convertNetworkAttachmentTypeToString(NetworkAttachmentType_T type);
+
+
+#endif /* !MAIN_INCLUDED_ApplianceImplPrivate_h */
+
diff --git a/src/VBox/Main/include/AudioAdapterImpl.h b/src/VBox/Main/include/AudioAdapterImpl.h
new file mode 100644
index 00000000..43dcf845
--- /dev/null
+++ b/src/VBox/Main/include/AudioAdapterImpl.h
@@ -0,0 +1,94 @@
+/* $Id: AudioAdapterImpl.h $ */
+
+/** @file
+ *
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_AudioAdapterImpl_h
+#define MAIN_INCLUDED_AudioAdapterImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+class AudioSettings;
+
+#include "AudioAdapterWrap.h"
+namespace settings
+{
+    struct AudioAdapter;
+}
+
+class ATL_NO_VTABLE AudioAdapter :
+    public AudioAdapterWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS (AudioAdapter)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(AudioSettings *aParent);
+    HRESULT init(AudioSettings *aParent, AudioAdapter *aThat);
+    HRESULT initCopy(AudioSettings *aParent, AudioAdapter *aThat);
+    void uninit();
+
+    // public methods only for internal purposes
+    HRESULT i_loadSettings(const settings::AudioAdapter &data);
+    HRESULT i_saveSettings(settings::AudioAdapter &data);
+
+    void i_rollback();
+    void i_commit();
+    void i_copyFrom(AudioAdapter *aThat);
+
+private:
+
+    // wrapped IAudioAdapter properties
+    HRESULT getEnabled(BOOL *aEnabled);
+    HRESULT setEnabled(BOOL aEnabled);
+    HRESULT getEnabledIn(BOOL *aEnabled);
+    HRESULT setEnabledIn(BOOL aEnabled);
+    HRESULT getEnabledOut(BOOL *aEnabled);
+    HRESULT setEnabledOut(BOOL aEnabled);
+    HRESULT getAudioDriver(AudioDriverType_T *aAudioDriver);
+    HRESULT setAudioDriver(AudioDriverType_T aAudioDriver);
+    HRESULT getAudioController(AudioControllerType_T *aAudioController);
+    HRESULT setAudioController(AudioControllerType_T aAudioController);
+    HRESULT getAudioCodec(AudioCodecType_T *aAudioCodec);
+    HRESULT setAudioCodec(AudioCodecType_T aAudioCodec);
+    HRESULT getPropertiesList(std::vector<com::Utf8Str>& aProperties);
+    HRESULT getProperty(const com::Utf8Str &aKey, com::Utf8Str &aValue);
+    HRESULT setProperty(const com::Utf8Str &aKey, const com::Utf8Str &aValue);
+
+private:
+
+    struct Data;
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_AudioAdapterImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/AudioDriver.h b/src/VBox/Main/include/AudioDriver.h
new file mode 100644
index 00000000..fbfba494
--- /dev/null
+++ b/src/VBox/Main/include/AudioDriver.h
@@ -0,0 +1,144 @@
+/* $Id: AudioDriver.h $ */
+/** @file
+ * VirtualBox audio base class for Main audio drivers.
+ */
+
+/*
+ * Copyright (C) 2018-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
+ */
+
+#ifndef MAIN_INCLUDED_AudioDriver_h
+#define MAIN_INCLUDED_AudioDriver_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/com/ptr.h>
+#include <VBox/com/string.h>
+#include <VBox/com/AutoLock.h>
+
+using namespace com;
+
+/**
+ * Audio driver configuration for audio drivers implemented
+ * in Main.
+ */
+struct AudioDriverCfg
+{
+    AudioDriverCfg(Utf8Str a_strDev = "", unsigned a_uInst = 0, unsigned a_uLUN = 0, Utf8Str a_strName = "",
+                   bool a_fEnabledIn = false, bool a_fEnabledOut = false)
+        : strDev(a_strDev)
+        , uInst(a_uInst)
+        , uLUN(a_uLUN)
+        , strName(a_strName)
+        , fEnabledIn(a_fEnabledIn)
+        , fEnabledOut(a_fEnabledOut)
+    { }
+
+    /** Copy assignment operator. */
+    AudioDriverCfg& operator=(AudioDriverCfg const &a_rThat) RT_NOEXCEPT
+    {
+        this->strDev      = a_rThat.strDev;
+        this->uInst       = a_rThat.uInst;
+        this->uLUN        = a_rThat.uLUN;
+        this->strName     = a_rThat.strName;
+        this->fEnabledIn  = a_rThat.fEnabledIn;
+        this->fEnabledOut = a_rThat.fEnabledOut;
+
+        return *this;
+    }
+
+    /** The device name. */
+    Utf8Str             strDev;
+    /** The device instance. */
+    unsigned            uInst;
+    /** The LUN the driver is attached to.
+     *  Set the UINT8_MAX if not attached. */
+    unsigned            uLUN;
+    /** The driver name. */
+    Utf8Str             strName;
+    /** Whether input is enabled. */
+    bool                fEnabledIn;
+    /** Whether output is enabled. */
+    bool                fEnabledOut;
+};
+
+class Console;
+
+/**
+ * Base class for all audio drivers implemented in Main.
+ */
+class AudioDriver
+{
+
+public:
+    AudioDriver(Console *pConsole);
+    virtual ~AudioDriver();
+
+    /** Copy assignment operator. */
+    AudioDriver &operator=(AudioDriver const &a_rThat) RT_NOEXCEPT;
+
+    Console *GetParent(void) { return mpConsole; }
+
+    AudioDriverCfg *GetConfig(void) { return &mCfg; }
+    int InitializeConfig(AudioDriverCfg *pCfg);
+
+    /** Checks if audio is configured or not. */
+    bool isConfigured() const { return mCfg.strName.isNotEmpty(); }
+
+    bool IsAttached(void) { return mfAttached; }
+
+    int doAttachDriverViaEmt(PUVM pUVM, PCVMMR3VTABLE pVMM, util::AutoWriteLock *pAutoLock);
+    int doDetachDriverViaEmt(PUVM pUVM, PCVMMR3VTABLE pVMM, util::AutoWriteLock *pAutoLock);
+
+protected:
+    static DECLCALLBACK(int) attachDriverOnEmt(AudioDriver *pThis);
+    static DECLCALLBACK(int) detachDriverOnEmt(AudioDriver *pThis);
+
+    int configure(unsigned uLUN, bool fAttach);
+
+    /**
+     * Virtual function for child specific driver configuration.
+     *
+     * This is called at the end of AudioDriver::configure().
+     *
+     * @returns VBox status code.
+     * @param   pLunCfg          CFGM configuration node of the driver.
+     * @param   pVMM            The VMM ring-3 vtable.
+     */
+    virtual int configureDriver(PCFGMNODE pLunCfg, PCVMMR3VTABLE pVMM)
+    {
+        RT_NOREF(pLunCfg, pVMM);
+        return VINF_SUCCESS;
+    }
+
+protected:
+
+    /** Pointer to parent. */
+    Console             *mpConsole;
+    /** The driver's configuration. */
+    AudioDriverCfg       mCfg;
+    /** Whether the driver is attached or not. */
+    bool                 mfAttached;
+};
+
+#endif /* !MAIN_INCLUDED_AudioDriver_h */
+
diff --git a/src/VBox/Main/include/AudioSettingsImpl.h b/src/VBox/Main/include/AudioSettingsImpl.h
new file mode 100644
index 00000000..e5ec0b31
--- /dev/null
+++ b/src/VBox/Main/include/AudioSettingsImpl.h
@@ -0,0 +1,84 @@
+/* $Id: AudioSettingsImpl.h $ */
+
+/** @file
+ *
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2022-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
+ */
+
+#ifndef MAIN_INCLUDED_AudioSettingsImpl_h
+#define MAIN_INCLUDED_AudioSettingsImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "AudioAdapterImpl.h"
+#include "GuestOSTypeImpl.h"
+
+#include "AudioSettingsWrap.h"
+namespace settings
+{
+    struct AudioSettings;
+}
+
+class ATL_NO_VTABLE AudioSettings :
+    public AudioSettingsWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(AudioSettings)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Machine *aParent);
+    HRESULT init(Machine *aParent, AudioSettings *aThat);
+    HRESULT initCopy(Machine *aParent, AudioSettings *aThat);
+    void uninit();
+
+    HRESULT getHostAudioDevice(AudioDirection_T aUsage, ComPtr<IHostAudioDevice> &aDevice);
+    HRESULT setHostAudioDevice(const ComPtr<IHostAudioDevice> &aDevice, AudioDirection_T aUsage);
+    HRESULT getAdapter(ComPtr<IAudioAdapter> &aAdapter);
+
+    // public methods only for internal purposes
+    bool     i_canChangeSettings(void);
+    void     i_onAdapterChanged(IAudioAdapter *pAdapter);
+    void     i_onHostDeviceChanged(IHostAudioDevice *pDevice, bool fIsNew, AudioDeviceState_T enmState, IVirtualBoxErrorInfo *pErrInfo);
+    void     i_onSettingsChanged(void);
+    HRESULT  i_loadSettings(const settings::AudioAdapter &data);
+    HRESULT  i_saveSettings(settings::AudioAdapter &data);
+    void     i_copyFrom(AudioSettings *aThat);
+    HRESULT  i_applyDefaults(ComObjPtr<GuestOSType> &aGuestOsType);
+
+    void i_rollback();
+    void i_commit();
+
+private:
+
+    struct Data;
+    Data *m;
+};
+#endif /* !MAIN_INCLUDED_AudioSettingsImpl_h */
+
diff --git a/src/VBox/Main/include/AuthLibrary.h b/src/VBox/Main/include/AuthLibrary.h
new file mode 100644
index 00000000..8d22b937
--- /dev/null
+++ b/src/VBox/Main/include/AuthLibrary.h
@@ -0,0 +1,54 @@
+/* $Id: AuthLibrary.h $ */
+/** @file
+ * Main - external authentication library interface.
+ */
+
+/*
+ * Copyright (C) 2015-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
+ */
+
+#ifndef MAIN_INCLUDED_AuthLibrary_h
+#define MAIN_INCLUDED_AuthLibrary_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/VBoxAuth.h>
+#include <iprt/types.h>
+
+typedef struct AUTHLIBRARYCONTEXT
+{
+    RTLDRMOD hAuthLibrary;
+    PAUTHENTRY pfnAuthEntry;
+    PAUTHENTRY2 pfnAuthEntry2;
+    PAUTHENTRY3 pfnAuthEntry3;
+} AUTHLIBRARYCONTEXT;
+
+int AuthLibLoad(AUTHLIBRARYCONTEXT *pAuthLibCtx, const char *pszLibrary);
+void AuthLibUnload(AUTHLIBRARYCONTEXT *pAuthLibCtx);
+
+AuthResult AuthLibAuthenticate(const AUTHLIBRARYCONTEXT *pAuthLibCtx,
+                               PCRTUUID pUuid, AuthGuestJudgement guestJudgement,
+                               const char *pszUser, const char *pszPassword, const char *pszDomain,
+                               uint32_t u32ClientId);
+void AuthLibDisconnect(const AUTHLIBRARYCONTEXT *pAuthLibCtx, PCRTUUID pUuid, uint32_t u32ClientId);
+
+#endif /* !MAIN_INCLUDED_AuthLibrary_h */
diff --git a/src/VBox/Main/include/AutoCaller.h b/src/VBox/Main/include/AutoCaller.h
new file mode 100644
index 00000000..d8bf6cc5
--- /dev/null
+++ b/src/VBox/Main/include/AutoCaller.h
@@ -0,0 +1,537 @@
+/* $Id: AutoCaller.h $ */
+/** @file
+ *
+ * VirtualBox object caller handling definitions
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_AutoCaller_h
+#define MAIN_INCLUDED_AutoCaller_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "ObjectState.h"
+
+#include "VBox/com/AutoLock.h"
+
+// Forward declaration needed, but nothing more.
+class VirtualBoxBase;
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// AutoCaller* classes
+//
+////////////////////////////////////////////////////////////////////////////////
+
+
+/**
+ * Smart class that automatically increases the number of normal (non-limited)
+ * callers of the given VirtualBoxBase object when an instance is constructed
+ * and decreases it back when the created instance goes out of scope (i.e. gets
+ * destroyed).
+ *
+ * If #hrc() returns a failure after the instance creation, it means that
+ * the managed VirtualBoxBase object is not Ready, or in any other invalid
+ * state, so that the caller must not use the object and can return this
+ * failed result code to the upper level.
+ *
+ * See ObjectState::addCaller() and ObjectState::releaseCaller() for more
+ * details about object callers.
+ *
+ * A typical usage pattern to declare a normal method of some object (i.e. a
+ * method that is valid only when the object provides its full
+ * functionality) is:
+ * <code>
+ * STDMETHODIMP Component::Foo()
+ * {
+ *     AutoCaller autoCaller(this);
+ *     HRESULT hrc = autoCaller.hrc();
+ *     if (SUCCEEDED(hrc))
+ *     {
+ *         ...
+ *     }
+ *     return hrc;
+ * }
+ * </code>
+ */
+class AutoCaller
+{
+public:
+    /**
+     * Default constructor. Not terribly useful, but it's valid to create
+     * an instance without associating it with an object. It's a no-op,
+     * like the more useful constructor below when NULL is passed to it.
+     */
+    AutoCaller()
+    {
+        init(NULL, false);
+    }
+
+    /**
+     * Increases the number of callers of the given object by calling
+     * ObjectState::addCaller() for the corresponding member instance.
+     *
+     * @param aObj      Object to add a normal caller to. If NULL, this
+     *                  instance is effectively turned to no-op (where
+     *                  hrc() will return S_OK).
+     */
+    AutoCaller(VirtualBoxBase *aObj)
+    {
+        init(aObj, false);
+    }
+
+    /**
+     * If the number of callers was successfully increased, decreases it
+     * using ObjectState::releaseCaller(), otherwise does nothing.
+     */
+    ~AutoCaller()
+    {
+        if (mObj && SUCCEEDED(mRC))
+            mObj->getObjectState().releaseCaller();
+    }
+
+    /**
+     * Returns the stored result code returned by ObjectState::addCaller() after
+     * instance creation or after the last #add() call.
+     *
+     * A successful result code means the number of callers was successfully
+     * increased.
+     */
+    HRESULT hrc() const { return mRC; }
+
+    /**
+     * Returns |true| if |SUCCEEDED(hrc())| is |true|, for convenience. |true| means
+     * the number of callers was successfully increased.
+     */
+    bool isOk() const { return SUCCEEDED(mRC); }
+
+    /**
+     * Returns |true| if |FAILED(hrc())| is |true|, for convenience. |true| means
+     * the number of callers was _not_ successfully increased.
+     */
+    bool isNotOk() const { return FAILED(mRC); }
+
+    /**
+     * Temporarily decreases the number of callers of the managed object.
+     * May only be called if #isOk() returns |true|. Note that #hrc() will return
+     * E_FAIL after this method succeeds.
+     */
+    void release()
+    {
+        Assert(SUCCEEDED(mRC));
+        if (SUCCEEDED(mRC))
+        {
+            if (mObj)
+                mObj->getObjectState().releaseCaller();
+            mRC = E_FAIL;
+        }
+    }
+
+    /**
+     * Restores the number of callers decreased by #release(). May only be
+     * called after #release().
+     */
+    void add()
+    {
+        Assert(!SUCCEEDED(mRC));
+        if (mObj && !SUCCEEDED(mRC))
+            mRC = mObj->getObjectState().addCaller(mLimited);
+    }
+
+    /**
+     * Attaches another object to this caller instance.
+     * The previous object's caller is released before the new one is added.
+     *
+     * @param aObj  New object to attach, may be @c NULL.
+     */
+    void attach(VirtualBoxBase *aObj)
+    {
+        /* detect simple self-reattachment */
+        if (mObj != aObj)
+        {
+            if (mObj && SUCCEEDED(mRC))
+                release();
+            else if (!mObj)
+            {
+                /* Fix up the success state when nothing is attached. Otherwise
+                 * there are a couple of assertion which would trigger. */
+                mRC = E_FAIL;
+            }
+            mObj = aObj;
+            add();
+        }
+    }
+
+    /** Verbose equivalent to <tt>attach(NULL)</tt>. */
+    void detach() { attach(NULL); }
+
+protected:
+    /**
+     * Internal constructor: Increases the number of callers of the given
+     * object (either normal or limited variant) by calling
+     * ObjectState::addCaller() for the corresponding member instance.
+     *
+     * @param aObj      Object to add a caller to. If NULL, this
+     *                  instance is effectively turned to no-op (where hrc() will
+     *                  return S_OK).
+     * @param aLimited  If |false|, then it's a regular caller, otherwise a
+     *                  limited caller.
+     */
+    void init(VirtualBoxBase *aObj, bool aLimited)
+    {
+        mObj = aObj;
+        mRC = S_OK;
+        mLimited = aLimited;
+        if (mObj)
+            mRC = mObj->getObjectState().addCaller(mLimited);
+    }
+
+private:
+    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(AutoCaller);
+    DECLARE_CLS_NEW_DELETE_NOOP(AutoCaller);
+
+    VirtualBoxBase *mObj;
+    HRESULT mRC;
+    bool mLimited;
+};
+
+/**
+ * Smart class that automatically increases the number of limited callers of
+ * the given VirtualBoxBase object when an instance is constructed and
+ * decreases it back when the created instance goes out of scope (i.e. gets
+ * destroyed).
+ *
+ * A typical usage pattern to declare a limited method of some object (i.e.
+ * a method that is valid even if the object doesn't provide its full
+ * functionality) is:
+ * <code>
+ * STDMETHODIMP Component::Bar()
+ * {
+ *     AutoLimitedCaller autoCaller(this);
+ *     HRESULT hrc = autoCaller.hrc();
+ *     if (SUCCEEDED(hrc))
+ *     {
+ *         ...
+ *     }
+ *     return hrc;
+ * </code>
+ *
+ * See AutoCaller for more information about auto caller functionality.
+ */
+class AutoLimitedCaller : public AutoCaller
+{
+public:
+    /**
+     * Default constructor. Not terribly useful, but it's valid to create
+     * an instance without associating it with an object. It's a no-op,
+     * like the more useful constructor below when NULL is passed to it.
+     */
+    AutoLimitedCaller()
+    {
+        AutoCaller::init(NULL, true);
+    }
+
+    /**
+     * Increases the number of callers of the given object by calling
+     * ObjectState::addCaller() for the corresponding member instance.
+     *
+     * @param aObj      Object to add a limited caller to. If NULL, this
+     *                  instance is effectively turned to no-op (where hrc() will
+     *                  return S_OK).
+     */
+    AutoLimitedCaller(VirtualBoxBase *aObj)
+    {
+        AutoCaller::init(aObj, true);
+    }
+
+private:
+    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(AutoLimitedCaller); /* Shuts up MSC warning C4625. */
+};
+
+/**
+ * Smart class to enclose the state transition NotReady->InInit->Ready.
+ *
+ * The purpose of this span is to protect object initialization.
+ *
+ * Instances must be created as a stack-based variable taking |this| pointer
+ * as the argument at the beginning of init() methods of VirtualBoxBase
+ * subclasses. When this variable is created it automatically places the
+ * object to the InInit state.
+ *
+ * When the created variable goes out of scope (i.e. gets destroyed) then,
+ * depending on the result status of this initialization span, it either
+ * places the object to Ready or Limited state or calls the object's
+ * VirtualBoxBase::uninit() method which is supposed to place the object
+ * back to the NotReady state using the AutoUninitSpan class.
+ *
+ * The initial result status of the initialization span is determined by the
+ * @a aResult argument of the AutoInitSpan constructor (Result::Failed by
+ * default). Inside the initialization span, the success status can be set
+ * to Result::Succeeded using #setSucceeded(), to to Result::Limited using
+ * #setLimited() or to Result::Failed using #setFailed(). Please don't
+ * forget to set the correct success status before getting the AutoInitSpan
+ * variable destroyed (for example, by performing an early return from
+ * the init() method)!
+ *
+ * Note that if an instance of this class gets constructed when the object
+ * is in the state other than NotReady, #isOk() returns |false| and methods
+ * of this class do nothing: the state transition is not performed.
+ *
+ * A typical usage pattern is:
+ * <code>
+ * HRESULT Component::init()
+ * {
+ *     AutoInitSpan autoInitSpan(this);
+ *     AssertReturn(autoInitSpan.isOk(), E_FAIL);
+ *     ...
+ *     if (FAILED(rc))
+ *         return rc;
+ *     ...
+ *     if (SUCCEEDED(rc))
+ *         autoInitSpan.setSucceeded();
+ *     return rc;
+ * }
+ * </code>
+ *
+ * @note Never create instances of this class outside init() methods of
+ *       VirtualBoxBase subclasses and never pass anything other than |this|
+ *       as the argument to the constructor!
+ */
+class AutoInitSpan
+{
+public:
+
+    enum Result { Failed = 0x0, Succeeded = 0x1, Limited = 0x2 };
+
+    AutoInitSpan(VirtualBoxBase *aObj, Result aResult = Failed);
+    ~AutoInitSpan();
+
+    /**
+     * Returns |true| if this instance has been created at the right moment
+     * (when the object was in the NotReady state) and |false| otherwise.
+     */
+    bool isOk() const { return mOk; }
+
+    /**
+     * Sets the initialization status to Succeeded to indicates successful
+     * initialization. The AutoInitSpan destructor will place the managed
+     * VirtualBoxBase object to the Ready state.
+     */
+    void setSucceeded() { mResult = Succeeded; }
+
+    /**
+     * Sets the initialization status to Succeeded to indicate limited
+     * (partly successful) initialization. The AutoInitSpan destructor will
+     * place the managed VirtualBoxBase object to the Limited state.
+     */
+    void setLimited() { mResult = Limited; }
+
+    /**
+     * Sets the initialization status to Succeeded to indicate limited
+     * (partly successful) initialization but also adds the initialization
+     * error if required for further reporting. The AutoInitSpan destructor
+     * will place the managed VirtualBoxBase object to the Limited state.
+     */
+    void setLimited(HRESULT rc)
+    {
+        mResult = Limited;
+        mFailedRC = rc;
+        mpFailedEI = new ErrorInfo();
+    }
+
+    /**
+     * Sets the initialization status to Failure to indicates failed
+     * initialization. The AutoInitSpan destructor will place the managed
+     * VirtualBoxBase object to the InitFailed state and will automatically
+     * call its uninit() method which is supposed to place the object back
+     * to the NotReady state using AutoUninitSpan.
+     */
+    void setFailed(HRESULT rc = E_ACCESSDENIED)
+    {
+        mResult = Failed;
+        mFailedRC = rc;
+        mpFailedEI = new ErrorInfo();
+    }
+
+    /** Returns the current initialization result. */
+    Result result() { return mResult; }
+
+private:
+
+    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(AutoInitSpan);
+    DECLARE_CLS_NEW_DELETE_NOOP(AutoInitSpan);
+
+    VirtualBoxBase *mObj;
+    Result mResult : 3; // must be at least total number of bits + 1 (sign)
+    bool mOk : 1;
+    HRESULT mFailedRC;
+    ErrorInfo *mpFailedEI;
+};
+
+/**
+ * Smart class to enclose the state transition Limited->InInit->Ready.
+ *
+ * The purpose of this span is to protect object re-initialization.
+ *
+ * Instances must be created as a stack-based variable taking |this| pointer
+ * as the argument at the beginning of methods of VirtualBoxBase
+ * subclasses that try to re-initialize the object to bring it to the Ready
+ * state (full functionality) after partial initialization (limited
+ * functionality). When this variable is created, it automatically places
+ * the object to the InInit state.
+ *
+ * When the created variable goes out of scope (i.e. gets destroyed),
+ * depending on the success status of this initialization span, it either
+ * places the object to the Ready state or brings it back to the Limited
+ * state.
+ *
+ * The initial success status of the re-initialization span is |false|. In
+ * order to make it successful, #setSucceeded() must be called before the
+ * instance is destroyed.
+ *
+ * Note that if an instance of this class gets constructed when the object
+ * is in the state other than Limited, #isOk() returns |false| and methods
+ * of this class do nothing: the state transition is not performed.
+ *
+ * A typical usage pattern is:
+ * <code>
+ * HRESULT Component::reinit()
+ * {
+ *     AutoReinitSpan autoReinitSpan(this);
+ *     AssertReturn(autoReinitSpan.isOk(), E_FAIL);
+ *     ...
+ *     if (FAILED(rc))
+ *         return rc;
+ *     ...
+ *     if (SUCCEEDED(rc))
+ *         autoReinitSpan.setSucceeded();
+ *     return rc;
+ * }
+ * </code>
+ *
+ * @note Never create instances of this class outside re-initialization
+ * methods of VirtualBoxBase subclasses and never pass anything other than
+ * |this| as the argument to the constructor!
+ */
+class AutoReinitSpan
+{
+public:
+
+    AutoReinitSpan(VirtualBoxBase *aObj);
+    ~AutoReinitSpan();
+
+    /**
+     * Returns |true| if this instance has been created at the right moment
+     * (when the object was in the Limited state) and |false| otherwise.
+     */
+    bool isOk() const { return mOk; }
+
+    /**
+     * Sets the re-initialization status to Succeeded to indicates
+     * successful re-initialization. The AutoReinitSpan destructor will place
+     * the managed VirtualBoxBase object to the Ready state.
+     */
+    void setSucceeded() { mSucceeded = true; }
+
+private:
+
+    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(AutoReinitSpan);
+    DECLARE_CLS_NEW_DELETE_NOOP(AutoReinitSpan);
+
+    VirtualBoxBase *mObj;
+    bool mSucceeded : 1;
+    bool mOk : 1;
+};
+
+/**
+ * Smart class to enclose the state transition Ready->InUninit->NotReady,
+ * InitFailed->InUninit->NotReady.
+ *
+ * The purpose of this span is to protect object uninitialization.
+ *
+ * Instances must be created as a stack-based variable taking |this| pointer
+ * as the argument at the beginning of uninit() methods of VirtualBoxBase
+ * subclasses. When this variable is created it automatically places the
+ * object to the InUninit state, unless it is already in the NotReady state
+ * as indicated by #uninitDone() returning |true|. In the latter case, the
+ * uninit() method must immediately return because there should be nothing
+ * to uninitialize.
+ *
+ * When this variable goes out of scope (i.e. gets destroyed), it places the
+ * object to NotReady state.
+ *
+ * A typical usage pattern is:
+ * <code>
+ * void Component::uninit()
+ * {
+ *     AutoUninitSpan autoUninitSpan(this);
+ *     if (autoUninitSpan.uninitDone())
+ *         return;
+ *     ...
+ * }
+ * </code>
+ *
+ * @note The constructor of this class blocks the current thread execution
+ *       until the number of callers added to the object using
+ *       ObjectState::addCaller() or AutoCaller drops to zero. For this reason,
+ *       it is forbidden to create instances of this class (or call uninit())
+ *       within the AutoCaller or ObjectState::addCaller() scope because it is
+ *       a guaranteed deadlock.
+ *
+ * @note Never create instances of this class outside uninit() methods and
+ *       never pass anything other than |this| as the argument to the
+ *       constructor!
+ */
+class AutoUninitSpan
+{
+public:
+
+    AutoUninitSpan(VirtualBoxBase *aObj, bool fTry = false);
+    ~AutoUninitSpan();
+
+    /** |true| when uninit() is called as a result of init() failure */
+    bool initFailed() { return mInitFailed; }
+
+    /** |true| when uninit() has already been called (so the object is NotReady) */
+    bool uninitDone() { return mUninitDone; }
+
+    /** |true| when uninit() has failed, relevant only if it was a "try uninit" */
+    bool uninitFailed() { return mUninitFailed; }
+
+    void setSucceeded();
+
+private:
+
+    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(AutoUninitSpan);
+    DECLARE_CLS_NEW_DELETE_NOOP(AutoUninitSpan);
+
+    VirtualBoxBase *mObj;
+    bool mInitFailed : 1;
+    bool mUninitDone : 1;
+    bool mUninitFailed : 1;
+};
+
+#endif /* !MAIN_INCLUDED_AutoCaller_h */
diff --git a/src/VBox/Main/include/AutoStateDep.h b/src/VBox/Main/include/AutoStateDep.h
new file mode 100644
index 00000000..7de2ef41
--- /dev/null
+++ b/src/VBox/Main/include/AutoStateDep.h
@@ -0,0 +1,214 @@
+/* $Id: AutoStateDep.h $ */
+
+#ifndef MAIN_INCLUDED_AutoStateDep_h
+#define MAIN_INCLUDED_AutoStateDep_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+/** @file
+ *
+ * AutoStateDep template classes, formerly in MachineImpl.h. Use these if
+ * you need to ensure that the machine state does not change over a certain
+ * period of time.
+ */
+
+/*
+ * 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
+ */
+
+    /**
+     *  Helper class that safely manages the machine state dependency by
+     *  calling Machine::addStateDependency() on construction and
+     *  Machine::releaseStateDependency() on destruction. Intended for Machine
+     *  children. The usage pattern is:
+     *
+     *  @code
+     *      AutoCaller autoCaller(this);
+     *      if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
+     *
+     *      Machine::AutoStateDependency<MutableStateDep> adep(mParent);
+     *      if (FAILED(stateDep.hrc())) return stateDep.hrc();
+     *      ...
+     *      // code that depends on the particular machine state
+     *      ...
+     *  @endcode
+     *
+     *  Note that it is more convenient to use the following individual
+     *  shortcut classes instead of using this template directly:
+     *  AutoAnyStateDependency, AutoMutableStateDependency,
+     *  AutoMutableOrSavedStateDependency, AutoMutableOrRunningStateDependency
+     *  or AutoMutableOrSavedOrRunningStateDependency. The usage pattern is
+     *  exactly the same as above except that there is no need to specify the
+     *  template argument because it is already done by the shortcut class.
+     *
+     *  @param taDepType    Dependency type to manage.
+     */
+    template <Machine::StateDependency taDepType = Machine::AnyStateDep>
+    class AutoStateDependency
+    {
+    public:
+
+        AutoStateDependency(Machine *aThat)
+            : mThat(aThat), mRC(S_OK),
+              mMachineState(MachineState_Null),
+              mRegistered(FALSE)
+        {
+            Assert(aThat);
+            mRC = aThat->i_addStateDependency(taDepType, &mMachineState,
+                                            &mRegistered);
+        }
+        ~AutoStateDependency()
+        {
+            if (SUCCEEDED(mRC))
+                mThat->i_releaseStateDependency();
+        }
+
+        /** Decreases the number of dependencies before the instance is
+         *  destroyed. Note that will reset #hrc() to E_FAIL. */
+        void release()
+        {
+            AssertReturnVoid(SUCCEEDED(mRC));
+            mThat->i_releaseStateDependency();
+            mRC = E_FAIL;
+        }
+
+        /** Restores the number of callers after by #release(). #hrc() will be
+         *  reset to the result of calling addStateDependency() and must be
+         *  rechecked to ensure the operation succeeded. */
+        void add()
+        {
+            AssertReturnVoid(!SUCCEEDED(mRC));
+            mRC = mThat->i_addStateDependency(taDepType, &mMachineState,
+                                            &mRegistered);
+        }
+
+        /** Returns the result of Machine::addStateDependency(). */
+        HRESULT hrc() const { return mRC; }
+
+        /** Shortcut to SUCCEEDED(hrc()). */
+        bool isOk() const { return SUCCEEDED(mRC); }
+
+        /** Returns the machine state value as returned by
+         *  Machine::addStateDependency(). */
+        MachineState_T machineState() const { return mMachineState; }
+
+        /** Returns the machine state value as returned by
+         *  Machine::addStateDependency(). */
+        BOOL machineRegistered() const { return mRegistered; }
+
+    protected:
+
+        Machine *mThat;
+        HRESULT mRC;
+        MachineState_T mMachineState;
+        BOOL mRegistered;
+
+    private:
+
+        DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(AutoStateDependency);
+        DECLARE_CLS_NEW_DELETE_NOOP(AutoStateDependency);
+    };
+
+    /**
+     *  Shortcut to AutoStateDependency<AnyStateDep>.
+     *  See AutoStateDependency to get the usage pattern.
+     *
+     *  Accepts any machine state and guarantees the state won't change before
+     *  this object is destroyed. If the machine state cannot be protected (as
+     *  a result of the state change currently in progress), this instance's
+     *  #hrc() method will indicate a failure, and the caller is not allowed to
+     *  rely on any particular machine state and should return the failed
+     *  result code to the upper level.
+     */
+    typedef AutoStateDependency<Machine::AnyStateDep> AutoAnyStateDependency;
+
+    /**
+     *  Shortcut to AutoStateDependency<MutableStateDep>.
+     *  See AutoStateDependency to get the usage pattern.
+     *
+     *  Succeeds only if the machine state is in one of the mutable states, and
+     *  guarantees the given mutable state won't change before this object is
+     *  destroyed. If the machine is not mutable, this instance's #hrc() method
+     *  will indicate a failure, and the caller is not allowed to rely on any
+     *  particular machine state and should return the failed result code to
+     *  the upper level.
+     *
+     *  Intended to be used within all setter methods of IMachine
+     *  children objects (DVDDrive, NetworkAdapter, AudioAdapter, etc.) to
+     *  provide data protection and consistency. There must be no VM process,
+     *  i.e. use for settings changes which are valid when the VM is shut down.
+     */
+    typedef AutoStateDependency<Machine::MutableStateDep> AutoMutableStateDependency;
+
+    /**
+     *  Shortcut to AutoStateDependency<MutableOrSavedStateDep>.
+     *  See AutoStateDependency to get the usage pattern.
+     *
+     *  Succeeds only if the machine state is in one of the mutable states, or
+     *  if the machine is in the Saved state, and guarantees the given mutable
+     *  state won't change before this object is destroyed. If the machine is
+     *  not mutable, this instance's #hrc() method will indicate a failure, and
+     *  the caller is not allowed to rely on any particular machine state and
+     *  should return the failed result code to the upper level.
+     *
+     *  Intended to be used within setter methods of IMachine
+     *  children objects that may operate on shut down or Saved machines.
+     */
+    typedef AutoStateDependency<Machine::MutableOrSavedStateDep> AutoMutableOrSavedStateDependency;
+
+    /**
+     *  Shortcut to AutoStateDependency<MutableOrRunningStateDep>.
+     *  See AutoStateDependency to get the usage pattern.
+     *
+     *  Succeeds only if the machine state is in one of the mutable states, or
+     *  if the machine is in the Running or Paused state, and guarantees the
+     *  given mutable state won't change before this object is destroyed. If
+     *  the machine is not mutable, this instance's #hrc() method will indicate
+     *  a failure, and the caller is not allowed to rely on any particular
+     *  machine state and should return the failed result code to the upper
+     *  level.
+     *
+     *  Intended to be used within setter methods of IMachine
+     *  children objects that may operate on shut down or running machines.
+     */
+    typedef AutoStateDependency<Machine::MutableOrRunningStateDep> AutoMutableOrRunningStateDependency;
+
+    /**
+     *  Shortcut to AutoStateDependency<MutableOrSavedOrRunningStateDep>.
+     *  See AutoStateDependency to get the usage pattern.
+     *
+     *  Succeeds only if the machine state is in one of the mutable states, or
+     *  if the machine is in the Running, Paused or Saved state, and guarantees
+     *  the given mutable state won't change before this object is destroyed.
+     *  If the machine is not mutable, this instance's #hrc() method will
+     *  indicate a failure, and the caller is not allowed to rely on any
+     *  particular machine state and should return the failed result code to
+     *  the upper level.
+     *
+     *  Intended to be used within setter methods of IMachine
+     *  children objects that may operate on shut down, running or saved
+     *  machines.
+     */
+    typedef AutoStateDependency<Machine::MutableOrSavedOrRunningStateDep> AutoMutableOrSavedOrRunningStateDependency;
+
+#endif /* !MAIN_INCLUDED_AutoStateDep_h */
+
diff --git a/src/VBox/Main/include/AutostartDb.h b/src/VBox/Main/include/AutostartDb.h
new file mode 100644
index 00000000..c939f220
--- /dev/null
+++ b/src/VBox/Main/include/AutostartDb.h
@@ -0,0 +1,109 @@
+/* $Id: AutostartDb.h $ */
+/** @file
+ * Main - Autostart database Interfaces.
+ */
+
+/*
+ * Copyright (C) 2012-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
+ */
+
+#ifndef MAIN_INCLUDED_AutostartDb_h
+#define MAIN_INCLUDED_AutostartDb_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/cdefs.h>
+#include <iprt/types.h>
+#include <iprt/critsect.h>
+
+class AutostartDb
+{
+    public:
+
+        AutostartDb();
+        ~AutostartDb();
+
+        /**
+         * Sets the path to the autostart database.
+         *
+         * @returns VBox status code.
+         * @param   pszAutostartDbPathNew    Path to the autostart database.
+         */
+        int setAutostartDbPath(const char *pszAutostartDbPathNew);
+
+        /**
+         * Add a autostart VM to the global database.
+         *
+         * @returns VBox status code.
+         * @retval VERR_PATH_NOT_FOUND if the autostart database directory is not set.
+         * @param   pszVMId    ID of the VM to add.
+         */
+        int addAutostartVM(const char *pszVMId);
+
+        /**
+         * Remove a autostart VM from the global database.
+         *
+         * @returns VBox status code.
+         * @retval VERR_PATH_NOT_FOUND if the autostart database directory is not set.
+         * @param   pszVMId    ID of the VM to remove.
+         */
+        int removeAutostartVM(const char *pszVMId);
+
+        /**
+         * Add a autostop VM to the global database.
+         *
+         * @returns VBox status code.
+         * @retval VERR_PATH_NOT_FOUND if the autostart database directory is not set.
+         * @param   pszVMId    ID of the VM to add.
+         */
+        int addAutostopVM(const char *pszVMId);
+
+        /**
+         * Remove a autostop VM from the global database.
+         *
+         * @returns VBox status code.
+         * @retval VERR_PATH_NOT_FOUND if the autostart database directory is not set.
+         * @param   pszVMId    ID of the VM to remove.
+         */
+        int removeAutostopVM(const char *pszVMId);
+
+    private:
+
+#ifdef RT_OS_LINUX
+        /** Critical section protecting the database against concurrent access. */
+        RTCRITSECT      CritSect;
+        /** Path to the autostart database. */
+        char           *m_pszAutostartDbPath;
+
+        /**
+         * Autostart database modification worker.
+         *
+         * @returns VBox status code.
+         * @param   fAutostart    Flag whether the autostart or autostop database is modified.
+         * @param   fAddVM        Flag whether a VM is added or removed from the database.
+         */
+        int autostartModifyDb(bool fAutostart, bool fAddVM);
+#endif
+};
+
+#endif /* !MAIN_INCLUDED_AutostartDb_h */
+
diff --git a/src/VBox/Main/include/BIOSSettingsImpl.h b/src/VBox/Main/include/BIOSSettingsImpl.h
new file mode 100644
index 00000000..efa01de4
--- /dev/null
+++ b/src/VBox/Main/include/BIOSSettingsImpl.h
@@ -0,0 +1,102 @@
+/* $Id: BIOSSettingsImpl.h $ */
+
+/** @file
+ *
+ * VirtualBox COM class implementation - Machine BIOS settings.
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_BIOSSettingsImpl_h
+#define MAIN_INCLUDED_BIOSSettingsImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "BIOSSettingsWrap.h"
+
+class GuestOSType;
+
+namespace settings
+{
+    struct BIOSSettings;
+}
+
+class ATL_NO_VTABLE BIOSSettings :
+    public BIOSSettingsWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(BIOSSettings)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Machine *parent);
+    HRESULT init(Machine *parent, BIOSSettings *that);
+    HRESULT initCopy(Machine *parent, BIOSSettings *that);
+    void uninit();
+
+    // public methods for internal purposes only
+    HRESULT i_loadSettings(const settings::BIOSSettings &data);
+    HRESULT i_saveSettings(settings::BIOSSettings &data);
+
+    void i_rollback();
+    void i_commit();
+    void i_copyFrom(BIOSSettings *aThat);
+    void i_applyDefaults(GuestOSType *aOsType);
+
+private:
+
+    // wrapped IBIOSettings properties
+    HRESULT getLogoFadeIn(BOOL *enabled);
+    HRESULT setLogoFadeIn(BOOL enable);
+    HRESULT getLogoFadeOut(BOOL *enabled);
+    HRESULT setLogoFadeOut(BOOL enable);
+    HRESULT getLogoDisplayTime(ULONG *displayTime);
+    HRESULT setLogoDisplayTime(ULONG displayTime);
+    HRESULT getLogoImagePath(com::Utf8Str &imagePath);
+    HRESULT setLogoImagePath(const com::Utf8Str &imagePath);
+    HRESULT getBootMenuMode(BIOSBootMenuMode_T *bootMenuMode);
+    HRESULT setBootMenuMode(BIOSBootMenuMode_T bootMenuMode);
+    HRESULT getACPIEnabled(BOOL *enabled);
+    HRESULT setACPIEnabled(BOOL enable);
+    HRESULT getIOAPICEnabled(BOOL *aIOAPICEnabled);
+    HRESULT setIOAPICEnabled(BOOL aIOAPICEnabled);
+    HRESULT getAPICMode(APICMode_T *aAPICMode);
+    HRESULT setAPICMode(APICMode_T aAPICMode);
+    HRESULT getTimeOffset(LONG64 *offset);
+    HRESULT setTimeOffset(LONG64 offset);
+    HRESULT getPXEDebugEnabled(BOOL *enabled);
+    HRESULT setPXEDebugEnabled(BOOL enable);
+    HRESULT getSMBIOSUuidLittleEndian(BOOL *enabled);
+    HRESULT setSMBIOSUuidLittleEndian(BOOL enable);
+
+    struct Data;
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_BIOSSettingsImpl_h */
+
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/BandwidthControlImpl.h b/src/VBox/Main/include/BandwidthControlImpl.h
new file mode 100644
index 00000000..ceb8c452
--- /dev/null
+++ b/src/VBox/Main/include/BandwidthControlImpl.h
@@ -0,0 +1,111 @@
+/* $Id: BandwidthControlImpl.h $ */
+/** @file
+ *
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_BandwidthControlImpl_h
+#define MAIN_INCLUDED_BandwidthControlImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "BandwidthControlWrap.h"
+
+class BandwidthGroup;
+
+namespace settings
+{
+    struct IOSettings;
+}
+
+class ATL_NO_VTABLE BandwidthControl :
+    public BandwidthControlWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(BandwidthControl)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Machine *aParent);
+    HRESULT init(Machine *aParent, BandwidthControl *aThat);
+    HRESULT initCopy(Machine *aParent, BandwidthControl *aThat);
+    void uninit();
+
+    // public internal methods
+    HRESULT i_loadSettings(const settings::IOSettings &data);
+    HRESULT i_saveSettings(settings::IOSettings &data);
+    void i_rollback();
+    void i_commit();
+    void i_copyFrom(BandwidthControl *aThat);
+    Machine *i_getMachine() const;
+    HRESULT i_getBandwidthGroupByName(const Utf8Str &aName,
+                                      ComObjPtr<BandwidthGroup> &aBandwidthGroup,
+                                      bool aSetError /* = false */);
+
+private:
+
+    // wrapped IBandwidthControl properties
+    HRESULT getNumGroups(ULONG *aNumGroups);
+
+    // wrapped IBandwidthControl methods
+    HRESULT createBandwidthGroup(const com::Utf8Str &aName,
+                                       BandwidthGroupType_T aType,
+                                       LONG64 aMaxBytesPerSec);
+    HRESULT deleteBandwidthGroup(const com::Utf8Str &aName);
+    HRESULT getBandwidthGroup(const com::Utf8Str &aName,
+                                    ComPtr<IBandwidthGroup> &aBandwidthGroup);
+    HRESULT getAllBandwidthGroups(std::vector<ComPtr<IBandwidthGroup> > &aBandwidthGroups);
+
+    // Data
+    typedef std::list< ComObjPtr<BandwidthGroup> > BandwidthGroupList;
+
+    struct Data
+    {
+        Data(Machine *pMachine)
+        : pParent(pMachine)
+        { }
+
+        ~Data()
+        {};
+
+        Machine * const                 pParent;
+
+        // peer machine's bandwidth control
+        const ComObjPtr<BandwidthControl>  pPeer;
+
+        // the following fields need special backup/rollback/commit handling,
+        // so they cannot be a part of BackupableData
+        Backupable<BandwidthGroupList>    llBandwidthGroups;
+    };
+
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_BandwidthControlImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/BandwidthGroupImpl.h b/src/VBox/Main/include/BandwidthGroupImpl.h
new file mode 100644
index 00000000..9bd56a98
--- /dev/null
+++ b/src/VBox/Main/include/BandwidthGroupImpl.h
@@ -0,0 +1,115 @@
+/* $Id: BandwidthGroupImpl.h $ */
+/** @file
+ *
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_BandwidthGroupImpl_h
+#define MAIN_INCLUDED_BandwidthGroupImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/settings.h>
+#include "BandwidthControlImpl.h"
+#include "BandwidthGroupWrap.h"
+
+
+class ATL_NO_VTABLE BandwidthGroup :
+    public BandwidthGroupWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(BandwidthGroup)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(BandwidthControl *aParent,
+                 const com::Utf8Str &aName,
+                 BandwidthGroupType_T aType,
+                 LONG64 aMaxBytesPerSec);
+    HRESULT init(BandwidthControl *aParent, BandwidthGroup *aThat, bool aReshare = false);
+    HRESULT initCopy(BandwidthControl *aParent, BandwidthGroup *aThat);
+    void uninit();
+
+    // public methods only for internal purposes
+    void i_rollback();
+    void i_commit();
+    void i_unshare();
+    void i_reference();
+    void i_release();
+
+    ComObjPtr<BandwidthGroup> i_getPeer() { return m->pPeer; }
+    const Utf8Str &i_getName() const { return m->bd->mData.strName; }
+    BandwidthGroupType_T i_getType() const { return m->bd->mData.enmType; }
+    LONG64 i_getMaxBytesPerSec() const { return (LONG64)m->bd->mData.cMaxBytesPerSec; }
+    ULONG i_getReferences() const { return m->bd->cReferences; }
+
+private:
+
+    // wrapped IBandwidthGroup properties
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT getType(BandwidthGroupType_T *aType);
+    HRESULT getReference(ULONG *aReferences);
+    HRESULT getMaxBytesPerSec(LONG64 *aMaxBytesPerSec);
+    HRESULT setMaxBytesPerSec(LONG64 MaxBytesPerSec);
+
+    ////////////////////////////////////////////////////////////////////////////////
+    ////
+    //// private member data definition
+    ////
+    //////////////////////////////////////////////////////////////////////////////////
+    //
+    struct BackupableBandwidthGroupData
+    {
+       BackupableBandwidthGroupData()
+           : cReferences(0)
+       { }
+
+       settings::BandwidthGroup mData;
+       ULONG                    cReferences;
+    };
+
+    struct Data
+    {
+        Data(BandwidthControl * const aBandwidthControl)
+            : pParent(aBandwidthControl),
+              pPeer(NULL)
+        { }
+
+       BandwidthControl * const    pParent;
+       ComObjPtr<BandwidthGroup>   pPeer;
+
+       // use the XML settings structure in the members for simplicity
+       Backupable<BackupableBandwidthGroupData> bd;
+    };
+
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_BandwidthGroupImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/BusAssignmentManager.h b/src/VBox/Main/include/BusAssignmentManager.h
new file mode 100644
index 00000000..d3bff5cd
--- /dev/null
+++ b/src/VBox/Main/include/BusAssignmentManager.h
@@ -0,0 +1,90 @@
+/* $Id: BusAssignmentManager.h $ */
+/** @file
+ * VirtualBox bus slots assignment manager
+ */
+
+/*
+ * Copyright (C) 2010-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
+ */
+
+#ifndef MAIN_INCLUDED_BusAssignmentManager_h
+#define MAIN_INCLUDED_BusAssignmentManager_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "VBox/types.h"
+#include "VBox/pci.h"
+#include "VirtualBoxBase.h"
+#include <vector>
+
+class BusAssignmentManager
+{
+private:
+    struct State;
+    State *pState;
+
+    BusAssignmentManager();
+    virtual ~BusAssignmentManager();
+
+    HRESULT assignPCIDeviceImpl(const char *pszDevName, PCFGMNODE pCfg, PCIBusAddress& GuestAddress,
+                                PCIBusAddress HostAddress, bool fGuestAddressRequired = false);
+
+public:
+    struct PCIDeviceInfo
+    {
+        com::Utf8Str strDeviceName;
+        PCIBusAddress guestAddress;
+        PCIBusAddress hostAddress;
+    };
+
+    static BusAssignmentManager *createInstance(PCVMMR3VTABLE pVMM, ChipsetType_T chipsetType, IommuType_T iommuType);
+    virtual void AddRef();
+    virtual void Release();
+
+    virtual HRESULT assignHostPCIDevice(const char *pszDevName, PCFGMNODE pCfg, PCIBusAddress HostAddress,
+                                        PCIBusAddress& GuestAddress, bool fAddressRequired = false)
+    {
+        return assignPCIDeviceImpl(pszDevName, pCfg, GuestAddress, HostAddress, fAddressRequired);
+    }
+
+    virtual HRESULT assignPCIDevice(const char *pszDevName, PCFGMNODE pCfg, PCIBusAddress& Address, bool fAddressRequired = false)
+    {
+        PCIBusAddress HostAddress;
+        return assignPCIDeviceImpl(pszDevName, pCfg, Address, HostAddress, fAddressRequired);
+    }
+
+    virtual HRESULT assignPCIDevice(const char *pszDevName, PCFGMNODE pCfg)
+    {
+        PCIBusAddress GuestAddress;
+        PCIBusAddress HostAddress;
+        return assignPCIDeviceImpl(pszDevName, pCfg, GuestAddress, HostAddress, false);
+    }
+    virtual bool findPCIAddress(const char *pszDevName, int iInstance, PCIBusAddress& Address);
+    virtual bool hasPCIDevice(const char *pszDevName, int iInstance)
+    {
+        PCIBusAddress Address;
+        return findPCIAddress(pszDevName, iInstance, Address);
+    }
+    virtual void listAttachedPCIDevices(std::vector<PCIDeviceInfo> &aAttached);
+};
+
+#endif /* !MAIN_INCLUDED_BusAssignmentManager_h */
diff --git a/src/VBox/Main/include/CPUProfileImpl.h b/src/VBox/Main/include/CPUProfileImpl.h
new file mode 100644
index 00000000..bf8aa73a
--- /dev/null
+++ b/src/VBox/Main/include/CPUProfileImpl.h
@@ -0,0 +1,75 @@
+/* $Id: CPUProfileImpl.h $ */
+/** @file
+ * VirtualBox Main - interface for CPU profiles, VBoxSVC.
+ */
+
+/*
+ * Copyright (C) 2020-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
+ */
+
+#ifndef MAIN_INCLUDED_CPUProfileImpl_h
+#define MAIN_INCLUDED_CPUProfileImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "CPUProfileWrap.h"
+
+struct CPUMDBENTRY;
+
+/**
+ * A CPU profile.
+ */
+class ATL_NO_VTABLE CPUProfile
+    : public CPUProfileWrap
+{
+public:
+    /** @name COM and internal init/term/mapping cruft
+     * @{ */
+    DECLARE_COMMON_CLASS_METHODS(CPUProfile)
+    HRESULT FinalConstruct();
+    void    FinalRelease();
+    HRESULT initFromDbEntry(struct CPUMDBENTRY const *a_pDbEntry) RT_NOEXCEPT;
+    void    uninit();
+    /** @} */
+
+    bool    i_match(CPUArchitecture_T a_enmArchitecture, CPUArchitecture_T a_enmSecondaryArch,
+                    const com::Utf8Str &a_strNamePattern) const RT_NOEXCEPT;
+
+private:
+    /** @name Wrapped ICPUProfile attributes
+     * @{ */
+    HRESULT getName(com::Utf8Str &aName) RT_OVERRIDE;
+    HRESULT getFullName(com::Utf8Str &aFullName) RT_OVERRIDE;
+    HRESULT getArchitecture(CPUArchitecture_T *aArchitecture) RT_OVERRIDE;
+    /** @} */
+
+    /** @name Data
+     * @{ */
+    com::Utf8Str        m_strName;
+    com::Utf8Str        m_strFullName;
+    CPUArchitecture_T   m_enmArchitecture;
+    /** @} */
+};
+
+#endif /* !MAIN_INCLUDED_CPUProfileImpl_h */
+
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/CertificateImpl.h b/src/VBox/Main/include/CertificateImpl.h
new file mode 100644
index 00000000..51f7ecf9
--- /dev/null
+++ b/src/VBox/Main/include/CertificateImpl.h
@@ -0,0 +1,112 @@
+/* $Id: CertificateImpl.h $ */
+/** @file
+ * VirtualBox COM ICertificate implementation.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_CertificateImpl_h
+#define MAIN_INCLUDED_CertificateImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+/* VBox includes */
+#include <iprt/crypto/x509.h>
+#include "CertificateWrap.h"
+
+#include <vector>
+
+using namespace std;
+
+/**
+ * Implemenation of ICertificate.
+ *
+ * This implemenation is a very thin wrapper around an immutable
+ * RTCRX509CERTIFICATE and a few caller stated views.
+ *
+ * The views are whether the caller thinks the certificate is trustworthly, and
+ * whether the caller thinks it's expired or not.  The caller could be sitting
+ * on more information, like timestamp and intermediate certificates, that helps
+ * inform the caller's view on these two topics.
+ *
+ * @remarks It could be helpful to let the caller also add certificate paths
+ *          showing how this certificate ends up being trusted.  However, that's
+ *          possibly quite some work and will have to wait till required...
+ */
+class ATL_NO_VTABLE Certificate
+    : public CertificateWrap
+{
+
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(Certificate)
+
+    HRESULT initCertificate(PCRTCRX509CERTIFICATE a_pCert, bool a_fTrusted, bool a_fExpired);
+    void uninit();
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+private:
+    // Wrapped ICertificate properties
+    HRESULT getVersionNumber(CertificateVersion_T *aVersionNumber);
+    HRESULT getSerialNumber(com::Utf8Str &aSerialNumber);
+    HRESULT getSignatureAlgorithmOID(com::Utf8Str &aSignatureAlgorithmOID);
+    HRESULT getSignatureAlgorithmName(com::Utf8Str &aSignatureAlgorithmName);
+    HRESULT getPublicKeyAlgorithmOID(com::Utf8Str &aPublicKeyAlgorithmOID);
+    HRESULT getPublicKeyAlgorithm(com::Utf8Str &aPublicKeyAlgorithm);
+    HRESULT getIssuerName(std::vector<com::Utf8Str> &aIssuerName);
+    HRESULT getSubjectName(std::vector<com::Utf8Str> &aSubjectName);
+    HRESULT getFriendlyName(com::Utf8Str &aFriendlyName);
+    HRESULT getValidityPeriodNotBefore(com::Utf8Str &aValidityPeriodNotBefore);
+    HRESULT getValidityPeriodNotAfter(com::Utf8Str &aValidityPeriodNotAfter);
+    HRESULT getSubjectPublicKey(std::vector<BYTE> &aSubjectPublicKey);
+    HRESULT getIssuerUniqueIdentifier(com::Utf8Str &aIssuerUniqueIdentifier);
+    HRESULT getSubjectUniqueIdentifier(com::Utf8Str &aSubjectUniqueIdentifier);
+    HRESULT getCertificateAuthority(BOOL *aCertificateAuthority);
+    HRESULT getKeyUsage(ULONG *aKeyUsage);
+    HRESULT getExtendedKeyUsage(std::vector<com::Utf8Str> &aExtendedKeyUsage);
+    HRESULT getRawCertData(std::vector<BYTE> &aRawCertData);
+    HRESULT getSelfSigned(BOOL *aSelfSigned);
+    HRESULT getTrusted(BOOL *aTrusted);
+    HRESULT getExpired(BOOL *aExpired);
+
+    // Wrapped ICertificate methods
+    HRESULT isCurrentlyExpired(BOOL *aResult);
+    HRESULT queryInfo(LONG aWhat, com::Utf8Str &aResult);
+
+    // Methods extracting COM data from the certificate object
+    HRESULT i_getAlgorithmName(PCRTCRX509ALGORITHMIDENTIFIER a_pAlgId, com::Utf8Str &a_rReturn);
+    HRESULT i_getX509Name(PCRTCRX509NAME a_pName, std::vector<com::Utf8Str> &a_rReturn);
+    HRESULT i_getTime(PCRTASN1TIME a_pTime, com::Utf8Str &a_rReturn);
+    HRESULT i_getUniqueIdentifier(PCRTCRX509UNIQUEIDENTIFIER a_pUniqueId, com::Utf8Str &a_rReturn);
+    HRESULT i_getEncodedBytes(PRTASN1CORE a_pAsn1Obj, std::vector<BYTE> &a_rReturn);
+
+    struct Data;
+    /** Pointer to the private instance data   */
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_CertificateImpl_h */
+
diff --git a/src/VBox/Main/include/ClientToken.h b/src/VBox/Main/include/ClientToken.h
new file mode 100644
index 00000000..52f1e2f1
--- /dev/null
+++ b/src/VBox/Main/include/ClientToken.h
@@ -0,0 +1,118 @@
+/* $Id: ClientToken.h $ */
+
+/** @file
+ *
+ * VirtualBox API client session token abstraction
+ */
+
+/*
+ * Copyright (C) 2013-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
+ */
+
+#ifndef MAIN_INCLUDED_ClientToken_h
+#define MAIN_INCLUDED_ClientToken_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/com/ptr.h>
+#include <VBox/com/AutoLock.h>
+
+#include "MachineImpl.h"
+#ifdef VBOX_WITH_GENERIC_SESSION_WATCHER
+# include "TokenImpl.h"
+#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
+
+#if defined(RT_OS_WINDOWS)
+# define CTTOKENARG NULL
+# define CTTOKENTYPE HANDLE
+#elif defined(RT_OS_OS2)
+# define CTTOKENARG NULLHANDLE
+# define CTTOKENTYPE HMTX
+#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
+# define CTTOKENARG -1
+# define CTTOKENTYPE int
+#elif defined(VBOX_WITH_GENERIC_SESSION_WATCHER)
+# define CTTOKENARG NULL
+# define CTTOKENTYPE MachineToken *
+#else
+# error "Port me!"
+#endif
+
+/**
+ * Class which represents a token which can be used to check for client
+ * crashes and similar purposes.
+ */
+class Machine::ClientToken
+{
+public:
+    /**
+     * Constructor which creates a usable instance
+     *
+     * @param pMachine          Reference to Machine object
+     * @param pSessionMachine   Reference to corresponding SessionMachine object
+     */
+    ClientToken(const ComObjPtr<Machine> &pMachine, SessionMachine *pSessionMachine);
+
+    /**
+     * Default destructor. Cleans everything up.
+     */
+    ~ClientToken();
+
+    /**
+     * Check if object contains a usable token.
+     */
+    bool isReady();
+
+    /**
+     * Query token ID, which is a unique string value for this token. Do not
+     * assume any specific content/format, it is opaque information.
+     */
+    void getId(Utf8Str &strId);
+
+    /**
+     * Query token, which is platform dependent.
+     */
+    CTTOKENTYPE getToken();
+
+#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
+    /**
+     * Release token now. Returns information if the client has terminated.
+     */
+    bool release();
+#endif /* !VBOX_WITH_GENERIC_SESSION_WATCHER */
+
+private:
+    /**
+     * Default constructor. Don't use, will not create a sensible instance.
+     */
+    ClientToken();
+
+    Machine *mMachine;
+    CTTOKENTYPE mClientToken;
+    Utf8Str mClientTokenId;
+#ifdef VBOX_WITH_GENERIC_SESSION_WATCHER
+    bool mClientTokenPassed;
+#endif
+};
+
+#endif /* !MAIN_INCLUDED_ClientToken_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/ClientTokenHolder.h b/src/VBox/Main/include/ClientTokenHolder.h
new file mode 100644
index 00000000..a6bf3262
--- /dev/null
+++ b/src/VBox/Main/include/ClientTokenHolder.h
@@ -0,0 +1,112 @@
+/* $Id: ClientTokenHolder.h $ */
+
+/** @file
+ *
+ * VirtualBox API client session token holder (in the client process)
+ */
+
+/*
+ * Copyright (C) 2013-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
+ */
+
+#ifndef MAIN_INCLUDED_ClientTokenHolder_h
+#define MAIN_INCLUDED_ClientTokenHolder_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "SessionImpl.h"
+
+#if defined(RT_OS_WINDOWS)
+# define CTHSEMARG NULL
+# define CTHSEMTYPE HANDLE
+/* this second semaphore is only used on Windows */
+# define CTHTHREADSEMARG NULL
+# define CTHTHREADSEMTYPE HANDLE
+#elif defined(RT_OS_OS2)
+# define CTHSEMARG NIL_RTSEMEVENT
+# define CTHSEMTYPE RTSEMEVENT
+#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
+# define CTHSEMARG -1
+# define CTHSEMTYPE int
+#elif defined(VBOX_WITH_GENERIC_SESSION_WATCHER)
+/* the token object based implementation needs no semaphores */
+#else
+# error "Port me!"
+#endif
+
+
+/**
+ * Class which holds a client token.
+ */
+class Session::ClientTokenHolder
+{
+public:
+#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
+    /**
+     * Constructor which creates a usable instance
+     *
+     * @param strTokenId    String with identifier of the token
+     */
+    ClientTokenHolder(const Utf8Str &strTokenId);
+#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
+    /**
+     * Constructor which creates a usable instance
+     *
+     * @param aToken        Reference to token object
+     */
+    ClientTokenHolder(IToken *aToken);
+#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
+
+    /**
+     * Default destructor. Cleans everything up.
+     */
+    ~ClientTokenHolder();
+
+    /**
+     * Check if object contains a usable token.
+     */
+    bool isReady();
+
+private:
+    /**
+     * Default constructor. Don't use, will not create a sensible instance.
+     */
+    ClientTokenHolder();
+
+#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
+    Utf8Str mClientTokenId;
+#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
+    ComPtr<IToken> mToken;
+#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
+#ifdef CTHSEMTYPE
+    CTHSEMTYPE mSem;
+#endif
+#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
+    RTTHREAD mThread;
+#endif
+#ifdef RT_OS_WINDOWS
+    CTHTHREADSEMTYPE mThreadSem;
+#endif
+};
+
+#endif /* !MAIN_INCLUDED_ClientTokenHolder_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/ClientWatcher.h b/src/VBox/Main/include/ClientWatcher.h
new file mode 100644
index 00000000..962817eb
--- /dev/null
+++ b/src/VBox/Main/include/ClientWatcher.h
@@ -0,0 +1,146 @@
+/* $Id: ClientWatcher.h $ */
+/** @file
+ * VirtualBox API client session watcher
+ */
+
+/*
+ * Copyright (C) 2013-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
+ */
+
+#ifndef MAIN_INCLUDED_ClientWatcher_h
+#define MAIN_INCLUDED_ClientWatcher_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+
+#include <list>
+#include <VBox/com/ptr.h>
+#include <VBox/com/AutoLock.h>
+
+#include "VirtualBoxImpl.h"
+
+#if defined(RT_OS_WINDOWS)
+# define CWUPDATEREQARG NULL
+# define CWUPDATEREQTYPE HANDLE
+# define CW_MAX_CLIENTS  _16K            /**< Max number of clients we can watch (windows). */
+# ifndef DEBUG /* The debug version triggers worker thread code much much earlier. */
+#  define CW_MAX_CLIENTS_PER_THREAD 63   /**< Max clients per watcher thread (windows). */
+# else
+#  define CW_MAX_CLIENTS_PER_THREAD 3    /**< Max clients per watcher thread (windows). */
+# endif
+# define CW_MAX_HANDLES_PER_THREAD (CW_MAX_CLIENTS_PER_THREAD + 1) /**< Max handles per thread. */
+
+#elif defined(RT_OS_OS2)
+# define CWUPDATEREQARG NIL_RTSEMEVENT
+# define CWUPDATEREQTYPE RTSEMEVENT
+
+#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER) || defined(VBOX_WITH_GENERIC_SESSION_WATCHER)
+# define CWUPDATEREQARG NIL_RTSEMEVENT
+# define CWUPDATEREQTYPE RTSEMEVENT
+
+#else
+# error "Port me!"
+#endif
+
+/**
+ * Class which checks for API clients which have crashed/exited, and takes
+ * the necessary cleanup actions. Singleton.
+ */
+class VirtualBox::ClientWatcher
+{
+public:
+    /**
+     * Constructor which creates a usable instance
+     *
+     * @param pVirtualBox   Reference to VirtualBox object
+     */
+    ClientWatcher(const ComObjPtr<VirtualBox> &pVirtualBox);
+
+    /**
+     * Default destructor. Cleans everything up.
+     */
+    ~ClientWatcher();
+
+    bool isReady();
+
+    void update();
+    void addProcess(RTPROCESS pid);
+
+private:
+    /**
+     * Default constructor. Don't use, will not create a sensible instance.
+     */
+    ClientWatcher();
+
+    static DECLCALLBACK(int) worker(RTTHREAD hThreadSelf, void *pvUser);
+    uint32_t reapProcesses(void);
+
+    VirtualBox *mVirtualBox;
+    RTTHREAD mThread;
+    CWUPDATEREQTYPE mUpdateReq;
+    util::RWLockHandle mLock;
+
+    typedef std::list<RTPROCESS> ProcessList;
+    ProcessList mProcesses;
+
+#if defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER) || defined(VBOX_WITH_GENERIC_SESSION_WATCHER)
+    uint8_t mUpdateAdaptCtr;
+#endif
+#ifdef RT_OS_WINDOWS
+    /** Indicate a real update request is pending.
+     * To avoid race conditions this must be set before mUpdateReq is signalled and
+     * read after resetting mUpdateReq. */
+    volatile bool mfUpdateReq;
+    /** Set when the worker threads are supposed to shut down. */
+    volatile bool mfTerminate;
+    /** Number of active subworkers.
+     * When decremented to 0, subworker zero is signalled. */
+    uint32_t volatile mcActiveSubworkers;
+    /** Number of valid handles in mahWaitHandles. */
+    uint32_t    mcWaitHandles;
+    /** The wait interval (usually INFINITE). */
+    uint32_t    mcMsWait;
+    /** Per subworker data. Subworker 0 is the main worker and does not have a
+     *  pReq pointer since. */
+    struct PerSubworker
+    {
+        /** The wait result. */
+        DWORD                       dwWait;
+        /** The subworker index. */
+        uint32_t                    iSubworker;
+        /** The subworker thread handle. */
+        RTTHREAD                    hThread;
+        /** Self pointer (for worker thread). */
+        VirtualBox::ClientWatcher  *pSelf;
+    } maSubworkers[(CW_MAX_CLIENTS + CW_MAX_CLIENTS_PER_THREAD - 1) / CW_MAX_CLIENTS_PER_THREAD];
+    /** Wait handle array. The mUpdateReq manual reset event handle is inserted
+     * every 64 entries, first entry being 0. */
+    HANDLE      mahWaitHandles[CW_MAX_CLIENTS + (CW_MAX_CLIENTS + CW_MAX_CLIENTS_PER_THREAD - 1) / CW_MAX_CLIENTS_PER_THREAD];
+
+    void subworkerWait(VirtualBox::ClientWatcher::PerSubworker *pSubworker, uint32_t cMsWait);
+    static DECLCALLBACK(int) subworkerThread(RTTHREAD hThreadSelf, void *pvUser);
+    void winResetHandleArray(uint32_t cProcHandles);
+#endif
+};
+
+#endif /* !MAIN_INCLUDED_ClientWatcher_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/CloudGateway.h b/src/VBox/Main/include/CloudGateway.h
new file mode 100644
index 00000000..06863d61
--- /dev/null
+++ b/src/VBox/Main/include/CloudGateway.h
@@ -0,0 +1,103 @@
+/* $Id: CloudGateway.h $ */
+/** @file
+ * Implementation of local and cloud gateway management.
+ */
+
+/*
+ * Copyright (C) 2019-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
+ */
+
+#ifndef MAIN_INCLUDED_CloudGateway_h
+#define MAIN_INCLUDED_CloudGateway_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+struct GatewayInfo
+{
+    Bstr    mTargetVM;
+    Utf8Str mGatewayInstanceId;
+    Utf8Str mPublicSshKey;
+    Utf8Str mPrivateSshKey;
+    Bstr    mCloudProvider;
+    Bstr    mCloudProfile;
+    Utf8Str mCloudPublicIp;
+    Utf8Str mCloudSecondaryPublicIp;
+    RTMAC   mCloudMacAddress;
+    RTMAC   mLocalMacAddress;
+    int     mAdapterSlot;
+
+    HRESULT setCloudMacAddress(const Utf8Str& mac);
+    HRESULT setLocalMacAddress(const Utf8Str& mac);
+
+    GatewayInfo() {}
+
+    GatewayInfo(const GatewayInfo& other)
+        : mGatewayInstanceId(other.mGatewayInstanceId),
+          mPublicSshKey(other.mPublicSshKey),
+          mPrivateSshKey(other.mPrivateSshKey),
+          mCloudProvider(other.mCloudProvider),
+          mCloudProfile(other.mCloudProfile),
+          mCloudPublicIp(other.mCloudPublicIp),
+          mCloudSecondaryPublicIp(other.mCloudSecondaryPublicIp),
+          mCloudMacAddress(other.mCloudMacAddress),
+          mLocalMacAddress(other.mLocalMacAddress),
+          mAdapterSlot(other.mAdapterSlot)
+    {}
+
+    GatewayInfo& operator=(const GatewayInfo& other)
+    {
+        mGatewayInstanceId = other.mGatewayInstanceId;
+        mPublicSshKey = other.mPublicSshKey;
+        mPrivateSshKey = other.mPrivateSshKey;
+        mCloudProvider = other.mCloudProvider;
+        mCloudProfile = other.mCloudProfile;
+        mCloudPublicIp = other.mCloudPublicIp;
+        mCloudSecondaryPublicIp = other.mCloudSecondaryPublicIp;
+        mCloudMacAddress = other.mCloudMacAddress;
+        mLocalMacAddress = other.mLocalMacAddress;
+        mAdapterSlot = other.mAdapterSlot;
+        return *this;
+    }
+
+    void setNull()
+    {
+        mGatewayInstanceId.setNull();
+        mPublicSshKey.setNull();
+        mPrivateSshKey.setNull();
+        mCloudProvider.setNull();
+        mCloudProfile.setNull();
+        mCloudPublicIp.setNull();
+        mCloudSecondaryPublicIp.setNull();
+        memset(&mCloudMacAddress, 0, sizeof(mCloudMacAddress));
+        memset(&mLocalMacAddress, 0, sizeof(mLocalMacAddress));
+        mAdapterSlot = -1;
+    }
+};
+
+class CloudNetwork;
+
+HRESULT startCloudGateway(ComPtr<IVirtualBox> virtualBox, ComPtr<ICloudNetwork> network, GatewayInfo& pGateways);
+HRESULT stopCloudGateway(ComPtr<IVirtualBox> virtualBox, GatewayInfo& gateways);
+HRESULT generateKeys(GatewayInfo& gateways);
+
+#endif /* !MAIN_INCLUDED_CloudGateway_h */
+
diff --git a/src/VBox/Main/include/CloudNetworkImpl.h b/src/VBox/Main/include/CloudNetworkImpl.h
new file mode 100644
index 00000000..cde8314a
--- /dev/null
+++ b/src/VBox/Main/include/CloudNetworkImpl.h
@@ -0,0 +1,79 @@
+/* $Id: CloudNetworkImpl.h $ */
+/** @file
+ * ICloudNetwork implementation header, lives in VBoxSVC.
+ */
+
+/*
+ * Copyright (C) 2019-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
+ */
+
+#ifndef MAIN_INCLUDED_CloudNetworkImpl_h
+#define MAIN_INCLUDED_CloudNetworkImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "CloudNetworkWrap.h"
+
+namespace settings
+{
+    struct CloudNetwork;
+}
+
+class ATL_NO_VTABLE CloudNetwork :
+    public CloudNetworkWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(CloudNetwork)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    HRESULT init(VirtualBox *aVirtualBox, com::Utf8Str aName);
+    HRESULT i_loadSettings(const settings::CloudNetwork &data);
+    void uninit();
+    HRESULT i_saveSettings(settings::CloudNetwork &data);
+
+    // Internal methods
+    Utf8Str i_getNetworkName();
+    Utf8Str i_getProvider();
+    Utf8Str i_getProfile();
+    Utf8Str i_getNetworkId();
+private:
+
+    // Wrapped ICloudNetwork properties
+    HRESULT getNetworkName(com::Utf8Str &aNetworkName);
+    HRESULT setNetworkName(const com::Utf8Str &aNetworkName);
+    HRESULT getEnabled(BOOL *aEnabled);
+    HRESULT setEnabled(BOOL aEnabled);
+    HRESULT getProvider(com::Utf8Str &aProvider);
+    HRESULT setProvider(const com::Utf8Str &aProvider);
+    HRESULT getProfile(com::Utf8Str &aProfile);
+    HRESULT setProfile(const com::Utf8Str &aProfile);
+    HRESULT getNetworkId(com::Utf8Str &aNetworkId);
+    HRESULT setNetworkId(const com::Utf8Str &aNetworkId);
+
+    struct Data;
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_CloudNetworkImpl_h */
diff --git a/src/VBox/Main/include/CloudProviderManagerImpl.h b/src/VBox/Main/include/CloudProviderManagerImpl.h
new file mode 100644
index 00000000..67f08c14
--- /dev/null
+++ b/src/VBox/Main/include/CloudProviderManagerImpl.h
@@ -0,0 +1,82 @@
+/* $Id: CloudProviderManagerImpl.h $ */
+/** @file
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2018-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
+ */
+
+#ifndef MAIN_INCLUDED_CloudProviderManagerImpl_h
+#define MAIN_INCLUDED_CloudProviderManagerImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "CloudProviderManagerWrap.h"
+
+class ATL_NO_VTABLE CloudProviderManager
+    : public CloudProviderManagerWrap
+{
+public:
+    CloudProviderManager();
+    virtual ~CloudProviderManager();
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    HRESULT init(VirtualBox *aVirtualBox);
+    void uninit();
+
+#ifdef VBOX_WITH_EXTPACK
+    // Safe helpers, take care of caller and lock themselves.
+    bool i_canRemoveExtPack(IExtPack *aExtPack);
+    void i_addExtPack(IExtPack *aExtPack);
+#endif
+
+private:
+    // wrapped ICloudProviderManager attributes and methods
+    HRESULT getProviders(std::vector<ComPtr<ICloudProvider> > &aProviders);
+    HRESULT getProviderById(const com::Guid &aProviderId,
+                            ComPtr<ICloudProvider> &aProvider);
+    HRESULT getProviderByShortName(const com::Utf8Str &aProviderName,
+                                   ComPtr<ICloudProvider> &aProvider);
+    HRESULT getProviderByName(const com::Utf8Str &aProviderName,
+                              ComPtr<ICloudProvider> &aProvider);
+
+private:
+#ifdef VBOX_WITH_EXTPACK
+    typedef std::map<com::Utf8Str, ComPtr<ICloudProviderManager> > ExtPackNameCloudProviderManagerMap;
+    ExtPackNameCloudProviderManagerMap m_mapCloudProviderManagers;
+
+    typedef std::vector<com::Utf8Str> ExtPackNameVec;
+    ExtPackNameVec m_astrExtPackNames;
+#endif
+
+    typedef std::vector<ComPtr<ICloudProvider> > CloudProviderVec;
+    CloudProviderVec m_apCloudProviders;
+
+    VirtualBox * const m_pVirtualBox;
+};
+
+#endif /* !MAIN_INCLUDED_CloudProviderManagerImpl_h */
+
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/ConsoleImpl.h b/src/VBox/Main/include/ConsoleImpl.h
new file mode 100644
index 00000000..fdea838f
--- /dev/null
+++ b/src/VBox/Main/include/ConsoleImpl.h
@@ -0,0 +1,1222 @@
+/* $Id: ConsoleImpl.h $ */
+/** @file
+ * VBox Console COM Class definition
+ */
+
+/*
+ * Copyright (C) 2005-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
+ */
+
+#ifndef MAIN_INCLUDED_ConsoleImpl_h
+#define MAIN_INCLUDED_ConsoleImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "VirtualBoxBase.h"
+#include "VBox/com/array.h"
+#include "EventImpl.h"
+#include "SecretKeyStore.h"
+#include "ConsoleWrap.h"
+#ifdef VBOX_WITH_RECORDING
+# include "Recording.h"
+#endif
+#ifdef VBOX_WITH_CLOUD_NET
+#include "CloudGateway.h"
+#endif /* VBOX_WITH_CLOUD_NET */
+
+class Guest;
+class Keyboard;
+class Mouse;
+class Display;
+class MachineDebugger;
+class TeleporterStateSrc;
+class OUSBDevice;
+class RemoteUSBDevice;
+class ConsoleSharedFolder;
+class VRDEServerInfo;
+class EmulatedUSB;
+class AudioVRDE;
+#ifdef VBOX_WITH_AUDIO_RECORDING
+class AudioVideoRec;
+#endif
+#ifdef VBOX_WITH_USB_CARDREADER
+class UsbCardReader;
+#endif
+class ConsoleVRDPServer;
+class VMMDev;
+class Progress;
+class BusAssignmentManager;
+COM_STRUCT_OR_CLASS(IEventListener);
+#ifdef VBOX_WITH_EXTPACK
+class ExtPackManager;
+#endif
+class VMMDevMouseInterface;
+class DisplayMouseInterface;
+class VMPowerUpTask;
+class VMPowerDownTask;
+class NvramStore;
+
+#include <iprt/uuid.h>
+#include <iprt/log.h>
+#include <iprt/memsafer.h>
+#include <VBox/RemoteDesktop/VRDE.h>
+#include <VBox/vmm/pdmdrv.h>
+#ifdef VBOX_WITH_GUEST_PROPS
+# include <VBox/HostServices/GuestPropertySvc.h>  /* For the property notification callback */
+#endif
+#ifdef VBOX_WITH_USB
+# include <VBox/vrdpusb.h>
+#endif
+#include <VBox/VBoxCryptoIf.h>
+
+#if    defined(VBOX_WITH_GUEST_PROPS) || defined(VBOX_WITH_SHARED_CLIPBOARD) \
+    || defined(VBOX_WITH_DRAG_AND_DROP)
+# include "HGCM.h" /** @todo It should be possible to register a service
+                    *        extension using a VMMDev callback. */
+#endif
+
+struct VUSBIRHCONFIG;
+typedef struct VUSBIRHCONFIG *PVUSBIRHCONFIG;
+
+#include <list>
+#include <vector>
+
+// defines
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Checks the availability of the underlying VM device driver corresponding
+ *  to the COM interface (IKeyboard, IMouse, IDisplay, etc.). When the driver is
+ *  not available (NULL), sets error info and returns returns E_ACCESSDENIED.
+ *  The translatable error message is defined in null context.
+ *
+ *  Intended to used only within Console children (i.e. Keyboard, Mouse,
+ *  Display, etc.).
+ *
+ *  @param drv  driver pointer to check (compare it with NULL)
+ */
+#define CHECK_CONSOLE_DRV(drv) \
+    do { \
+        if (!!(drv)) {} \
+        else return setError(E_ACCESSDENIED, Console::tr("The console is not powered up (%Rfn)"), __FUNCTION__); \
+    } while (0)
+
+// Console
+///////////////////////////////////////////////////////////////////////////////
+
+class ConsoleMouseInterface
+{
+public:
+    virtual ~ConsoleMouseInterface() { }
+    virtual VMMDevMouseInterface  *i_getVMMDevMouseInterface(){return NULL;}
+    virtual DisplayMouseInterface *i_getDisplayMouseInterface(){return NULL;}
+    virtual void i_onMouseCapabilityChange(BOOL supportsAbsolute,
+                                           BOOL supportsRelative,
+                                           BOOL supportsTouchScreen,
+                                           BOOL supportsTouchPad,
+                                           BOOL needsHostCursor)
+    {
+        RT_NOREF(supportsAbsolute, supportsRelative, supportsTouchScreen, supportsTouchPad, needsHostCursor);
+    }
+};
+
+/** IConsole implementation class */
+class ATL_NO_VTABLE Console :
+    public ConsoleWrap,
+    public ConsoleMouseInterface
+{
+
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(Console)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializers/uninitializers for internal purposes only
+    HRESULT initWithMachine(IMachine *aMachine, IInternalMachineControl *aControl, LockType_T aLockType);
+    void uninit();
+
+
+    // public methods for internal purposes only
+
+    /*
+     *  Note: the following methods do not increase refcount. intended to be
+     *  called only by the VM execution thread.
+     */
+
+    PCVMMR3VTABLE i_getVMMVTable() const RT_NOEXCEPT { return mpVMM; }
+    Guest *i_getGuest() const { return mGuest; }
+    Keyboard *i_getKeyboard() const { return mKeyboard; }
+    Mouse *i_getMouse() const { return mMouse; }
+    Display *i_getDisplay() const { return mDisplay; }
+    MachineDebugger *i_getMachineDebugger() const { return mDebugger; }
+#ifdef VBOX_WITH_AUDIO_VRDE
+    AudioVRDE *i_getAudioVRDE() const { return mAudioVRDE; }
+#endif
+#ifdef VBOX_WITH_RECORDING
+    int i_recordingCreate(void);
+    void i_recordingDestroy(void);
+    int i_recordingEnable(BOOL fEnable, util::AutoWriteLock *pAutoLock);
+    int i_recordingGetSettings(settings::RecordingSettings &recording);
+    int i_recordingStart(util::AutoWriteLock *pAutoLock = NULL);
+    int i_recordingStop(util::AutoWriteLock *pAutoLock = NULL);
+# ifdef VBOX_WITH_AUDIO_RECORDING
+    AudioVideoRec *i_recordingGetAudioDrv(void) const { return mRecording.mAudioRec; }
+# endif
+    RecordingContext *i_recordingGetContext(void) { return &mRecording.mCtx; }
+# ifdef VBOX_WITH_AUDIO_RECORDING
+    HRESULT i_recordingSendAudio(const void *pvData, size_t cbData, uint64_t uDurationMs);
+# endif
+#endif
+
+    const ComPtr<IMachine> &i_machine() const { return mMachine; }
+    const Bstr &i_getId() const { return mstrUuid; }
+
+    bool i_useHostClipboard() { return mfUseHostClipboard; }
+
+    /** Method is called only from ConsoleVRDPServer */
+    IVRDEServer *i_getVRDEServer() const { return mVRDEServer; }
+
+    ConsoleVRDPServer *i_consoleVRDPServer() const { return mConsoleVRDPServer; }
+
+    HRESULT i_updateMachineState(MachineState_T aMachineState);
+    HRESULT i_getNominalState(MachineState_T &aNominalState);
+    Utf8Str i_getAudioAdapterDeviceName(IAudioAdapter *aAudioAdapter);
+
+    // events from IInternalSessionControl
+    HRESULT i_onNetworkAdapterChange(INetworkAdapter *aNetworkAdapter, BOOL changeAdapter);
+    HRESULT i_onAudioAdapterChange(IAudioAdapter *aAudioAdapter);
+    HRESULT i_onHostAudioDeviceChange(IHostAudioDevice *aDevice, BOOL aNew, AudioDeviceState_T aState,
+                                      IVirtualBoxErrorInfo *aErrInfo);
+    HRESULT i_onSerialPortChange(ISerialPort *aSerialPort);
+    HRESULT i_onParallelPortChange(IParallelPort *aParallelPort);
+    HRESULT i_onStorageControllerChange(const com::Guid& aMachineId, const com::Utf8Str& aControllerName);
+    HRESULT i_onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce);
+    HRESULT i_onCPUChange(ULONG aCPU, BOOL aRemove);
+    HRESULT i_onCPUExecutionCapChange(ULONG aExecutionCap);
+    HRESULT i_onClipboardModeChange(ClipboardMode_T aClipboardMode);
+    HRESULT i_onClipboardFileTransferModeChange(bool aEnabled);
+    HRESULT i_onDnDModeChange(DnDMode_T aDnDMode);
+    HRESULT i_onVRDEServerChange(BOOL aRestart);
+    HRESULT i_onRecordingChange(BOOL fEnable);
+    HRESULT i_onUSBControllerChange();
+    HRESULT i_onSharedFolderChange(BOOL aGlobal);
+    HRESULT i_onUSBDeviceAttach(IUSBDevice *aDevice, IVirtualBoxErrorInfo *aError, ULONG aMaskedIfs,
+                                const Utf8Str &aCaptureFilename);
+    HRESULT i_onUSBDeviceDetach(IN_BSTR aId, IVirtualBoxErrorInfo *aError);
+    HRESULT i_onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup);
+    HRESULT i_onStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent);
+    HRESULT i_onExtraDataChange(const Bstr &aMachineId, const Bstr &aKey, const Bstr &aVal);
+    HRESULT i_onGuestDebugControlChange(IGuestDebugControl *aGuestDebugControl);
+
+    HRESULT i_getGuestProperty(const Utf8Str &aName, Utf8Str *aValue, LONG64 *aTimestamp, Utf8Str *aFlags);
+    HRESULT i_setGuestProperty(const Utf8Str &aName, const Utf8Str &aValue, const Utf8Str &aFlags);
+    HRESULT i_deleteGuestProperty(const Utf8Str &aName);
+    HRESULT i_enumerateGuestProperties(const Utf8Str &aPatterns,
+                                       std::vector<Utf8Str> &aNames,
+                                       std::vector<Utf8Str> &aValues,
+                                       std::vector<LONG64>  &aTimestamps,
+                                       std::vector<Utf8Str> &aFlags);
+    HRESULT i_onlineMergeMedium(IMediumAttachment *aMediumAttachment,
+                                ULONG aSourceIdx, ULONG aTargetIdx,
+                                IProgress *aProgress);
+    HRESULT i_reconfigureMediumAttachments(const std::vector<ComPtr<IMediumAttachment> > &aAttachments);
+    HRESULT i_onVMProcessPriorityChange(VMProcPriority_T priority);
+    int i_hgcmLoadService(const char *pszServiceLibrary, const char *pszServiceName);
+    VMMDev *i_getVMMDev() { return m_pVMMDev; }
+
+#ifdef VBOX_WITH_EXTPACK
+    ExtPackManager *i_getExtPackManager();
+#endif
+    EventSource *i_getEventSource() { return mEventSource; }
+#ifdef VBOX_WITH_USB_CARDREADER
+    UsbCardReader *i_getUsbCardReader() { return mUsbCardReader; }
+#endif
+
+    int i_VRDPClientLogon(uint32_t u32ClientId, const char *pszUser, const char *pszPassword, const char *pszDomain);
+    void i_VRDPClientStatusChange(uint32_t u32ClientId, const char *pszStatus);
+    void i_VRDPClientConnect(uint32_t u32ClientId);
+    void i_VRDPClientDisconnect(uint32_t u32ClientId, uint32_t fu32Intercepted);
+    void i_VRDPInterceptAudio(uint32_t u32ClientId);
+    void i_VRDPInterceptUSB(uint32_t u32ClientId, void **ppvIntercept);
+    void i_VRDPInterceptClipboard(uint32_t u32ClientId);
+
+    void i_processRemoteUSBDevices(uint32_t u32ClientId, VRDEUSBDEVICEDESC *pDevList, uint32_t cbDevList, bool fDescExt);
+    void i_reportVmStatistics(ULONG aValidStats, ULONG aCpuUser,
+                              ULONG aCpuKernel, ULONG aCpuIdle,
+                              ULONG aMemTotal, ULONG aMemFree,
+                              ULONG aMemBalloon, ULONG aMemShared,
+                              ULONG aMemCache, ULONG aPageTotal,
+                              ULONG aAllocVMM, ULONG aFreeVMM,
+                              ULONG aBalloonedVMM, ULONG aSharedVMM,
+                              ULONG aVmNetRx, ULONG aVmNetTx)
+    {
+        mControl->ReportVmStatistics(aValidStats, aCpuUser, aCpuKernel, aCpuIdle,
+                                     aMemTotal, aMemFree, aMemBalloon, aMemShared,
+                                     aMemCache, aPageTotal, aAllocVMM, aFreeVMM,
+                                     aBalloonedVMM, aSharedVMM, aVmNetRx, aVmNetTx);
+    }
+    void i_enableVMMStatistics(BOOL aEnable);
+
+    HRESULT i_pause(Reason_T aReason);
+    HRESULT i_resume(Reason_T aReason, AutoWriteLock &alock);
+    HRESULT i_saveState(Reason_T aReason, const ComPtr<IProgress> &aProgress,
+                        const ComPtr<ISnapshot> &aSnapshot,
+                        const Utf8Str &aStateFilePath, bool fPauseVM, bool &fLeftPaused);
+    HRESULT i_cancelSaveState();
+
+    // callback callers (partly; for some events console callbacks are notified
+    // directly from IInternalSessionControl event handlers declared above)
+    void i_onMousePointerShapeChange(bool fVisible, bool fAlpha,
+                                     uint32_t xHot, uint32_t yHot,
+                                     uint32_t width, uint32_t height,
+                                     const uint8_t *pu8Shape,
+                                     uint32_t cbShape);
+    void i_onMouseCapabilityChange(BOOL supportsAbsolute, BOOL supportsRelative,
+                                   BOOL supportsTouchScreen, BOOL supportsTouchPad,
+                                   BOOL needsHostCursor);
+    void i_onStateChange(MachineState_T aMachineState);
+    void i_onAdditionsStateChange();
+    void i_onAdditionsOutdated();
+    void i_onKeyboardLedsChange(bool fNumLock, bool fCapsLock, bool fScrollLock);
+    void i_onUSBDeviceStateChange(IUSBDevice *aDevice, bool aAttached,
+                                  IVirtualBoxErrorInfo *aError);
+    void i_onRuntimeError(BOOL aFatal, IN_BSTR aErrorID, IN_BSTR aMessage);
+    HRESULT i_onShowWindow(BOOL aCheck, BOOL *aCanShow, LONG64 *aWinId);
+    void i_onVRDEServerInfoChange();
+    HRESULT i_sendACPIMonitorHotPlugEvent();
+
+    static const PDMDRVREG DrvStatusReg;
+
+    static HRESULT i_setErrorStatic(HRESULT aResultCode, const char *pcsz, ...);
+    static HRESULT i_setErrorStaticBoth(HRESULT aResultCode, int vrc, const char *pcsz, ...);
+    HRESULT i_setInvalidMachineStateError();
+
+    static const char *i_storageControllerTypeToStr(StorageControllerType_T enmCtrlType);
+    static HRESULT i_storageBusPortDeviceToLun(StorageBus_T enmBus, LONG port, LONG device, unsigned &uLun);
+    // Called from event listener
+    HRESULT i_onNATRedirectRuleChanged(ULONG ulInstance, BOOL aNatRuleRemove,
+                                       NATProtocol_T aProto, IN_BSTR aHostIp, LONG aHostPort, IN_BSTR aGuestIp, LONG aGuestPort);
+    HRESULT i_onNATDnsChanged();
+
+    // Mouse interface
+    VMMDevMouseInterface *i_getVMMDevMouseInterface();
+    DisplayMouseInterface *i_getDisplayMouseInterface();
+
+    EmulatedUSB *i_getEmulatedUSB(void) { return mEmulatedUSB; }
+
+    /**
+     * Sets the disk encryption keys.
+     *
+     * @returns COM status code.
+     * @param   strCfg    The config for the disks.
+     *
+     * @note  One line in the config string contains all required data for one disk.
+     *        The format for one disk is some sort of comma separated value using
+     *        key=value pairs.
+     *        There are two keys defined at the moment:
+     *            - uuid: The uuid of the base image the key is for (with or without)
+     *                    the curly braces.
+     *            - dek: The data encryption key in base64 encoding
+     */
+    HRESULT i_setDiskEncryptionKeys(const Utf8Str &strCfg);
+
+    int i_retainCryptoIf(PCVBOXCRYPTOIF *ppCryptoIf);
+    int i_releaseCryptoIf(PCVBOXCRYPTOIF pCryptoIf);
+    HRESULT i_unloadCryptoIfModule(void);
+
+#ifdef VBOX_WITH_GUEST_PROPS
+    // VMMDev needs:
+    HRESULT                     i_pullGuestProperties(ComSafeArrayOut(BSTR, names), ComSafeArrayOut(BSTR, values),
+                                                      ComSafeArrayOut(LONG64, timestamps), ComSafeArrayOut(BSTR, flags));
+    static DECLCALLBACK(int)    i_doGuestPropNotification(void *pvExtension, uint32_t, void *pvParms, uint32_t cbParms);
+#endif
+
+private:
+
+    // wrapped IConsole properties
+    HRESULT getMachine(ComPtr<IMachine> &aMachine);
+    HRESULT getState(MachineState_T *aState);
+    HRESULT getGuest(ComPtr<IGuest> &aGuest);
+    HRESULT getKeyboard(ComPtr<IKeyboard> &aKeyboard);
+    HRESULT getMouse(ComPtr<IMouse> &aMouse);
+    HRESULT getDisplay(ComPtr<IDisplay> &aDisplay);
+    HRESULT getDebugger(ComPtr<IMachineDebugger> &aDebugger);
+    HRESULT getUSBDevices(std::vector<ComPtr<IUSBDevice> > &aUSBDevices);
+    HRESULT getRemoteUSBDevices(std::vector<ComPtr<IHostUSBDevice> > &aRemoteUSBDevices);
+    HRESULT getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders);
+    HRESULT getVRDEServerInfo(ComPtr<IVRDEServerInfo> &aVRDEServerInfo);
+    HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
+    HRESULT getAttachedPCIDevices(std::vector<ComPtr<IPCIDeviceAttachment> > &aAttachedPCIDevices);
+    HRESULT getUseHostClipboard(BOOL *aUseHostClipboard);
+    HRESULT setUseHostClipboard(BOOL aUseHostClipboard);
+    HRESULT getEmulatedUSB(ComPtr<IEmulatedUSB> &aEmulatedUSB);
+
+    // wrapped IConsole methods
+    HRESULT powerUp(ComPtr<IProgress> &aProgress);
+    HRESULT powerUpPaused(ComPtr<IProgress> &aProgress);
+    HRESULT powerDown(ComPtr<IProgress> &aProgress);
+    HRESULT reset();
+    HRESULT pause();
+    HRESULT resume();
+    HRESULT powerButton();
+    HRESULT sleepButton();
+    HRESULT getPowerButtonHandled(BOOL *aHandled);
+    HRESULT getGuestEnteredACPIMode(BOOL *aEntered);
+    HRESULT getDeviceActivity(const std::vector<DeviceType_T> &aType,
+                              std::vector<DeviceActivity_T> &aActivity);
+    HRESULT attachUSBDevice(const com::Guid &aId, const com::Utf8Str &aCaptureFilename);
+    HRESULT detachUSBDevice(const com::Guid &aId,
+                            ComPtr<IUSBDevice> &aDevice);
+    HRESULT findUSBDeviceByAddress(const com::Utf8Str &aName,
+                                   ComPtr<IUSBDevice> &aDevice);
+    HRESULT findUSBDeviceById(const com::Guid &aId,
+                              ComPtr<IUSBDevice> &aDevice);
+    HRESULT createSharedFolder(const com::Utf8Str &aName,
+                               const com::Utf8Str &aHostPath,
+                               BOOL aWritable,
+                               BOOL aAutomount,
+                               const com::Utf8Str &aAutoMountPoint);
+    HRESULT removeSharedFolder(const com::Utf8Str &aName);
+    HRESULT teleport(const com::Utf8Str &aHostname,
+                     ULONG aTcpport,
+                     const com::Utf8Str &aPassword,
+                     ULONG aMaxDowntime,
+                     ComPtr<IProgress> &aProgress);
+    HRESULT addEncryptionPassword(const com::Utf8Str &aId, const com::Utf8Str &aPassword,
+                                  BOOL aClearOnSuspend);
+    HRESULT addEncryptionPasswords(const std::vector<com::Utf8Str> &aIds, const std::vector<com::Utf8Str> &aPasswords,
+                                   BOOL aClearOnSuspend);
+    HRESULT removeEncryptionPassword(const com::Utf8Str &aId);
+    HRESULT clearAllEncryptionPasswords();
+
+    void notifyNatDnsChange(PUVM pUVM, PCVMMR3VTABLE pVMM, const char *pszDevice, ULONG ulInstanceMax);
+    Utf8Str VRDPServerErrorToMsg(int vrc);
+
+    /**
+     *  Base template for AutoVMCaller and SafeVMPtr. Template arguments
+     *  have the same meaning as arguments of Console::addVMCaller().
+     */
+    template <bool taQuiet = false, bool taAllowNullVM = false>
+    class AutoVMCallerBase
+    {
+    public:
+        AutoVMCallerBase(Console *aThat) : mThat(aThat), mRC(E_FAIL)
+        {
+            Assert(aThat);
+            mRC = aThat->i_addVMCaller(taQuiet, taAllowNullVM);
+        }
+        ~AutoVMCallerBase()
+        {
+            doRelease();
+        }
+        /** Decreases the number of callers before the instance is destroyed. */
+        void releaseCaller()
+        {
+            Assert(SUCCEEDED(mRC));
+            doRelease();
+        }
+        /** Restores the number of callers after by #release(). #hrc() must be
+         *  rechecked to ensure the operation succeeded. */
+        void addYY()
+        {
+            AssertReturnVoid(!SUCCEEDED(mRC));
+            mRC = mThat->i_addVMCaller(taQuiet, taAllowNullVM);
+        }
+        /** Returns the result of Console::addVMCaller() */
+        HRESULT hrc() const { return mRC; }
+        /** Shortcut to SUCCEEDED(hrc()) */
+        bool isOk() const { return SUCCEEDED(mRC); }
+    protected:
+        Console *mThat;
+        void doRelease()
+        {
+            if (SUCCEEDED(mRC))
+            {
+                mThat->i_releaseVMCaller();
+                mRC = E_FAIL;
+            }
+        }
+    private:
+        HRESULT mRC; /* Whether the caller was added. */
+        DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(AutoVMCallerBase);
+    };
+
+#if 0
+    /**
+     *  Helper class that protects sections of code using the mpUVM pointer by
+     *  automatically calling addVMCaller() on construction and
+     *  releaseVMCaller() on destruction. Intended for Console methods dealing
+     *  with mpUVM. The usage pattern is:
+     *  <code>
+     *      AutoVMCaller autoVMCaller(this);
+     *      if (FAILED(autoVMCaller.hrc())) return autoVMCaller.hrc();
+     *      ...
+     *      VMR3ReqCall (mpUVM, ...
+     *  </code>
+     *
+     *  @note Temporarily locks the argument for writing.
+     *
+     *  @sa SafeVMPtr, SafeVMPtrQuiet
+     *  @note Obsolete, use SafeVMPtr
+     */
+    typedef AutoVMCallerBase<false, false> AutoVMCaller;
+#endif
+
+    /**
+     *  Same as AutoVMCaller but doesn't set extended error info on failure.
+     *
+     *  @note Temporarily locks the argument for writing.
+     *  @note Obsolete, use SafeVMPtrQuiet
+     */
+    typedef AutoVMCallerBase<true, false> AutoVMCallerQuiet;
+
+    /**
+     *  Same as AutoVMCaller but allows a null VM pointer (to trigger an error
+     *  instead of assertion).
+     *
+     *  @note Temporarily locks the argument for writing.
+     *  @note Obsolete, use SafeVMPtr
+     */
+    typedef AutoVMCallerBase<false, true> AutoVMCallerWeak;
+
+    /**
+     *  Same as AutoVMCaller but doesn't set extended error info on failure
+     *  and allows a null VM pointer (to trigger an error instead of
+     *  assertion).
+     *
+     *  @note Temporarily locks the argument for writing.
+     *  @note Obsolete, use SafeVMPtrQuiet
+     */
+    typedef AutoVMCallerBase<true, true> AutoVMCallerQuietWeak;
+
+    /**
+     *  Base template for SafeVMPtr and SafeVMPtrQuiet.
+     */
+    template<bool taQuiet = false>
+    class SafeVMPtrBase : public AutoVMCallerBase<taQuiet, true>
+    {
+        typedef AutoVMCallerBase<taQuiet, true> Base;
+    public:
+        SafeVMPtrBase(Console *aThat) : Base(aThat), mRC(E_FAIL), mpUVM(NULL), mpVMM(NULL)
+        {
+            if (Base::isOk())
+                mRC = aThat->i_safeVMPtrRetainer(&mpUVM, &mpVMM, taQuiet);
+        }
+        ~SafeVMPtrBase()
+        {
+            doRelease();
+        }
+        /** Direct PUVM access. */
+        PUVM rawUVM() const { return mpUVM; }
+        /** Direct PCVMMR3VTABLE access. */
+        PCVMMR3VTABLE vtable() const { return mpVMM; }
+        /** Release the handles. */
+        void release()
+        {
+            Assert(SUCCEEDED(mRC));
+            doRelease();
+        }
+
+        /** The combined result of Console::addVMCaller() and Console::safeVMPtrRetainer */
+        HRESULT hrc() const { return Base::isOk() ? mRC : Base::hrc(); }
+        /** Shortcut to SUCCEEDED(hrc()) */
+        bool isOk() const { return SUCCEEDED(mRC) && Base::isOk(); }
+
+    private:
+        void doRelease()
+        {
+            if (SUCCEEDED(mRC))
+            {
+                Base::mThat->i_safeVMPtrReleaser(&mpUVM);
+                mRC = E_FAIL;
+            }
+            Base::doRelease();
+        }
+        HRESULT         mRC; /* Whether the VM ptr was retained. */
+        PUVM            mpUVM;
+        PCVMMR3VTABLE   mpVMM;
+        DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(SafeVMPtrBase);
+    };
+
+public:
+
+    /*
+     *  Helper class that safely manages the Console::mpUVM pointer
+     *  by calling addVMCaller() on construction and releaseVMCaller() on
+     *  destruction. Intended for Console children. The usage pattern is:
+     *  <code>
+     *      Console::SafeVMPtr ptrVM(mParent);
+     *      if (!ptrVM.isOk())
+     *          return ptrVM.hrc();
+     *      ...
+     *      VMR3ReqCall(ptrVM.rawUVM(), ...
+     *      ...
+     *      printf("%p\n", ptrVM.rawUVM());
+     *  </code>
+     *
+     *  @note Temporarily locks the argument for writing.
+     *
+     *  @sa SafeVMPtrQuiet, AutoVMCaller
+     */
+    typedef SafeVMPtrBase<false> SafeVMPtr;
+
+    /**
+     *  A deviation of SafeVMPtr that doesn't set the error info on failure.
+     *  Intended for pieces of code that don't need to return the VM access
+     *  failure to the caller. The usage pattern is:
+     *  <code>
+     *      Console::SafeVMPtrQuiet pVM(mParent);
+     *      if (pVM.hrc())
+     *          VMR3ReqCall(pVM, ...
+     *      return S_OK;
+     *  </code>
+     *
+     *  @note Temporarily locks the argument for writing.
+     *
+     *  @sa SafeVMPtr, AutoVMCaller
+     */
+    typedef SafeVMPtrBase<true> SafeVMPtrQuiet;
+
+    class SharedFolderData
+    {
+    public:
+        SharedFolderData()
+        { }
+
+        SharedFolderData(const Utf8Str &aHostPath,
+                         bool aWritable,
+                         bool aAutoMount,
+                         const Utf8Str &aAutoMountPoint)
+            : m_strHostPath(aHostPath)
+            , m_fWritable(aWritable)
+            , m_fAutoMount(aAutoMount)
+            , m_strAutoMountPoint(aAutoMountPoint)
+        { }
+
+        /** Copy constructor. */
+        SharedFolderData(const SharedFolderData& aThat)
+            : m_strHostPath(aThat.m_strHostPath)
+            , m_fWritable(aThat.m_fWritable)
+            , m_fAutoMount(aThat.m_fAutoMount)
+            , m_strAutoMountPoint(aThat.m_strAutoMountPoint)
+        { }
+
+        /** Copy assignment operator. */
+        SharedFolderData &operator=(SharedFolderData const &a_rThat) RT_NOEXCEPT
+        {
+            m_strHostPath       = a_rThat.m_strHostPath;
+            m_fWritable         = a_rThat.m_fWritable;
+            m_fAutoMount        = a_rThat.m_fAutoMount;
+            m_strAutoMountPoint = a_rThat.m_strAutoMountPoint;
+
+            return *this;
+        }
+
+        Utf8Str m_strHostPath;
+        bool m_fWritable;
+        bool m_fAutoMount;
+        Utf8Str m_strAutoMountPoint;
+    };
+
+    /**
+     * Class for managing emulated USB MSDs.
+     */
+    class USBStorageDevice
+    {
+    public:
+        USBStorageDevice()
+        { }
+        /** The UUID associated with the USB device. */
+        RTUUID   mUuid;
+        /** Port of the storage device. */
+        LONG     iPort;
+    };
+
+    typedef std::map<Utf8Str, ComObjPtr<ConsoleSharedFolder> > SharedFolderMap;
+    typedef std::map<Utf8Str, SharedFolderData> SharedFolderDataMap;
+    typedef std::map<Utf8Str, ComPtr<IMediumAttachment> > MediumAttachmentMap;
+    typedef std::list<USBStorageDevice> USBStorageDeviceList;
+
+    static void i_powerUpThreadTask(VMPowerUpTask *pTask);
+    static void i_powerDownThreadTask(VMPowerDownTask *pTask);
+
+private:
+
+    typedef std::list <ComObjPtr<OUSBDevice> > USBDeviceList;
+    typedef std::list <ComObjPtr<RemoteUSBDevice> > RemoteUSBDeviceList;
+
+    HRESULT i_loadVMM(void) RT_NOEXCEPT;
+    HRESULT i_addVMCaller(bool aQuiet = false, bool aAllowNullVM = false);
+    void    i_releaseVMCaller();
+    HRESULT i_safeVMPtrRetainer(PUVM *a_ppUVM, PCVMMR3VTABLE *a_ppVMM, bool aQuiet) RT_NOEXCEPT;
+    void    i_safeVMPtrReleaser(PUVM *a_ppUVM);
+
+    HRESULT i_consoleInitReleaseLog(const ComPtr<IMachine> aMachine);
+
+    HRESULT i_powerUp(IProgress **aProgress, bool aPaused);
+    HRESULT i_powerDown(IProgress *aProgress = NULL);
+
+/* Note: FreeBSD needs this whether netflt is used or not. */
+#if ((defined(RT_OS_LINUX) && !defined(VBOX_WITH_NETFLT)) || defined(RT_OS_FREEBSD))
+    HRESULT i_attachToTapInterface(INetworkAdapter *networkAdapter);
+    HRESULT i_detachFromTapInterface(INetworkAdapter *networkAdapter);
+#endif
+    HRESULT i_powerDownHostInterfaces();
+
+    HRESULT i_setMachineState(MachineState_T aMachineState, bool aUpdateServer = true);
+    HRESULT i_setMachineStateLocally(MachineState_T aMachineState)
+    {
+        return i_setMachineState(aMachineState, false /* aUpdateServer */);
+    }
+
+    HRESULT i_findSharedFolder(const Utf8Str &strName,
+                               ComObjPtr<ConsoleSharedFolder> &aSharedFolder,
+                               bool aSetError = false);
+
+    HRESULT i_fetchSharedFolders(BOOL aGlobal);
+    bool    i_findOtherSharedFolder(const Utf8Str &straName,
+                                    SharedFolderDataMap::const_iterator &aIt);
+
+    HRESULT i_createSharedFolder(const Utf8Str &strName, const SharedFolderData &aData);
+    HRESULT i_removeSharedFolder(const Utf8Str &strName);
+
+    HRESULT i_suspendBeforeConfigChange(PUVM pUVM, PCVMMR3VTABLE pVMM, AutoWriteLock *pAlock, bool *pfResume);
+    void    i_resumeAfterConfigChange(PUVM pUVM, PCVMMR3VTABLE pVMM);
+
+    static DECLCALLBACK(int) i_configConstructor(PUVM pUVM, PVM pVM, PCVMMR3VTABLE pVMM, void *pvConsole);
+    void InsertConfigString(PCFGMNODE pNode, const char *pcszName, const char *pcszValue);
+    void InsertConfigString(PCFGMNODE pNode, const char *pcszName, const Utf8Str &rStrValue);
+    void InsertConfigString(PCFGMNODE pNode, const char *pcszName, const Bstr &rBstrValue);
+    void InsertConfigStringF(PCFGMNODE pNode, const char *pcszName, const char *pszFormat, ...);
+    void InsertConfigPassword(PCFGMNODE pNode, const char *pcszName, const Utf8Str &rStrValue);
+    void InsertConfigBytes(PCFGMNODE pNode, const char *pcszName, const void *pvBytes, size_t cbBytes);
+    void InsertConfigInteger(PCFGMNODE pNode, const char *pcszName, uint64_t u64Integer);
+    void InsertConfigNode(PCFGMNODE pNode, const char *pcszName, PCFGMNODE *ppChild);
+    void InsertConfigNodeF(PCFGMNODE pNode, PCFGMNODE *ppChild, const char *pszNameFormat, ...) RT_IPRT_FORMAT_ATTR(3, 4);
+    void RemoveConfigValue(PCFGMNODE pNode, const char *pcszName);
+    int  SetBiosDiskInfo(ComPtr<IMachine> pMachine, PCFGMNODE pCfg, PCFGMNODE pBiosCfg,
+                         Bstr controllerName, const char * const s_apszBiosConfig[4]);
+    void i_configAudioDriver(IVirtualBox *pVirtualBox, IMachine *pMachine, PCFGMNODE pLUN, const char *pszDriverName,
+                             bool fAudioEnabledIn, bool fAudioEnabledOut);
+    int i_configConstructorInner(PUVM pUVM, PVM pVM, PCVMMR3VTABLE pVMM, AutoWriteLock *pAlock);
+    int i_configCfgmOverlay(PCFGMNODE pRoot, IVirtualBox *pVirtualBox, IMachine *pMachine);
+    int i_configDumpAPISettingsTweaks(IVirtualBox *pVirtualBox, IMachine *pMachine);
+
+    int i_configGraphicsController(PCFGMNODE pDevices,
+                                   const GraphicsControllerType_T graphicsController,
+                                   BusAssignmentManager *pBusMgr,
+                                   const ComPtr<IMachine> &ptrMachine,
+                                   const ComPtr<IGraphicsAdapter> &ptrGraphicsAdapter,
+                                   const ComPtr<IBIOSSettings> &ptrBiosSettings,
+                                   bool fHMEnabled);
+    int i_checkMediumLocation(IMedium *pMedium, bool *pfUseHostIOCache);
+    int i_unmountMediumFromGuest(PUVM pUVM, PCVMMR3VTABLE pVMM, StorageBus_T enmBus, DeviceType_T enmDevType,
+                                 const char *pcszDevice, unsigned uInstance, unsigned uLUN,
+                                 bool fForceUnmount) RT_NOEXCEPT;
+    int i_removeMediumDriverFromVm(PCFGMNODE pCtlInst,
+                                   const char *pcszDevice,
+                                   unsigned uInstance,
+                                   unsigned uLUN,
+                                   StorageBus_T enmBus,
+                                   bool fAttachDetach,
+                                   bool fHotplug,
+                                   bool fForceUnmount,
+                                   PUVM pUVM,
+                                   PCVMMR3VTABLE pVMM,
+                                   DeviceType_T enmDevType,
+                                   PCFGMNODE *ppLunL0);
+    int i_configMediumAttachment(const char *pcszDevice,
+                                 unsigned uInstance,
+                                 StorageBus_T enmBus,
+                                 bool fUseHostIOCache,
+                                 bool fBuiltinIoCache,
+                                 bool fInsertDiskIntegrityDrv,
+                                 bool fSetupMerge,
+                                 unsigned uMergeSource,
+                                 unsigned uMergeTarget,
+                                 IMediumAttachment *pMediumAtt,
+                                 MachineState_T aMachineState,
+                                 HRESULT *phrc,
+                                 bool fAttachDetach,
+                                 bool fForceUnmount,
+                                 bool fHotplug,
+                                 PUVM pUVM,
+                                 PCVMMR3VTABLE pVMM,
+                                 DeviceType_T *paLedDevType,
+                                 PCFGMNODE *ppLunL0);
+    int i_configMedium(PCFGMNODE pLunL0,
+                       bool fPassthrough,
+                       DeviceType_T enmType,
+                       bool fUseHostIOCache,
+                       bool fBuiltinIoCache,
+                       bool fInsertDiskIntegrityDrv,
+                       bool fSetupMerge,
+                       unsigned uMergeSource,
+                       unsigned uMergeTarget,
+                       const char *pcszBwGroup,
+                       bool fDiscard,
+                       bool fNonRotational,
+                       ComPtr<IMedium> ptrMedium,
+                       MachineState_T aMachineState,
+                       HRESULT *phrc);
+    int i_configMediumProperties(PCFGMNODE pCur, IMedium *pMedium, bool *pfHostIP, bool *pfEncrypted);
+    static DECLCALLBACK(int) i_reconfigureMediumAttachment(Console *pThis,
+                                                           PUVM pUVM,
+                                                           PCVMMR3VTABLE pVMM,
+                                                           const char *pcszDevice,
+                                                           unsigned uInstance,
+                                                           StorageBus_T enmBus,
+                                                           bool fUseHostIOCache,
+                                                           bool fBuiltinIoCache,
+                                                           bool fInsertDiskIntegrityDrv,
+                                                           bool fSetupMerge,
+                                                           unsigned uMergeSource,
+                                                           unsigned uMergeTarget,
+                                                           IMediumAttachment *aMediumAtt,
+                                                           MachineState_T aMachineState,
+                                                           HRESULT *phrc);
+    static DECLCALLBACK(int) i_changeRemovableMedium(Console *pThis,
+                                                     PUVM pUVM,
+                                                     PCVMMR3VTABLE pVMM,
+                                                     const char *pcszDevice,
+                                                     unsigned uInstance,
+                                                     StorageBus_T enmBus,
+                                                     bool fUseHostIOCache,
+                                                     IMediumAttachment *aMediumAtt,
+                                                     bool fForce);
+
+    HRESULT i_attachRawPCIDevices(PUVM pUVM, BusAssignmentManager *BusMgr, PCFGMNODE pDevices);
+    struct LEDSET;
+    typedef struct LEDSET *PLEDSET;
+    PPDMLED volatile *i_getLedSet(uint32_t iLedSet);
+    void i_setLedType(DeviceType_T *penmSubTypeEntry, DeviceType_T enmNewType);
+    HRESULT i_refreshLedTypeArrays(AutoReadLock *pReadLock);
+    uint32_t i_allocateDriverLeds(uint32_t cLeds, uint32_t fTypes, DeviceType_T **ppSubTypes);
+    void i_attachStatusDriver(PCFGMNODE pCtlInst, DeviceType_T enmType, uint32_t cLeds = 1);
+    void i_attachStatusDriver(PCFGMNODE pCtlInst, uint32_t fTypes, uint32_t cLeds, DeviceType_T **ppaSubTypes,
+                              Console::MediumAttachmentMap *pmapMediumAttachments,
+                              const char *pcszDevice, unsigned uInstance);
+
+    int i_configNetwork(const char *pszDevice, unsigned uInstance, unsigned uLun, INetworkAdapter *aNetworkAdapter,
+                        PCFGMNODE pCfg,  PCFGMNODE pLunL0, PCFGMNODE pInst, bool fAttachDetach, bool fIgnoreConnectFailure,
+                        PUVM pUVM, PCVMMR3VTABLE pVMM);
+    int i_configProxy(ComPtr<IVirtualBox> virtualBox, PCFGMNODE pCfg, const char *pcszPrefix, const com::Utf8Str &strIpAddr);
+
+    int i_configSerialPort(PCFGMNODE pInst, PortMode_T ePortMode, const char *pszPath, bool fServer);
+    static DECLCALLBACK(void) i_vmstateChangeCallback(PUVM pUVM, PCVMMR3VTABLE pVMM, VMSTATE enmState,
+                                                      VMSTATE enmOldState, void *pvUser);
+    static DECLCALLBACK(int) i_unplugCpu(Console *pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, VMCPUID idCpu);
+    static DECLCALLBACK(int) i_plugCpu(Console *pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, VMCPUID idCpu);
+    HRESULT i_doMediumChange(IMediumAttachment *aMediumAttachment, bool fForce, PUVM pUVM, PCVMMR3VTABLE pVMM);
+    HRESULT i_doCPURemove(ULONG aCpu, PUVM pUVM, PCVMMR3VTABLE pVMM);
+    HRESULT i_doCPUAdd(ULONG aCpu, PUVM pUVM, PCVMMR3VTABLE pVMM);
+
+    HRESULT i_doNetworkAdapterChange(PUVM pUVM, PCVMMR3VTABLE pVMM, const char *pszDevice, unsigned uInstance,
+                                     unsigned uLun, INetworkAdapter *aNetworkAdapter);
+    static DECLCALLBACK(int) i_changeNetworkAttachment(Console *pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, const char *pszDevice,
+                                                       unsigned uInstance, unsigned uLun, INetworkAdapter *aNetworkAdapter);
+    static DECLCALLBACK(int) i_changeSerialPortAttachment(Console *pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, ISerialPort *pSerialPort);
+
+    int i_changeClipboardMode(ClipboardMode_T aClipboardMode);
+    int i_changeClipboardFileTransferMode(bool aEnabled);
+    int i_changeDnDMode(DnDMode_T aDnDMode);
+
+#ifdef VBOX_WITH_USB
+    HRESULT i_attachUSBDevice(IUSBDevice *aHostDevice, ULONG aMaskedIfs, const Utf8Str &aCaptureFilename);
+    HRESULT i_detachUSBDevice(const ComObjPtr<OUSBDevice> &aHostDevice);
+
+    static DECLCALLBACK(int) i_usbAttachCallback(Console *that, PUVM pUVM, PCVMMR3VTABLE pVMM, IUSBDevice *aHostDevice,
+                                                 PCRTUUID aUuid, const char *aBackend, const char *aAddress,
+                                                 PCFGMNODE pRemoteCfg, USBConnectionSpeed_T enmSpeed, ULONG aMaskedIfs,
+                                                 const char *pszCaptureFilename);
+    static DECLCALLBACK(int) i_usbDetachCallback(Console *that, PUVM pUVM, PCVMMR3VTABLE pVMM, PCRTUUID aUuid);
+    static DECLCALLBACK(PREMOTEUSBCALLBACK) i_usbQueryRemoteUsbBackend(void *pvUser, PCRTUUID pUuid, uint32_t idClient);
+
+    /** Interface for the VRDP USB proxy backend to query for a device remote callback table. */
+    REMOTEUSBIF mRemoteUsbIf;
+#endif
+
+    static DECLCALLBACK(int) i_attachStorageDevice(Console *pThis,
+                                                   PUVM pUVM,
+                                                   PCVMMR3VTABLE pVMM,
+                                                   const char *pcszDevice,
+                                                   unsigned uInstance,
+                                                   StorageBus_T enmBus,
+                                                   bool fUseHostIOCache,
+                                                   IMediumAttachment *aMediumAtt,
+                                                   bool fSilent);
+    static DECLCALLBACK(int) i_detachStorageDevice(Console *pThis,
+                                                   PUVM pUVM,
+                                                   PCVMMR3VTABLE pVMM,
+                                                   const char *pcszDevice,
+                                                   unsigned uInstance,
+                                                   StorageBus_T enmBus,
+                                                   IMediumAttachment *aMediumAtt,
+                                                   bool fSilent);
+    HRESULT i_doStorageDeviceAttach(IMediumAttachment *aMediumAttachment, PUVM pUVM, PCVMMR3VTABLE pVMM, bool fSilent);
+    HRESULT i_doStorageDeviceDetach(IMediumAttachment *aMediumAttachment, PUVM pUVM, PCVMMR3VTABLE pVMM, bool fSilent);
+
+    static DECLCALLBACK(int)    i_stateProgressCallback(PUVM pUVM, unsigned uPercent, void *pvUser);
+
+    static DECLCALLBACK(void)   i_genericVMSetErrorCallback(PUVM pUVM, void *pvUser, int vrc, RT_SRC_POS_DECL,
+                                                            const char *pszErrorFmt, va_list va);
+
+    void                        i_atVMRuntimeErrorCallbackF(uint32_t fFatal, const char *pszErrorId, const char *pszFormat, ...);
+    static DECLCALLBACK(void)   i_atVMRuntimeErrorCallback(PUVM pUVM, void *pvUser, uint32_t fFatal,
+                                                           const char *pszErrorId, const char *pszFormat, va_list va);
+
+    HRESULT                     i_captureUSBDevices(PUVM pUVM);
+    void                        i_detachAllUSBDevices(bool aDone);
+
+
+    static DECLCALLBACK(int)    i_vmm2User_SaveState(PCVMM2USERMETHODS pThis, PUVM pUVM);
+    static DECLCALLBACK(void)   i_vmm2User_NotifyEmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu);
+    static DECLCALLBACK(void)   i_vmm2User_NotifyEmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu);
+    static DECLCALLBACK(void)   i_vmm2User_NotifyPdmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM);
+    static DECLCALLBACK(void)   i_vmm2User_NotifyPdmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM);
+    static DECLCALLBACK(void)   i_vmm2User_NotifyResetTurnedIntoPowerOff(PCVMM2USERMETHODS pThis, PUVM pUVM);
+    static DECLCALLBACK(void *) i_vmm2User_QueryGenericObject(PCVMM2USERMETHODS pThis, PUVM pUVM, PCRTUUID pUuid);
+
+    static DECLCALLBACK(void *) i_drvStatus_QueryInterface(PPDMIBASE pInterface, const char *pszIID);
+    static DECLCALLBACK(void)   i_drvStatus_UnitChanged(PPDMILEDCONNECTORS pInterface, unsigned iLUN);
+    static DECLCALLBACK(int)    i_drvStatus_MediumEjected(PPDMIMEDIANOTIFY pInterface, unsigned iLUN);
+    static DECLCALLBACK(void)   i_drvStatus_Destruct(PPDMDRVINS pDrvIns);
+    static DECLCALLBACK(int)    i_drvStatus_Construct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
+
+    static DECLCALLBACK(int)    i_pdmIfSecKey_KeyRetain(PPDMISECKEY pInterface, const char *pszId, const uint8_t **ppbKey,
+                                                        size_t *pcbKey);
+    static DECLCALLBACK(int)    i_pdmIfSecKey_KeyRelease(PPDMISECKEY pInterface, const char *pszId);
+    static DECLCALLBACK(int)    i_pdmIfSecKey_PasswordRetain(PPDMISECKEY pInterface, const char *pszId, const char **ppszPassword);
+    static DECLCALLBACK(int)    i_pdmIfSecKey_PasswordRelease(PPDMISECKEY pInterface, const char *pszId);
+
+    static DECLCALLBACK(int)    i_pdmIfSecKeyHlp_KeyMissingNotify(PPDMISECKEYHLP pInterface);
+
+    int mcAudioRefs;
+    volatile uint32_t mcVRDPClients;
+    uint32_t mu32SingleRDPClientId; /* The id of a connected client in the single connection mode. */
+    volatile  bool mcGuestCredentialsProvided;
+
+    static const char *sSSMConsoleUnit;
+
+    HRESULT i_loadDataFromSavedState();
+    int i_loadStateFileExecInternal(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, uint32_t u32Version);
+
+    static DECLCALLBACK(int)    i_saveStateFileExec(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser);
+    static DECLCALLBACK(int)    i_loadStateFileExec(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser,
+                                                    uint32_t uVersion, uint32_t uPass);
+
+#ifdef VBOX_WITH_GUEST_PROPS
+    HRESULT                     i_doEnumerateGuestProperties(const Utf8Str &aPatterns,
+                                                             std::vector<Utf8Str> &aNames,
+                                                             std::vector<Utf8Str> &aValues,
+                                                             std::vector<LONG64>  &aTimestamps,
+                                                             std::vector<Utf8Str> &aFlags);
+
+    void i_guestPropertiesHandleVMReset(void);
+    bool i_guestPropertiesVRDPEnabled(void);
+    void i_guestPropertiesVRDPUpdateLogon(uint32_t u32ClientId, const char *pszUser, const char *pszDomain);
+    void i_guestPropertiesVRDPUpdateActiveClient(uint32_t u32ClientId);
+    void i_guestPropertiesVRDPUpdateClientAttach(uint32_t u32ClientId, bool fAttached);
+    void i_guestPropertiesVRDPUpdateNameChange(uint32_t u32ClientId, const char *pszName);
+    void i_guestPropertiesVRDPUpdateIPAddrChange(uint32_t u32ClientId, const char *pszIPAddr);
+    void i_guestPropertiesVRDPUpdateLocationChange(uint32_t u32ClientId, const char *pszLocation);
+    void i_guestPropertiesVRDPUpdateOtherInfoChange(uint32_t u32ClientId, const char *pszOtherInfo);
+    void i_guestPropertiesVRDPUpdateDisconnect(uint32_t u32ClientId);
+#endif
+
+    /** @name Disk encryption support
+     * @{ */
+    HRESULT i_consoleParseDiskEncryption(const char *psz, const char **ppszEnd);
+    HRESULT i_configureEncryptionForDisk(const Utf8Str &strId, unsigned *pcDisksConfigured);
+    HRESULT i_clearDiskEncryptionKeysOnAllAttachmentsWithKeyId(const Utf8Str &strId);
+    HRESULT i_initSecretKeyIfOnAllAttachments(void);
+    int i_consoleParseKeyValue(const char *psz, const char **ppszEnd,
+                               char **ppszKey, char **ppszVal);
+    void i_removeSecretKeysOnSuspend();
+    /** @} */
+
+    /** @name Teleporter support
+     * @{ */
+    static DECLCALLBACK(int)    i_teleporterSrcThreadWrapper(RTTHREAD hThreadSelf, void *pvUser);
+    HRESULT                     i_teleporterSrc(TeleporterStateSrc *pState);
+    HRESULT                     i_teleporterSrcReadACK(TeleporterStateSrc *pState, const char *pszWhich, const char *pszNAckMsg = NULL);
+    HRESULT                     i_teleporterSrcSubmitCommand(TeleporterStateSrc *pState, const char *pszCommand, bool fWaitForAck = true);
+    HRESULT                     i_teleporterTrg(PUVM pUVM, PCVMMR3VTABLE pVMM, IMachine *pMachine, Utf8Str *pErrorMsg,
+                                                bool fStartPaused, Progress *pProgress, bool *pfPowerOffOnFailure);
+    static DECLCALLBACK(int)    i_teleporterTrgServeConnection(RTSOCKET Sock, void *pvUser);
+    /** @} */
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+    /** @name Encrypted log interface
+     * @{ */
+    static DECLCALLBACK(int)    i_logEncryptedOpen(PCRTLOGOUTPUTIF pIf, void *pvUser, const char *pszFilename, uint32_t fFlags);
+    static DECLCALLBACK(int)    i_logEncryptedClose(PCRTLOGOUTPUTIF pIf, void *pvUser);
+    static DECLCALLBACK(int)    i_logEncryptedDelete(PCRTLOGOUTPUTIF pIf, void *pvUser, const char *pszFilename);
+    static DECLCALLBACK(int)    i_logEncryptedRename(PCRTLOGOUTPUTIF pIf, void *pvUser, const char *pszFilenameOld,
+                                                     const char *pszFilenameNew, uint32_t fFlags);
+    static DECLCALLBACK(int)    i_logEncryptedQuerySize(PCRTLOGOUTPUTIF pIf, void *pvUser, uint64_t *pcbSize);
+    static DECLCALLBACK(int)    i_logEncryptedWrite(PCRTLOGOUTPUTIF pIf, void *pvUser, const void *pvBuf,
+                                                    size_t cbWrite, size_t *pcbWritten);
+    static DECLCALLBACK(int)    i_logEncryptedFlush(PCRTLOGOUTPUTIF pIf, void *pvUser);
+    /** @} */
+#endif
+
+    bool mSavedStateDataLoaded : 1;
+
+    const ComPtr<IMachine> mMachine;
+    const ComPtr<IInternalMachineControl> mControl;
+
+    const ComPtr<IVRDEServer> mVRDEServer;
+
+    ConsoleVRDPServer * const mConsoleVRDPServer;
+    bool mfVRDEChangeInProcess;
+    bool mfVRDEChangePending;
+    const ComObjPtr<Guest> mGuest;
+    const ComObjPtr<Keyboard> mKeyboard;
+    const ComObjPtr<Mouse> mMouse;
+    const ComObjPtr<Display> mDisplay;
+    const ComObjPtr<MachineDebugger> mDebugger;
+    const ComObjPtr<VRDEServerInfo> mVRDEServerInfo;
+    /** This can safely be used without holding any locks.
+     * An AutoCaller suffices to prevent it being destroy while in use and
+     * internally there is a lock providing the necessary serialization. */
+    const ComObjPtr<EventSource> mEventSource;
+#ifdef VBOX_WITH_EXTPACK
+    const ComObjPtr<ExtPackManager> mptrExtPackManager;
+#endif
+    const ComObjPtr<EmulatedUSB> mEmulatedUSB;
+    const ComObjPtr<NvramStore> mptrNvramStore;
+
+    USBDeviceList mUSBDevices;
+    RemoteUSBDeviceList mRemoteUSBDevices;
+
+    SharedFolderDataMap m_mapGlobalSharedFolders;
+    SharedFolderDataMap m_mapMachineSharedFolders;
+    SharedFolderMap m_mapSharedFolders;             // the console instances
+
+    /** VMM loader handle. */
+    RTLDRMOD mhModVMM;
+    /** The VMM vtable. */
+    PCVMMR3VTABLE mpVMM;
+    /** The user mode VM handle. */
+    PUVM mpUVM;
+    /** Holds the number of "readonly" mpUVM callers (users). */
+    uint32_t mVMCallers;
+    /** Semaphore posted when the number of mpUVM callers drops to zero. */
+    RTSEMEVENT mVMZeroCallersSem;
+    /** true when Console has entered the mpUVM destruction phase. */
+    bool mVMDestroying : 1;
+    /** true when power down is initiated by vmstateChangeCallback (EMT). */
+    bool mVMPoweredOff : 1;
+    /** true when vmstateChangeCallback shouldn't initiate a power down.  */
+    bool mVMIsAlreadyPoweringOff : 1;
+    /** true if we already showed the snapshot folder size warning. */
+    bool mfSnapshotFolderSizeWarningShown : 1;
+    /** true if we already showed the snapshot folder ext4/xfs bug warning. */
+    bool mfSnapshotFolderExt4WarningShown : 1;
+    /** true if we already listed the disk type of the snapshot folder. */
+    bool mfSnapshotFolderDiskTypeShown : 1;
+    /** true if a USB controller is available (i.e. USB devices can be attached). */
+    bool mfVMHasUsbController : 1;
+    /** Shadow of the VBoxInternal2/TurnResetIntoPowerOff extra data setting.
+     * This is initialized by Console::i_configConstructorInner(). */
+    bool mfTurnResetIntoPowerOff : 1;
+    /** true if the VM power off was caused by reset. */
+    bool mfPowerOffCausedByReset : 1;
+
+    /** Pointer to the VMM -> User (that's us) callbacks. */
+    struct MYVMM2USERMETHODS : public VMM2USERMETHODS
+    {
+        Console *pConsole;
+        /** The in-progress snapshot. */
+        ISnapshot *pISnapshot;
+    } *mpVmm2UserMethods;
+
+    /** The current network attachment type in the VM.
+     * This doesn't have to match the network attachment type maintained in the
+     * NetworkAdapter. This is needed to change the network attachment
+     * dynamically.
+     */
+    typedef std::vector<NetworkAttachmentType_T> NetworkAttachmentTypeVector;
+    NetworkAttachmentTypeVector meAttachmentType;
+
+    VMMDev *                    m_pVMMDev;
+    AudioVRDE * const           mAudioVRDE;
+#ifdef VBOX_WITH_USB_CARDREADER
+    UsbCardReader * const       mUsbCardReader;
+#endif
+    BusAssignmentManager*       mBusMgr;
+
+    /** @name LEDs and their management
+     * @{ */
+    /** Read/write lock separating LED allocations and per-type data construction
+     * (write) from queries (read). */
+    RWLockHandle            mLedLock;
+    /** LED configuration generation.  This is increased whenever a new set is
+     *  allocated or a sub-device type changes. */
+    uint32_t                muLedGen;
+    /** The LED configuration generation which maLedTypes was constructed for. */
+    uint32_t                muLedTypeGen;
+    /** Number of LED sets in use in maLedSets. */
+    uint32_t                mcLedSets;
+    /** LED sets. */
+    struct LEDSET
+    {
+        /** Bitmask of possible DeviceType_T values (e.g. RT_BIT_32(DeviceType_Network)). */
+        uint32_t            fTypes;
+        /** Number of LEDs.   */
+        uint32_t            cLeds;
+        /** Array of PDMLED pointers.  The pointers in the array can be changed at any
+         *  time by Console::i_drvStatus_UnitChanged(). */
+        PPDMLED volatile   *papLeds;
+        /** Optionally, device types for each individual LED. Runs parallel to papLeds. */
+        DeviceType_T       *paSubTypes;
+    } maLedSets[32];
+    /** LEDs data organized by DeviceType_T.
+     * This is reconstructed by Console::i_refreshLedTypeArrays() when
+     * Console::getDeviceActivity is called and mLedTypeGen doesn't match
+     * muLedGen. */
+    struct
+    {
+        /** Number of possibly valid entries in pappLeds. */
+        uint32_t            cLeds;
+        /** Number of allocated entries. */
+        uint32_t            cAllocated;
+        /** Array of pointer to LEDSET::papLed entries.
+         * The indirection is due to Console::i_drvStatus_UnitChanged() only knowing
+         * about the LEDSET::papLeds. */
+        PPDMLED volatile  **pappLeds;
+    } maLedTypes[DeviceType_End];
+    /** @} */
+
+    MediumAttachmentMap mapMediumAttachments;
+
+    /** List of attached USB storage devices. */
+    USBStorageDeviceList mUSBStorageDevices;
+
+    /** Store for secret keys. */
+    SecretKeyStore * const m_pKeyStore;
+    /** Number of disks configured for encryption. */
+    unsigned               m_cDisksEncrypted;
+    /** Number of disks which have the key in the map. */
+    unsigned               m_cDisksPwProvided;
+
+    /** Current active port modes of the supported serial ports. */
+    PortMode_T             m_aeSerialPortMode[4];
+
+    /** Pointer to the key consumer -> provider (that's us) callbacks. */
+    struct MYPDMISECKEY : public PDMISECKEY
+    {
+        Console *pConsole;
+    } *mpIfSecKey;
+
+    /** Pointer to the key helpers -> provider (that's us) callbacks. */
+    struct MYPDMISECKEYHLP : public PDMISECKEYHLP
+    {
+        Console *pConsole;
+    } *mpIfSecKeyHlp;
+
+/* Note: FreeBSD needs this whether netflt is used or not. */
+#if ((defined(RT_OS_LINUX) && !defined(VBOX_WITH_NETFLT)) || defined(RT_OS_FREEBSD))
+    Utf8Str      maTAPDeviceName[8];
+    RTFILE       maTapFD[8];
+#endif
+
+    bool mVMStateChangeCallbackDisabled;
+
+    bool mfUseHostClipboard;
+
+    /** Local machine state value. */
+    MachineState_T mMachineState;
+
+    /** Machine uuid string. */
+    Bstr mstrUuid;
+
+    /** @name Members related to the cryptographic support interface.
+     * @{ */
+    /** The loaded module handle if loaded. */
+    RTLDRMOD                            mhLdrModCrypto;
+    /** Reference counter tracking how many users of the cryptographic support
+     * are there currently. */
+    volatile uint32_t                   mcRefsCrypto;
+    /** Pointer to the cryptographic support interface. */
+    PCVBOXCRYPTOIF                      mpCryptoIf;
+    /** @} */
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+    /** Flag whether the log is encrypted. */
+    bool                                m_fEncryptedLog;
+    /** The file handle of the encrypted log. */
+    RTVFSFILE                           m_hVfsFileLog;
+    /** The logging output interface for encrypted logs. */
+    RTLOGOUTPUTIF                       m_LogOutputIf;
+    /** The log file key ID. */
+    Utf8Str                             m_strLogKeyId;
+    /** The log file key store. */
+    Utf8Str                             m_strLogKeyStore;
+#endif
+
+#ifdef VBOX_WITH_DRAG_AND_DROP
+    HGCMSVCEXTHANDLE m_hHgcmSvcExtDragAndDrop;
+#endif
+
+    /** Pointer to the progress object of a live cancelable task.
+     *
+     * This is currently only used by Console::Teleport(), but is intended to later
+     * be used by the live snapshot code path as well.  Actions like
+     * Console::PowerDown, which automatically cancels out the running snapshot /
+     * teleportation operation, will cancel the teleportation / live snapshot
+     * operation before starting. */
+    ComPtr<IProgress> mptrCancelableProgress;
+
+    ComPtr<IEventListener> mVmListener;
+
+#ifdef VBOX_WITH_RECORDING
+    struct Recording
+    {
+        Recording()
+# ifdef VBOX_WITH_AUDIO_RECORDING
+            : mAudioRec(NULL)
+# endif
+        { }
+
+        /** The recording context. */
+        RecordingContext      mCtx;
+# ifdef VBOX_WITH_AUDIO_RECORDING
+        /** Pointer to capturing audio backend. */
+        AudioVideoRec * const mAudioRec;
+# endif
+    } mRecording;
+#endif /* VBOX_WITH_RECORDING */
+
+#ifdef VBOX_WITH_CLOUD_NET
+    GatewayInfo mGateway;
+#endif /* VBOX_WITH_CLOUD_NET */
+
+    friend class VMTask;
+    friend class ConsoleVRDPServer;
+};
+
+#endif /* !MAIN_INCLUDED_ConsoleImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/ConsoleSharedFolderImpl.h b/src/VBox/Main/include/ConsoleSharedFolderImpl.h
new file mode 100644
index 00000000..1ad45a38
--- /dev/null
+++ b/src/VBox/Main/include/ConsoleSharedFolderImpl.h
@@ -0,0 +1,124 @@
+/* $Id: ConsoleSharedFolderImpl.h $ */
+/** @file
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2022 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
+ */
+
+#ifndef MAIN_INCLUDED_ConsoleSharedFolderImpl_h
+#define MAIN_INCLUDED_ConsoleSharedFolderImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "SharedFolderWrap.h"
+#include <VBox/shflsvc.h>
+
+class Console;
+
+class ATL_NO_VTABLE ConsoleSharedFolder :
+    public SharedFolderWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS (ConsoleSharedFolder)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+//    HRESULT init(Machine *aMachine, const com::Utf8Str &aName, const com::Utf8Str &aHostPath,
+//                 bool aWritable, bool aAutoMount, const com::Utf8Str &aAutoMountPoint, bool fFailOnError);
+//    HRESULT initCopy(Machine *aMachine, SharedFolder *aThat);
+    HRESULT init(Console *aConsole, const com::Utf8Str &aName, const com::Utf8Str &aHostPath,
+                 bool aWritable, bool aAutoMount, const com::Utf8Str &aAutoMountPoint, bool fFailOnError);
+//     HRESULT init(VirtualBox *aVirtualBox, const Utf8Str &aName, const Utf8Str &aHostPath,
+//                  bool aWritable, const com::Utf8Str &aAutoMountPoint, bool aAutoMount, bool fFailOnError);
+    void uninit();
+
+    // public methods for internal purposes only
+    // (ensure there is a caller and a read lock before calling them!)
+
+    /**
+     * Public internal method. Returns the shared folder's name. Needs caller! Locking not necessary.
+     * @return
+     */
+    const Utf8Str &i_getName() const;
+
+    /**
+     * Public internal method. Returns the shared folder's host path. Needs caller! Locking not necessary.
+     * @return
+     */
+    const Utf8Str &i_getHostPath() const;
+
+    /**
+     * Public internal method. Returns true if the shared folder is writable. Needs caller and locking!
+     * @return
+     */
+    bool i_isWritable() const;
+
+    /**
+     * Public internal method. Returns true if the shared folder is auto-mounted. Needs caller and locking!
+     * @return
+     */
+    bool i_isAutoMounted() const;
+
+    /**
+     * Public internal method for getting the auto mount point.
+     */
+    const Utf8Str &i_getAutoMountPoint() const;
+
+protected:
+
+    HRESULT i_protectedInit(VirtualBoxBase *aParent,
+                            const Utf8Str &aName,
+                            const Utf8Str &aHostPath,
+                            bool aWritable,
+                            bool aAutoMount,
+                            const com::Utf8Str &aAutoMountPoint,
+                            bool fFailOnError);
+private:
+
+    // wrapped ISharedFolder properies.
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT getHostPath(com::Utf8Str &aHostPath);
+    HRESULT getAccessible(BOOL *aAccessible);
+    HRESULT getWritable(BOOL *aWritable);
+    HRESULT setWritable(BOOL aWritable);
+    HRESULT getAutoMount(BOOL *aAutoMount);
+    HRESULT setAutoMount(BOOL aAutoMount);
+    HRESULT getAutoMountPoint(com::Utf8Str &aAutoMountPoint);
+    HRESULT setAutoMountPoint(com::Utf8Str const &aAutoMountPoint);
+    HRESULT getLastAccessError(com::Utf8Str &aLastAccessError);
+
+    VirtualBoxBase * const mParent;
+
+    /* weak parents (only one of them is not null) */
+    Console        * const mConsole;
+
+    struct Data;            // opaque data struct, defined in ConsoleSharedFolderImpl.cpp
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_ConsoleSharedFolderImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/ConsoleVRDPServer.h b/src/VBox/Main/include/ConsoleVRDPServer.h
new file mode 100644
index 00000000..dc08c270
--- /dev/null
+++ b/src/VBox/Main/include/ConsoleVRDPServer.h
@@ -0,0 +1,428 @@
+/* $Id: ConsoleVRDPServer.h $ */
+/** @file
+ * VBox Console VRDE Server Helper class and implementation of IVRDEServerInfo
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_ConsoleVRDPServer_h
+#define MAIN_INCLUDED_ConsoleVRDPServer_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "VRDEServerInfoWrap.h"
+#include "RemoteUSBBackend.h"
+#include "HGCM.h"
+
+#include "AuthLibrary.h"
+
+#include <VBox/RemoteDesktop/VRDEImage.h>
+#include <VBox/RemoteDesktop/VRDEMousePtr.h>
+#include <VBox/RemoteDesktop/VRDESCard.h>
+#include <VBox/RemoteDesktop/VRDETSMF.h>
+#define VRDE_VIDEOIN_WITH_VRDEINTERFACE /* Get the VRDE interface definitions. */
+#include <VBox/RemoteDesktop/VRDEVideoIn.h>
+#include <VBox/RemoteDesktop/VRDEInput.h>
+
+#include <VBox/HostServices/VBoxClipboardExt.h>
+#include <VBox/HostServices/VBoxHostChannel.h>
+
+#include "SchemaDefs.h"
+
+// ConsoleVRDPServer
+///////////////////////////////////////////////////////////////////////////////
+
+class EmWebcam;
+
+typedef struct _VRDPInputSynch
+{
+    int cGuestNumLockAdaptions;
+    int cGuestCapsLockAdaptions;
+
+    bool fGuestNumLock;
+    bool fGuestCapsLock;
+    bool fGuestScrollLock;
+
+    bool fClientNumLock;
+    bool fClientCapsLock;
+    bool fClientScrollLock;
+} VRDPInputSynch;
+
+/* Member of Console. Helper class for VRDP server management. Not a COM class. */
+class ConsoleVRDPServer
+{
+public:
+    DECLARE_TRANSLATE_METHODS(ConsoleVRDPServer)
+
+    ConsoleVRDPServer (Console *console);
+    ~ConsoleVRDPServer ();
+
+    int Launch (void);
+
+    void NotifyAbsoluteMouse (bool fGuestWantsAbsolute)
+    {
+        m_fGuestWantsAbsolute = fGuestWantsAbsolute;
+    }
+
+    void NotifyKeyboardLedsChange (BOOL fNumLock, BOOL fCapsLock, BOOL fScrollLock)
+    {
+        bool fGuestNumLock    = (fNumLock != FALSE);
+        bool fGuestCapsLock   = (fCapsLock != FALSE);
+        bool fGuestScrollLock = (fScrollLock != FALSE);
+
+        /* Might need to resync in case the guest itself changed the LED status. */
+        if (m_InputSynch.fClientNumLock != fGuestNumLock)
+        {
+            m_InputSynch.cGuestNumLockAdaptions = 2;
+        }
+
+        if (m_InputSynch.fClientCapsLock != fGuestCapsLock)
+        {
+            m_InputSynch.cGuestCapsLockAdaptions = 2;
+        }
+
+        m_InputSynch.fGuestNumLock    = fGuestNumLock;
+        m_InputSynch.fGuestCapsLock   = fGuestCapsLock;
+        m_InputSynch.fGuestScrollLock = fGuestScrollLock;
+    }
+
+    void EnableConnections (void);
+    void DisconnectClient (uint32_t u32ClientId, bool fReconnect);
+    int MousePointer(BOOL alpha, ULONG xHot, ULONG yHot, ULONG width, ULONG height, const uint8_t *pu8Shape);
+    void MousePointerUpdate (const VRDECOLORPOINTER *pPointer);
+    void MousePointerHide (void);
+
+    void Stop (void);
+
+    AuthResult Authenticate (const Guid &uuid, AuthGuestJudgement guestJudgement,
+                             const char *pszUser, const char *pszPassword, const char *pszDomain,
+                             uint32_t u32ClientId);
+
+    void AuthDisconnect (const Guid &uuid, uint32_t u32ClientId);
+
+    void USBBackendCreate (uint32_t u32ClientId, void **ppvIntercept);
+    void USBBackendDelete (uint32_t u32ClientId);
+
+    void *USBBackendRequestPointer (uint32_t u32ClientId, const Guid *pGuid);
+    void USBBackendReleasePointer (const Guid *pGuid);
+
+    /* Private interface for the RemoteUSBBackend destructor. */
+    void usbBackendRemoveFromList (RemoteUSBBackend *pRemoteUSBBackend);
+
+    /* Private methods for the Remote USB thread. */
+    RemoteUSBBackend *usbBackendGetNext (RemoteUSBBackend *pRemoteUSBBackend);
+
+    void notifyRemoteUSBThreadRunning (RTTHREAD thread);
+    bool isRemoteUSBThreadRunning (void);
+    void waitRemoteUSBThreadEvent (RTMSINTERVAL cMillies);
+
+    void ClipboardCreate (uint32_t u32ClientId);
+    void ClipboardDelete (uint32_t u32ClientId);
+
+    /*
+     * Forwarders to VRDP server library.
+     */
+    void SendUpdate (unsigned uScreenId, void *pvUpdate, uint32_t cbUpdate) const;
+    void SendResize (void);
+    void SendUpdateBitmap (unsigned uScreenId, uint32_t x, uint32_t y, uint32_t w, uint32_t h) const;
+
+    void SendAudioSamples (void const *pvSamples, uint32_t cSamples, VRDEAUDIOFORMAT format) const;
+    void SendAudioVolume (uint16_t left, uint16_t right) const;
+    void SendUSBRequest (uint32_t u32ClientId, void *pvParms, uint32_t cbParms) const;
+
+    void QueryInfo (uint32_t index, void *pvBuffer, uint32_t cbBuffer, uint32_t *pcbOut) const;
+
+    int SendAudioInputBegin(void **ppvUserCtx,
+                            void *pvContext,
+                            uint32_t cSamples,
+                            uint32_t iSampleHz,
+                            uint32_t cChannels,
+                            uint32_t cBits);
+
+    void SendAudioInputEnd(void *pvUserCtx);
+
+    int SCardRequest(void *pvUser, uint32_t u32Function, const void *pvData, uint32_t cbData);
+
+    int VideoInDeviceAttach(const VRDEVIDEOINDEVICEHANDLE *pDeviceHandle, void *pvDeviceCtx);
+    int VideoInDeviceDetach(const VRDEVIDEOINDEVICEHANDLE *pDeviceHandle);
+    int VideoInGetDeviceDesc(void *pvUser, const VRDEVIDEOINDEVICEHANDLE *pDeviceHandle);
+    int VideoInControl(void *pvUser, const VRDEVIDEOINDEVICEHANDLE *pDeviceHandle,
+                       const VRDEVIDEOINCTRLHDR *pReq, uint32_t cbReq);
+
+    Console *getConsole(void) { return mConsole; }
+
+    void onMousePointerShapeChange(BOOL visible, BOOL alpha, ULONG xHot, ULONG yHot,
+                                   ULONG width, ULONG height, ComSafeArrayIn(BYTE,shape));
+
+private:
+    /* Note: This is not a ComObjPtr here, because the ConsoleVRDPServer object
+     * is actually just a part of the Console.
+     */
+    Console *mConsole;
+
+    HVRDESERVER mhServer;
+    int mServerInterfaceVersion;
+
+    int32_t volatile mcInResize; /* Do not Stop the server if this is not 0. */
+
+    static int loadVRDPLibrary (const char *pszLibraryName);
+
+    /** Static because will never load this more than once! */
+    static RTLDRMOD mVRDPLibrary;
+
+    static PFNVRDECREATESERVER mpfnVRDECreateServer;
+
+    static VRDEENTRYPOINTS_4 mEntryPoints;
+    static VRDEENTRYPOINTS_4 *mpEntryPoints;
+    static VRDECALLBACKS_4 mCallbacks;
+
+    static DECLCALLBACK(int)  VRDPCallbackQueryProperty     (void *pvCallback, uint32_t index, void *pvBuffer, uint32_t cbBuffer, uint32_t *pcbOut);
+    static DECLCALLBACK(int)  VRDPCallbackClientLogon       (void *pvCallback, uint32_t u32ClientId, const char *pszUser, const char *pszPassword, const char *pszDomain);
+    static DECLCALLBACK(void) VRDPCallbackClientConnect     (void *pvCallback, uint32_t u32ClientId);
+    static DECLCALLBACK(void) VRDPCallbackClientDisconnect  (void *pvCallback, uint32_t u32ClientId, uint32_t fu32Intercepted);
+    static DECLCALLBACK(int)  VRDPCallbackIntercept         (void *pvCallback, uint32_t u32ClientId, uint32_t fu32Intercept, void **ppvIntercept);
+    static DECLCALLBACK(int)  VRDPCallbackUSB               (void *pvCallback, void *pvIntercept, uint32_t u32ClientId, uint8_t u8Code, const void *pvRet, uint32_t cbRet);
+    static DECLCALLBACK(int)  VRDPCallbackClipboard         (void *pvCallback, void *pvIntercept, uint32_t u32ClientId, uint32_t u32Function, uint32_t u32Format, const void *pvData, uint32_t cbData);
+    static DECLCALLBACK(bool) VRDPCallbackFramebufferQuery  (void *pvCallback, unsigned uScreenId, VRDEFRAMEBUFFERINFO *pInfo);
+    static DECLCALLBACK(void) VRDPCallbackFramebufferLock   (void *pvCallback, unsigned uScreenId);
+    static DECLCALLBACK(void) VRDPCallbackFramebufferUnlock (void *pvCallback, unsigned uScreenId);
+    static DECLCALLBACK(void) VRDPCallbackInput             (void *pvCallback, int type, const void *pvInput, unsigned cbInput);
+    static DECLCALLBACK(void) VRDPCallbackVideoModeHint     (void *pvCallback, unsigned cWidth, unsigned cHeight,  unsigned cBitsPerPixel, unsigned uScreenId);
+    static DECLCALLBACK(void) VRDECallbackAudioIn           (void *pvCallback, void *pvCtx, uint32_t u32ClientId, uint32_t u32Event, const void *pvData, uint32_t cbData);
+
+    void fetchCurrentState(void);
+
+    bool m_fGuestWantsAbsolute;
+    int m_mousex;
+    int m_mousey;
+
+    ComPtr<IDisplaySourceBitmap> maSourceBitmaps[SchemaDefs::MaxGuestMonitors];
+
+    ComPtr<IEventListener> mConsoleListener;
+
+    VRDPInputSynch m_InputSynch;
+
+    int32_t mVRDPBindPort;
+
+    RTCRITSECT mCritSect;
+
+    int lockConsoleVRDPServer (void);
+    void unlockConsoleVRDPServer (void);
+
+    int mcClipboardRefs;
+    HGCMSVCEXTHANDLE mhClipboard;
+    PFNVRDPCLIPBOARDEXTCALLBACK mpfnClipboardCallback;
+
+    static DECLCALLBACK(int) ClipboardCallback (void *pvCallback, uint32_t u32ClientId, uint32_t u32Function, uint32_t u32Format, const void *pvData, uint32_t cbData);
+    static DECLCALLBACK(int) ClipboardServiceExtension(void *pvExtension, uint32_t u32Function, void *pvParms, uint32_t cbParms);
+
+#ifdef VBOX_WITH_USB
+    RemoteUSBBackend *usbBackendFindByUUID (const Guid *pGuid);
+    RemoteUSBBackend *usbBackendFind (uint32_t u32ClientId);
+
+    typedef struct _USBBackends
+    {
+        RemoteUSBBackend *pHead;
+        RemoteUSBBackend *pTail;
+
+        RTTHREAD thread;
+
+        bool fThreadRunning;
+
+        RTSEMEVENT event;
+    } USBBackends;
+
+    USBBackends mUSBBackends;
+
+    void remoteUSBThreadStart (void);
+    void remoteUSBThreadStop (void);
+#endif /* VBOX_WITH_USB */
+
+#ifndef VBOX_WITH_VRDEAUTH_IN_VBOXSVC
+    /* External authentication library context. The library is loaded in the
+     * Authenticate method and unloaded at the object destructor.
+     */
+    AUTHLIBRARYCONTEXT mAuthLibCtx;
+#endif
+
+    uint32_t volatile mu32AudioInputClientId;
+
+    int32_t volatile mcClients;
+
+#if 0 /** @todo Chromium got removed (see @bugref{9529}) and this is not available for VMSVGA yet. */
+    static DECLCALLBACK(void) H3DORBegin(const void *pvContext, void **ppvInstance,
+                                         const char *pszFormat);
+    static DECLCALLBACK(void) H3DORGeometry(void *pvInstance,
+                                            int32_t x, int32_t y, uint32_t w, uint32_t h);
+    static DECLCALLBACK(void) H3DORVisibleRegion(void *pvInstance,
+                                                 uint32_t cRects, const RTRECT *paRects);
+    static DECLCALLBACK(void) H3DORFrame(void *pvInstance,
+                                         void *pvData, uint32_t cbData);
+    static DECLCALLBACK(void) H3DOREnd(void *pvInstance);
+    static DECLCALLBACK(int)  H3DORContextProperty(const void *pvContext, uint32_t index,
+                                                   void *pvBuffer, uint32_t cbBuffer, uint32_t *pcbOut);
+#endif
+
+    void remote3DRedirect(bool fEnable);
+
+    /*
+     * VRDE server optional interfaces.
+     */
+
+    /* Image update interface. */
+    bool m_fInterfaceImage;
+    VRDEIMAGECALLBACKS m_interfaceCallbacksImage;
+    VRDEIMAGEINTERFACE m_interfaceImage;
+    static DECLCALLBACK(int) VRDEImageCbNotify (void *pvContext,
+                                                void *pvUser,
+                                                HVRDEIMAGE hVideo,
+                                                uint32_t u32Id,
+                                                void *pvData,
+                                                uint32_t cbData);
+    /* Mouse pointer interface. */
+    VRDEMOUSEPTRINTERFACE m_interfaceMousePtr;
+
+    /* Smartcard interface. */
+    VRDESCARDINTERFACE m_interfaceSCard;
+    VRDESCARDCALLBACKS m_interfaceCallbacksSCard;
+    static DECLCALLBACK(int) VRDESCardCbNotify(void *pvContext,
+                                               uint32_t u32Id,
+                                               void *pvData,
+                                               uint32_t cbData);
+    static DECLCALLBACK(int) VRDESCardCbResponse(void *pvContext,
+                                                 int vrcRequest,
+                                                 void *pvUser,
+                                                 uint32_t u32Function,
+                                                 void *pvData,
+                                                 uint32_t cbData);
+
+    /* TSMF interface. */
+    VRDETSMFINTERFACE m_interfaceTSMF;
+    VRDETSMFCALLBACKS m_interfaceCallbacksTSMF;
+    static DECLCALLBACK(void) VRDETSMFCbNotify(void *pvContext,
+                                               uint32_t u32Notification,
+                                               void *pvChannel,
+                                               const void *pvParm,
+                                               uint32_t cbParm);
+    void setupTSMF(void);
+
+    static DECLCALLBACK(int) tsmfHostChannelAttach(void *pvProvider, void **ppvInstance, uint32_t u32Flags,
+                                                   VBOXHOSTCHANNELCALLBACKS *pCallbacks, void *pvCallbacks);
+    static DECLCALLBACK(void) tsmfHostChannelDetach(void *pvInstance);
+    static DECLCALLBACK(int) tsmfHostChannelSend(void *pvInstance, const void *pvData, uint32_t cbData);
+    static DECLCALLBACK(int) tsmfHostChannelRecv(void *pvInstance, void *pvData, uint32_t cbData,
+                                                 uint32_t *pcbReturned, uint32_t *pcbRemaining);
+    static DECLCALLBACK(int) tsmfHostChannelControl(void *pvInstance, uint32_t u32Code,
+                                                    const void *pvParm, uint32_t cbParm,
+                                                    const void *pvData, uint32_t cbData, uint32_t *pcbDataReturned);
+    int tsmfLock(void);
+    void tsmfUnlock(void);
+    RTCRITSECT mTSMFLock;
+
+    /* Video input interface. */
+    VRDEVIDEOININTERFACE m_interfaceVideoIn;
+    VRDEVIDEOINCALLBACKS m_interfaceCallbacksVideoIn;
+    static DECLCALLBACK(void) VRDECallbackVideoInNotify(void *pvCallback,
+                                                        uint32_t u32Id,
+                                                        const void *pvData,
+                                                        uint32_t cbData);
+    static DECLCALLBACK(void) VRDECallbackVideoInDeviceDesc(void *pvCallback,
+                                                            int vrcRequest,
+                                                            void *pDeviceCtx,
+                                                            void *pvUser,
+                                                            const VRDEVIDEOINDEVICEDESC *pDeviceDesc,
+                                                            uint32_t cbDevice);
+    static DECLCALLBACK(void) VRDECallbackVideoInControl(void *pvCallback,
+                                                         int vrcRequest,
+                                                         void *pDeviceCtx,
+                                                         void *pvUser,
+                                                         const VRDEVIDEOINCTRLHDR *pControl,
+                                                         uint32_t cbControl);
+    static DECLCALLBACK(void) VRDECallbackVideoInFrame(void *pvCallback,
+                                                       int vrcRequest,
+                                                       void *pDeviceCtx,
+                                                       const VRDEVIDEOINPAYLOADHDR *pFrame,
+                                                       uint32_t cbFrame);
+    EmWebcam *mEmWebcam;
+
+    /* Input interface. */
+    VRDEINPUTINTERFACE m_interfaceInput;
+    VRDEINPUTCALLBACKS m_interfaceCallbacksInput;
+    static DECLCALLBACK(void) VRDECallbackInputSetup(void *pvCallback,
+                                                     int vrcRequest,
+                                                     uint32_t u32Method,
+                                                     const void *pvResult,
+                                                     uint32_t cbResult);
+    static DECLCALLBACK(void) VRDECallbackInputEvent(void *pvCallback,
+                                                     uint32_t u32Method,
+                                                     const void *pvEvent,
+                                                     uint32_t cbEvent);
+    uint64_t mu64TouchInputTimestampMCS;
+};
+
+
+class Console;
+
+class ATL_NO_VTABLE VRDEServerInfo :
+    public VRDEServerInfoWrap
+{
+public:
+    DECLARE_NOT_AGGREGATABLE(VRDEServerInfo)
+
+    DECLARE_COMMON_CLASS_METHODS(VRDEServerInfo)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    /* Public initializer/uninitializer for internal purposes only. */
+    HRESULT init(Console *aParent);
+    void uninit();
+
+private:
+    // wrapped IVRDEServerInfo properties
+#define DECL_GETTER(_aType, _aName) virtual HRESULT get##_aName(_aType *a##_aName)
+#define DECL_GETTER_REF(_aType, _aName) virtual HRESULT get##_aName(_aType &a##_aName)
+    DECL_GETTER(BOOL, Active);
+    DECL_GETTER(LONG, Port);
+    DECL_GETTER(ULONG, NumberOfClients);
+    DECL_GETTER(LONG64, BeginTime);
+    DECL_GETTER(LONG64, EndTime);
+    DECL_GETTER(LONG64, BytesSent);
+    DECL_GETTER(LONG64, BytesSentTotal);
+    DECL_GETTER(LONG64, BytesReceived);
+    DECL_GETTER(LONG64, BytesReceivedTotal);
+    DECL_GETTER_REF(com::Utf8Str, User);
+    DECL_GETTER_REF(com::Utf8Str, Domain);
+    DECL_GETTER_REF(com::Utf8Str, ClientName);
+    DECL_GETTER_REF(com::Utf8Str, ClientIP);
+    DECL_GETTER(ULONG, ClientVersion);
+    DECL_GETTER(ULONG, EncryptionStyle);
+#undef DECL_GETTER_REF
+#undef DECL_GETTER
+
+    Console * const         mParent;
+};
+
+#endif /* !MAIN_INCLUDED_ConsoleVRDPServer_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/CryptoUtils.h b/src/VBox/Main/include/CryptoUtils.h
new file mode 100644
index 00000000..3a14029b
--- /dev/null
+++ b/src/VBox/Main/include/CryptoUtils.h
@@ -0,0 +1,141 @@
+/* $Id: CryptoUtils.h $ */
+/** @file
+ * Main - Cryptographic utility functions used by both VBoxSVC and VBoxC.
+ */
+
+/*
+ * Copyright (C) 2022-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
+ */
+
+#ifndef MAIN_INCLUDED_CryptoUtils_h
+#define MAIN_INCLUDED_CryptoUtils_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/cdefs.h>
+#include <iprt/types.h>
+#include <iprt/vfs.h>
+
+#include <VBox/VBoxCryptoIf.h>
+#include <VBox/com/string.h>
+
+#include <VBox/vmm/ssm.h>
+#include <VBox/vmm/vmmr3vtable.h>
+#include <VBox/vmm/vmapi.h>
+
+#include "SecretKeyStore.h"
+#ifdef VBOX_COM_INPROC
+# include "ConsoleImpl.h"
+#else
+# include "MachineImpl.h"
+# include "VirtualBoxImpl.h"
+#endif
+
+
+/**
+ * Class handling encrypted and non encrypted SSM files.
+ */
+class SsmStream
+{
+    public:
+#ifdef VBOX_COM_INPROC
+        SsmStream(Console *pParent, PCVMMR3VTABLE pVMM, SecretKeyStore *pKeyStore, const Utf8Str &strKeyId, const Utf8Str &strKeyStore);
+#else
+        SsmStream(VirtualBox *pParent, SecretKeyStore *pKeyStore, const Utf8Str &strKeyId, const Utf8Str &strKeyStore);
+#endif
+        ~SsmStream();
+
+        /**
+         * Actually opens the stream for either reading or writing.
+         *
+         * @returns VBox status code.
+         * @param   strFilename The filename of the saved state to open or create.
+         * @param   fWrite      Flag whether the stream should be opened for writing (true) or readonly (false).
+         * @param   ppSsmHandle Where to store the SSM handle on success, don't call SSMR3Close() but the provided close() method.
+         */
+        int open(const Utf8Str &strFilename, bool fWrite, PSSMHANDLE *ppSsmHandle);
+
+        /**
+         * Opens the saved state file for reading, doesn't call SSMR3Open().
+         *
+         * @returns VBox status code.
+         * @param   strFilename The filename of the saved state to open.
+         */
+        int open(const Utf8Str &strFilename);
+
+        /**
+         * Creates a new saved state file under the given path.
+         *
+         * @returns VBox status code.
+         * @param   strFilename The filename of the saved state to create.
+         */
+        int create(const Utf8Str &strFilename);
+
+        /**
+         * Returns the pointer to the stream operations table after a succesful opening/creation.
+         *
+         * @return VBox status code.
+         * @param  ppStrmOps      Where to store the pointer to the stream operations table on success.
+         * @param  ppvStrmOpsUser Where to store the pointer to the opaque user data on success.
+         */
+        int querySsmStrmOps(PCSSMSTRMOPS *ppStrmOps, void **ppvStrmOpsUser);
+
+        /**
+         * Closes an previously opened stream.
+         *
+         * @returns VBox status code.
+         */
+        int close(void);
+
+    private:
+
+        static DECLCALLBACK(int) i_ssmCryptoWrite(void *pvUser, uint64_t offStream, const void *pvBuf, size_t cbToWrite);
+        static DECLCALLBACK(int) i_ssmCryptoRead(void *pvUser, uint64_t offStream, void *pvBuf, size_t cbToRead, size_t *pcbRead);
+        static DECLCALLBACK(int) i_ssmCryptoSeek(void *pvUser, int64_t offSeek, unsigned uMethod, uint64_t *poffActual);
+        static DECLCALLBACK(uint64_t) i_ssmCryptoTell(void *pvUser);
+        static DECLCALLBACK(int) i_ssmCryptoSize(void *pvUser, uint64_t *pcb);
+        static DECLCALLBACK(int) i_ssmCryptoIsOk(void *pvUser);
+        static DECLCALLBACK(int) i_ssmCryptoClose(void *pvUser, bool fCancelled);
+
+#ifdef VBOX_COM_INPROC
+        Console        *m_pParent;
+        PCVMMR3VTABLE  m_pVMM;
+#else
+        VirtualBox     *m_pParent;
+#endif
+        /** The key store for getting at passwords. */
+        SecretKeyStore *m_pKeyStore;
+        /** The key ID holding the password, empty if the saved state is not encrypted. */
+        Utf8Str        m_strKeyId;
+        /** The keystore holding the encrypted DEK. */
+        Utf8Str        m_strKeyStore;
+        /** The VFS file handle. */
+        RTVFSFILE      m_hVfsFile;
+        /** The SSM handle when opened. */
+        PSSMHANDLE     m_pSsm;
+        /** The SSM stream callbacks table. */
+        SSMSTRMOPS     m_StrmOps;
+        /** The cryptographic interfacer. */
+        PCVBOXCRYPTOIF m_pCryptoIf;
+};
+
+#endif /* !MAIN_INCLUDED_CryptoUtils_h */
diff --git a/src/VBox/Main/include/DHCPConfigImpl.h b/src/VBox/Main/include/DHCPConfigImpl.h
new file mode 100644
index 00000000..eb83641d
--- /dev/null
+++ b/src/VBox/Main/include/DHCPConfigImpl.h
@@ -0,0 +1,529 @@
+/* $Id: DHCPConfigImpl.h $ */
+/** @file
+ * VirtualBox Main - IDHCPConfig, IDHCPConfigGlobal, IDHCPConfigGroup, IDHCPConfigIndividual header.
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_DHCPConfigImpl_h
+#define MAIN_INCLUDED_DHCPConfigImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "DHCPGlobalConfigWrap.h"
+#include "DHCPGroupConditionWrap.h"
+#include "DHCPGroupConfigWrap.h"
+#include "DHCPIndividualConfigWrap.h"
+#include <VBox/settings.h>
+
+
+class DHCPServer;
+class DHCPGroupConfig;
+
+
+/**
+ * Base class for the a DHCP configration layer.
+ *
+ * This does not inherit from DHCPConfigWrap because its children need to
+ * inherit from children of DHCPConfigWrap, which smells like trouble and thus
+ * wasn't even attempted.  Instead, we have a hack for passing a pointer that we
+ * can call setError and such on.
+ */
+class DHCPConfig
+{
+protected:
+    /** Config scope (global, group, vm+nic, mac).  */
+    DHCPConfigScope_T const     m_enmScope;
+    /** Minimum lease time. */
+    ULONG                       m_secMinLeaseTime;
+    /** Default lease time. */
+    ULONG                       m_secDefaultLeaseTime;
+    /** Maximum lease time. */
+    ULONG                       m_secMaxLeaseTime;
+    /** List of options which are forced upon the client when available, whether
+     * requested by it or not.  */
+    std::vector<DHCPOption_T>   m_vecForcedOptions;
+    /** List of options which should be suppressed and not returned the the client
+     * when available and requested. */
+    std::vector<DHCPOption_T>   m_vecSuppressedOptions;
+    /** DHCP option map. */
+    settings::DhcpOptionMap     m_OptionMap;
+    /** The DHCP server parent (weak).   */
+    DHCPServer * const          m_pParent;
+    /** The DHCP server parent (weak).   */
+    VirtualBox * const          m_pVirtualBox;
+private:
+    /** For setError and such. */
+    VirtualBoxBase * const      m_pHack;
+
+protected:
+    /** @name Constructors and destructors.
+     * @{ */
+    DHCPConfig(DHCPConfigScope_T a_enmScope, VirtualBoxBase *a_pHack)
+        : m_enmScope(a_enmScope), m_secMinLeaseTime(0), m_secDefaultLeaseTime(0), m_secMaxLeaseTime(0), m_OptionMap()
+        , m_pParent(NULL), m_pVirtualBox(NULL), m_pHack(a_pHack)
+    {}
+    DHCPConfig();
+    virtual ~DHCPConfig()
+    {}
+    HRESULT i_initWithDefaults(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent);
+    HRESULT i_initWithSettings(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, const settings::DHCPConfig &rConfig);
+    /** @} */
+
+    /** @name IDHCPConfig properties
+     * @{ */
+    HRESULT i_getScope(DHCPConfigScope_T *aScope);
+    HRESULT i_getMinLeaseTime(ULONG *aMinLeaseTime);
+    HRESULT i_setMinLeaseTime(ULONG aMinLeaseTime);
+    HRESULT i_getDefaultLeaseTime(ULONG *aDefaultLeaseTime);
+    HRESULT i_setDefaultLeaseTime(ULONG aDefaultLeaseTime);
+    HRESULT i_getMaxLeaseTime(ULONG *aMaxLeaseTime);
+    HRESULT i_setMaxLeaseTime(ULONG aMaxLeaseTime);
+    HRESULT i_getForcedOptions(std::vector<DHCPOption_T> &aOptions);
+    HRESULT i_setForcedOptions(const std::vector<DHCPOption_T> &aOptions);
+    HRESULT i_getSuppressedOptions(std::vector<DHCPOption_T> &aOptions);
+    HRESULT i_setSuppressedOptions(const std::vector<DHCPOption_T> &aOptions);
+    /** @} */
+
+public:
+    DECLARE_TRANSLATE_METHODS(DHCPConfig)
+
+    /** @name IDHCPConfig methods
+     * @note public because the DHCPServer needs them for 6.0 interfaces.
+     * @todo Make protected again when IDHCPServer is cleaned up.
+     * @{ */
+    virtual HRESULT i_setOption(DHCPOption_T aOption, DHCPOptionEncoding_T aEncoding, const com::Utf8Str &aValue);
+
+    virtual HRESULT i_removeOption(DHCPOption_T aOption);
+    virtual HRESULT i_removeAllOptions();
+    HRESULT         i_getOption(DHCPOption_T aOption, DHCPOptionEncoding_T *aEncoding, com::Utf8Str &aValue);
+    HRESULT         i_getAllOptions(std::vector<DHCPOption_T> &aOptions, std::vector<DHCPOptionEncoding_T> &aEncodings,
+                                    std::vector<com::Utf8Str> &aValues);
+    virtual HRESULT i_remove();
+    /** @} */
+
+
+public:
+    HRESULT             i_doWriteConfig();
+    HRESULT             i_saveSettings(settings::DHCPConfig &a_rDst);
+    DHCPConfigScope_T   i_getScope() const RT_NOEXCEPT { return m_enmScope; }
+    virtual void        i_writeDhcpdConfig(xml::ElementNode *pElm);
+};
+
+
+/**
+ * Global DHCP configuration.
+ */
+class DHCPGlobalConfig : public DHCPGlobalConfigWrap, public DHCPConfig
+{
+public:
+    DECLARE_TRANSLATE_METHODS(DHCPGlobalConfig)
+
+    /** @name Constructors and destructors.
+     * @{ */
+    DHCPGlobalConfig()
+        : DHCPConfig(DHCPConfigScope_Global, this)
+    { }
+    HRESULT FinalConstruct()
+    {
+        return BaseFinalConstruct();
+    }
+    void    FinalRelease()
+    {
+        uninit();
+        BaseFinalRelease();
+    }
+    HRESULT initWithDefaults(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent);
+    HRESULT initWithSettings(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, const settings::DHCPConfig &rConfig);
+    void    uninit();
+    /** @} */
+
+    HRESULT i_saveSettings(settings::DHCPConfig &a_rDst);
+    HRESULT i_getNetworkMask(com::Utf8Str &a_rDst);
+    HRESULT i_setNetworkMask(const com::Utf8Str &a_rSrc);
+
+protected:
+    /** @name wrapped IDHCPConfig properties
+     * @{ */
+    HRESULT getScope(DHCPConfigScope_T *aScope) RT_OVERRIDE             { return i_getScope(aScope); }
+    HRESULT getMinLeaseTime(ULONG *aMinLeaseTime) RT_OVERRIDE           { return i_getMinLeaseTime(aMinLeaseTime); }
+    HRESULT setMinLeaseTime(ULONG aMinLeaseTime) RT_OVERRIDE            { return i_setMinLeaseTime(aMinLeaseTime); }
+    HRESULT getDefaultLeaseTime(ULONG *aDefaultLeaseTime) RT_OVERRIDE   { return i_getDefaultLeaseTime(aDefaultLeaseTime); }
+    HRESULT setDefaultLeaseTime(ULONG aDefaultLeaseTime) RT_OVERRIDE    { return i_setDefaultLeaseTime(aDefaultLeaseTime); }
+    HRESULT getMaxLeaseTime(ULONG *aMaxLeaseTime) RT_OVERRIDE           { return i_getMaxLeaseTime(aMaxLeaseTime); }
+    HRESULT setMaxLeaseTime(ULONG aMaxLeaseTime) RT_OVERRIDE            { return i_setMaxLeaseTime(aMaxLeaseTime); }
+    HRESULT getForcedOptions(std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE       { return i_getForcedOptions(aOptions); }
+    HRESULT setForcedOptions(const std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE { return i_setForcedOptions(aOptions); }
+    HRESULT getSuppressedOptions(std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE   { return i_getSuppressedOptions(aOptions); }
+    HRESULT setSuppressedOptions(const std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE  { return i_setSuppressedOptions(aOptions); }
+    /** @} */
+
+    /** @name wrapped IDHCPConfig methods
+     * @{ */
+    HRESULT setOption(DHCPOption_T aOption, DHCPOptionEncoding_T aEncoding, const com::Utf8Str &aValue) RT_OVERRIDE
+    {
+        return i_setOption(aOption, aEncoding, aValue);
+    }
+
+    HRESULT removeOption(DHCPOption_T aOption) RT_OVERRIDE
+    {
+        return i_removeOption(aOption);
+    }
+
+    HRESULT removeAllOptions() RT_OVERRIDE
+    {
+        return i_removeAllOptions();
+    }
+
+    HRESULT getOption(DHCPOption_T aOption, DHCPOptionEncoding_T *aEncoding, com::Utf8Str &aValue) RT_OVERRIDE
+    {
+        return i_getOption(aOption, aEncoding, aValue);
+    }
+
+    HRESULT getAllOptions(std::vector<DHCPOption_T> &aOptions, std::vector<DHCPOptionEncoding_T> &aEncodings,
+                          std::vector<com::Utf8Str> &aValues) RT_OVERRIDE
+    {
+        return i_getAllOptions(aOptions, aEncodings, aValues);
+    }
+
+    HRESULT remove() RT_OVERRIDE
+    {
+        return i_remove();
+    }
+    /** @} */
+
+public:
+    HRESULT i_setOption(DHCPOption_T aOption, DHCPOptionEncoding_T aEncoding, const com::Utf8Str &aValue) RT_OVERRIDE;
+    HRESULT i_removeOption(DHCPOption_T aOption) RT_OVERRIDE;
+    HRESULT i_removeAllOptions() RT_OVERRIDE;
+    HRESULT i_remove() RT_OVERRIDE;
+};
+
+
+/**
+ * DHCP Group inclusion/exclusion condition.
+ */
+class DHCPGroupCondition : public DHCPGroupConditionWrap
+{
+private:
+    /** Inclusive or exclusive condition. */
+    bool                        m_fInclusive;
+    /** The condition type (or how m_strValue should be interpreted). */
+    DHCPGroupConditionType_T    m_enmType;
+    /** The value.  Interpreted according to m_enmType. */
+    com::Utf8Str                m_strValue;
+    /** Pointer to the parent (weak). */
+    DHCPGroupConfig            *m_pParent;
+
+public:
+    DECLARE_TRANSLATE_METHODS(DHCPGroupCondition)
+
+    /** @name Constructors and destructors.
+     * @{ */
+    DHCPGroupCondition()
+        : m_enmType(DHCPGroupConditionType_MAC)
+        , m_pParent(NULL)
+    {}
+    HRESULT FinalConstruct()
+    {
+        return BaseFinalConstruct();
+    }
+    void    FinalRelease()
+    {
+        uninit();
+        BaseFinalRelease();
+    }
+    HRESULT initWithDefaults(DHCPGroupConfig *a_pParent, bool a_fInclusive, DHCPGroupConditionType_T a_enmType,
+                             const com::Utf8Str a_strValue);
+    HRESULT initWithSettings(DHCPGroupConfig *a_pParent, const settings::DHCPGroupCondition &a_rSrc);
+    void    uninit();
+    /** @} */
+
+    HRESULT i_saveSettings(settings::DHCPGroupCondition &a_rDst);
+    static HRESULT i_validateTypeAndValue(DHCPGroupConditionType_T enmType, com::Utf8Str const &strValue,
+                                          VirtualBoxBase *pErrorDst);
+
+    /** @name Internal accessors
+     * @{ */
+    bool                        i_getInclusive() const RT_NOEXCEPT  { return m_fInclusive; }
+    DHCPGroupConditionType_T    i_getType() const RT_NOEXCEPT       { return m_enmType; }
+    com::Utf8Str const         &i_getValue() const RT_NOEXCEPT      { return m_strValue; }
+    /** @} */
+
+protected:
+    /** @name Wrapped IDHCPGroupCondition properties
+     * @{ */
+    HRESULT getInclusive(BOOL *aInclusive) RT_OVERRIDE;
+    HRESULT setInclusive(BOOL aInclusive) RT_OVERRIDE;
+    HRESULT getType(DHCPGroupConditionType_T *aType) RT_OVERRIDE;
+    HRESULT setType(DHCPGroupConditionType_T aType) RT_OVERRIDE;
+    HRESULT getValue(com::Utf8Str &aValue) RT_OVERRIDE;
+    HRESULT setValue(const com::Utf8Str &aValue) RT_OVERRIDE;
+    /** @} */
+
+    /** @name Wrapped IDHCPGroupCondition methods
+     * @{ */
+    HRESULT remove() RT_OVERRIDE;
+    /** @} */
+};
+
+
+/**
+ * Group configuration.
+ */
+class DHCPGroupConfig : public DHCPGroupConfigWrap, public DHCPConfig
+{
+private:
+    /** Group name. */
+    com::Utf8Str                                m_strName;
+    /** Group membership conditions.   */
+    std::vector<ComObjPtr<DHCPGroupCondition> > m_Conditions;
+    /** Iterator for m_Conditions. */
+    typedef std::vector<ComObjPtr<DHCPGroupCondition> >::iterator ConditionsIterator;
+
+public:
+    DECLARE_TRANSLATE_METHODS(DHCPGroupConfig)
+
+    /** @name Constructors and destructors.
+     * @{ */
+    DHCPGroupConfig()
+        : DHCPConfig(DHCPConfigScope_Group, this)
+    { }
+    HRESULT FinalConstruct()
+    {
+        return BaseFinalConstruct();
+    }
+    void    FinalRelease()
+    {
+        uninit();
+        BaseFinalRelease();
+    }
+    HRESULT initWithDefaults(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, const com::Utf8Str &a_rName);
+    HRESULT initWithSettings(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, const settings::DHCPGroupConfig &a_rSrc);
+    void    uninit();
+    /** @} */
+
+    HRESULT i_saveSettings(settings::DHCPGroupConfig &a_rDst);
+    HRESULT i_removeCondition(DHCPGroupCondition *a_pCondition);
+    void    i_writeDhcpdConfig(xml::ElementNode *a_pElmGroup) RT_OVERRIDE;
+
+protected:
+    /** @name Wrapped IDHCPConfig properties
+     * @{ */
+    HRESULT getScope(DHCPConfigScope_T *aScope) RT_OVERRIDE             { return i_getScope(aScope); }
+    HRESULT getMinLeaseTime(ULONG *aMinLeaseTime) RT_OVERRIDE           { return i_getMinLeaseTime(aMinLeaseTime); }
+    HRESULT setMinLeaseTime(ULONG aMinLeaseTime) RT_OVERRIDE            { return i_setMinLeaseTime(aMinLeaseTime); }
+    HRESULT getDefaultLeaseTime(ULONG *aDefaultLeaseTime) RT_OVERRIDE   { return i_getDefaultLeaseTime(aDefaultLeaseTime); }
+    HRESULT setDefaultLeaseTime(ULONG aDefaultLeaseTime) RT_OVERRIDE    { return i_setDefaultLeaseTime(aDefaultLeaseTime); }
+    HRESULT getMaxLeaseTime(ULONG *aMaxLeaseTime) RT_OVERRIDE           { return i_getMaxLeaseTime(aMaxLeaseTime); }
+    HRESULT setMaxLeaseTime(ULONG aMaxLeaseTime) RT_OVERRIDE            { return i_setMaxLeaseTime(aMaxLeaseTime); }
+    HRESULT getForcedOptions(std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE       { return i_getForcedOptions(aOptions); }
+    HRESULT setForcedOptions(const std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE { return i_setForcedOptions(aOptions); }
+    HRESULT getSuppressedOptions(std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE   { return i_getSuppressedOptions(aOptions); }
+    HRESULT setSuppressedOptions(const std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE  { return i_setSuppressedOptions(aOptions); }
+    /** @} */
+
+    /** @name Wrapped IDHCPGroupConfig properties
+     * @{ */
+    HRESULT getName(com::Utf8Str &aName) RT_OVERRIDE;
+    HRESULT setName(const com::Utf8Str &aName) RT_OVERRIDE;
+    HRESULT getConditions(std::vector<ComPtr<IDHCPGroupCondition> > &aConditions) RT_OVERRIDE;
+    /** @} */
+
+    /** @name Wrapped IDHCPConfig methods
+     * @{ */
+    HRESULT setOption(DHCPOption_T aOption, DHCPOptionEncoding_T aEncoding, const com::Utf8Str &aValue) RT_OVERRIDE
+    {
+        return i_setOption(aOption, aEncoding, aValue);
+    }
+
+    HRESULT removeOption(DHCPOption_T aOption) RT_OVERRIDE
+    {
+        return i_removeOption(aOption);
+    }
+
+    HRESULT removeAllOptions() RT_OVERRIDE
+    {
+        return i_removeAllOptions();
+    }
+
+    HRESULT getOption(DHCPOption_T aOption, DHCPOptionEncoding_T *aEncoding, com::Utf8Str &aValue) RT_OVERRIDE
+    {
+        return i_getOption(aOption, aEncoding, aValue);
+    }
+
+    HRESULT getAllOptions(std::vector<DHCPOption_T> &aOptions, std::vector<DHCPOptionEncoding_T> &aEncodings,
+                          std::vector<com::Utf8Str> &aValues) RT_OVERRIDE
+    {
+        return i_getAllOptions(aOptions, aEncodings, aValues);
+    }
+
+    HRESULT remove() RT_OVERRIDE
+    {
+        return i_remove();
+    }
+    /** @} */
+
+    /** @name Wrapped IDHCPGroupConfig methods
+     * @{ */
+    HRESULT addCondition(BOOL aInclusive, DHCPGroupConditionType_T aType, const com::Utf8Str &aValue,
+                         ComPtr<IDHCPGroupCondition> &aCondition) RT_OVERRIDE;
+    HRESULT removeAllConditions() RT_OVERRIDE;
+    /** @} */
+};
+
+
+/**
+ * Individual DHCP configuration.
+ */
+class DHCPIndividualConfig : public DHCPIndividualConfigWrap, public DHCPConfig
+{
+private:
+    /** The MAC address or all zeros. */
+    RTMAC               m_MACAddress;
+    /** The VM ID or all zeros. */
+    com::Guid const     m_idMachine;
+    /** The VM NIC slot number, or ~(ULONG)0. */
+    ULONG const         m_uSlot;
+    /** This is part of a hack to resolve the MAC address for
+     * DHCPConfigScope_MachineNIC instances.  If non-zero, we m_MACAddress is valid.
+     * To deal with the impossibly theoretical scenario that the DHCP server is
+     * being started by more than one thread, this is a version number and not just
+     * a boolean indicator.   */
+    uint32_t volatile   m_uMACAddressResolvedVersion;
+
+    /** The fixed IPv4 address, empty if dynamic. */
+    com::Utf8Str        m_strFixedAddress;
+
+public:
+    DECLARE_TRANSLATE_METHODS(DHCPIndividualConfig)
+
+    /** @name Constructors and destructors.
+     * @{ */
+    DHCPIndividualConfig()
+        : DHCPConfig(DHCPConfigScope_MAC, this)
+        , m_uSlot(~(ULONG)0)
+        , m_uMACAddressResolvedVersion(0)
+    {
+        RT_ZERO(m_MACAddress);
+    }
+    HRESULT FinalConstruct()
+    {
+        return BaseFinalConstruct();
+    }
+    void    FinalRelease()
+    {
+        uninit();
+        BaseFinalRelease();
+    }
+    HRESULT initWithMachineIdAndSlot(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, com::Guid const &a_idMachine,
+                                     ULONG a_uSlot, uint32_t a_uMACAddressVersion);
+    HRESULT initWithMACAddress(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent, PCRTMAC a_pMACAddress);
+    HRESULT initWithSettingsAndMachineIdAndSlot(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent,
+                                                const settings::DHCPIndividualConfig &rData, com::Guid const &a_idMachine,
+                                                ULONG a_uSlot, uint32_t a_uMACAddressVersion);
+    HRESULT initWithSettingsAndMACAddress(VirtualBox *a_pVirtualBox, DHCPServer *a_pParent,
+                                          const settings::DHCPIndividualConfig &rData, PCRTMAC a_pMACAddress);
+    void    uninit();
+    /** @} */
+
+    /** @name Internal methods that are public for various reasons
+     * @{ */
+    HRESULT             i_saveSettings(settings::DHCPIndividualConfig &a_rDst);
+    RTMAC const        &i_getMACAddress() const RT_NOEXCEPT    { return m_MACAddress; }
+    com::Guid const    &i_getMachineId() const RT_NOEXCEPT     { return m_idMachine; }
+    ULONG               i_getSlot() const RT_NOEXCEPT          { return m_uSlot; }
+    HRESULT             i_getMachineMAC(PRTMAC pMACAddress);
+
+    HRESULT             i_resolveMACAddress(uint32_t uVersion);
+    /** This is used to avoid producing bogus Dhcpd configuration elements. */
+    bool                i_isMACAddressResolved(uint32_t uVersion) const
+    {
+        return m_enmScope != DHCPConfigScope_MachineNIC || (int32_t)(m_uMACAddressResolvedVersion - uVersion) >= 0;
+    }
+    void                i_writeDhcpdConfig(xml::ElementNode *pElm) RT_OVERRIDE;
+    /** @} */
+
+protected:
+    /** @name wrapped IDHCPConfig properties
+     * @{ */
+    HRESULT getScope(DHCPConfigScope_T *aScope) RT_OVERRIDE             { return i_getScope(aScope); }
+    HRESULT getMinLeaseTime(ULONG *aMinLeaseTime) RT_OVERRIDE           { return i_getMinLeaseTime(aMinLeaseTime); }
+    HRESULT setMinLeaseTime(ULONG aMinLeaseTime) RT_OVERRIDE            { return i_setMinLeaseTime(aMinLeaseTime); }
+    HRESULT getDefaultLeaseTime(ULONG *aDefaultLeaseTime) RT_OVERRIDE   { return i_getDefaultLeaseTime(aDefaultLeaseTime); }
+    HRESULT setDefaultLeaseTime(ULONG aDefaultLeaseTime) RT_OVERRIDE    { return i_setDefaultLeaseTime(aDefaultLeaseTime); }
+    HRESULT getMaxLeaseTime(ULONG *aMaxLeaseTime) RT_OVERRIDE           { return i_getMaxLeaseTime(aMaxLeaseTime); }
+    HRESULT setMaxLeaseTime(ULONG aMaxLeaseTime) RT_OVERRIDE            { return i_setMaxLeaseTime(aMaxLeaseTime); }
+    HRESULT getForcedOptions(std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE       { return i_getForcedOptions(aOptions); }
+    HRESULT setForcedOptions(const std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE { return i_setForcedOptions(aOptions); }
+    HRESULT getSuppressedOptions(std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE   { return i_getSuppressedOptions(aOptions); }
+    HRESULT setSuppressedOptions(const std::vector<DHCPOption_T> &aOptions) RT_OVERRIDE  { return i_setSuppressedOptions(aOptions); }
+    /** @} */
+
+    /** @name wrapped IDHCPConfig methods
+     * @{ */
+    HRESULT setOption(DHCPOption_T aOption, DHCPOptionEncoding_T aEncoding, const com::Utf8Str &aValue) RT_OVERRIDE
+    {
+        return i_setOption(aOption, aEncoding, aValue);
+    }
+
+    HRESULT removeOption(DHCPOption_T aOption) RT_OVERRIDE
+    {
+        return i_removeOption(aOption);
+    }
+
+    HRESULT removeAllOptions() RT_OVERRIDE
+    {
+        return i_removeAllOptions();
+    }
+
+    HRESULT getOption(DHCPOption_T aOption, DHCPOptionEncoding_T *aEncoding, com::Utf8Str &aValue) RT_OVERRIDE
+    {
+        return i_getOption(aOption, aEncoding, aValue);
+    }
+
+    HRESULT getAllOptions(std::vector<DHCPOption_T> &aOptions, std::vector<DHCPOptionEncoding_T> &aEncodings,
+                          std::vector<com::Utf8Str> &aValues) RT_OVERRIDE
+    {
+        return i_getAllOptions(aOptions, aEncodings, aValues);
+    }
+
+    HRESULT remove() RT_OVERRIDE
+    {
+        return i_remove();
+    }
+    /** @} */
+
+    /** @name IDHCPIndividualConfig properties
+     * @{ */
+    HRESULT getMACAddress(com::Utf8Str &aMacAddress) RT_OVERRIDE;
+    HRESULT getMachineId(com::Guid &aId) RT_OVERRIDE;
+    HRESULT getSlot(ULONG *aSlot) RT_OVERRIDE;
+    HRESULT getFixedAddress(com::Utf8Str &aFixedAddress) RT_OVERRIDE;
+    HRESULT setFixedAddress(const com::Utf8Str &aFixedAddress) RT_OVERRIDE;
+    /** @} */
+};
+
+#endif /* !MAIN_INCLUDED_DHCPConfigImpl_h */
+
diff --git a/src/VBox/Main/include/DHCPServerImpl.h b/src/VBox/Main/include/DHCPServerImpl.h
new file mode 100644
index 00000000..92c925f8
--- /dev/null
+++ b/src/VBox/Main/include/DHCPServerImpl.h
@@ -0,0 +1,130 @@
+/* $Id: DHCPServerImpl.h $ */
+/** @file
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_DHCPServerImpl_h
+#define MAIN_INCLUDED_DHCPServerImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "DHCPServerWrap.h"
+#include <map>
+
+namespace settings
+{
+    struct DHCPServer;
+    struct DhcpOptValue;
+    typedef std::map<DHCPOption_T, DhcpOptValue> DhcpOptionMap;
+}
+
+class DHCPConfig;
+class DHCPIndividualConfig;
+
+/**
+ * A DHCP server for internal host-only & NAT networks.
+ *
+ * Old notes:
+ *
+ *  for server configuration needs, it's perhaps better to use (VM,slot) pair
+ *  (vm-name, slot) <----> (MAC)
+ *
+ *  but for client configuration, when server will have MACs at hand, it'd be
+ *  easier to requiest options by MAC.
+ *  (MAC) <----> (option-list)
+ *
+ *  Doubts: What should be done if MAC changed for (vm-name, slot), when syncing should?
+ *  XML: serialization of dependecy (DHCP options) - (VM,slot) shouldn't be done via MAC in
+ *  the middle.
+ */
+class ATL_NO_VTABLE DHCPServer
+    : public DHCPServerWrap
+{
+public:
+    /** @name Constructors and destructors
+     * @{ */
+    DECLARE_COMMON_CLASS_METHODS(DHCPServer)
+    HRESULT FinalConstruct();
+    void    FinalRelease();
+
+    HRESULT init(VirtualBox *aVirtualBox, const com::Utf8Str &aName);
+    HRESULT init(VirtualBox *aVirtualBox, const settings::DHCPServer &data);
+    void    uninit();
+    /** @} */
+
+    /** @name Public internal methods.
+     * @{ */
+    HRESULT i_saveSettings(settings::DHCPServer &data);
+    HRESULT i_removeConfig(DHCPConfig *pConfig, DHCPConfigScope_T enmScope);
+    /** @} */
+
+private:
+    /** @name IDHCPServer Properties
+     * @{ */
+    HRESULT getEventSource(ComPtr<IEventSource> &aEventSource) RT_OVERRIDE;
+    HRESULT getEnabled(BOOL *aEnabled) RT_OVERRIDE;
+    HRESULT setEnabled(BOOL aEnabled) RT_OVERRIDE;
+    HRESULT getIPAddress(com::Utf8Str &aIPAddress) RT_OVERRIDE;
+    HRESULT getNetworkMask(com::Utf8Str &aNetworkMask) RT_OVERRIDE;
+    HRESULT getNetworkName(com::Utf8Str &aName) RT_OVERRIDE;
+    HRESULT getLowerIP(com::Utf8Str &aIPAddress) RT_OVERRIDE;
+    HRESULT getUpperIP(com::Utf8Str &aIPAddress) RT_OVERRIDE;
+    HRESULT setConfiguration(const com::Utf8Str &aIPAddress, const com::Utf8Str &aNetworkMask,
+                             const com::Utf8Str &aFromIPAddress, const com::Utf8Str &aToIPAddress) RT_OVERRIDE;
+    HRESULT getGlobalConfig(ComPtr<IDHCPGlobalConfig> &aGlobalConfig) RT_OVERRIDE;
+    HRESULT getGroupConfigs(std::vector<ComPtr<IDHCPGroupConfig> > &aGroupConfigs) RT_OVERRIDE;
+    HRESULT getIndividualConfigs(std::vector<ComPtr<IDHCPIndividualConfig> > &aIndividualConfigs) ;
+    /** @} */
+
+    /** @name IDHCPServer Methods
+     * @{ */
+    HRESULT start(const com::Utf8Str &aTrunkName, const com::Utf8Str &aTrunkType) RT_OVERRIDE;
+    HRESULT stop() RT_OVERRIDE;
+    HRESULT restart() RT_OVERRIDE;
+    HRESULT findLeaseByMAC(const com::Utf8Str &aMac, LONG aType, com::Utf8Str &aAddress, com::Utf8Str &aState,
+                           LONG64 *aIssued, LONG64 *aExpire) RT_OVERRIDE;
+    HRESULT getConfig(DHCPConfigScope_T aScope, const com::Utf8Str &aName, ULONG aSlot, BOOL aMayAdd,
+                      ComPtr<IDHCPConfig> &aConfig) RT_OVERRIDE;
+    /** @} */
+
+    /** @name Helpers
+     * @{  */
+    HRESULT i_doSaveSettings();
+    HRESULT i_calcLeasesConfigAndLogFilenames(const com::Utf8Str &aNetwork) RT_NOEXCEPT;
+    HRESULT i_writeDhcpdConfig(const char *pszFilename, uint32_t uMACAddressVersion) RT_NOEXCEPT;
+
+    HRESULT i_vmNameToIdAndValidateSlot(const com::Utf8Str &aVmName, ULONG a_uSlot, com::Guid &idMachine);
+    HRESULT i_vmNameAndSlotToConfig(const com::Utf8Str &a_strVmName, ULONG a_uSlot, bool a_fCreateIfNeeded,
+                                    ComObjPtr<DHCPIndividualConfig> &a_rPtrConfig);
+    /** @} */
+
+    /** Private data */
+    struct Data;
+    /** Private data. */
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_DHCPServerImpl_h */
diff --git a/src/VBox/Main/include/DataStreamImpl.h b/src/VBox/Main/include/DataStreamImpl.h
new file mode 100644
index 00000000..1dad9b22
--- /dev/null
+++ b/src/VBox/Main/include/DataStreamImpl.h
@@ -0,0 +1,78 @@
+/* $Id: DataStreamImpl.h $ */
+/** @file
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2018-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
+ */
+
+#ifndef MAIN_INCLUDED_DataStreamImpl_h
+#define MAIN_INCLUDED_DataStreamImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "DataStreamWrap.h"
+
+#include <iprt/circbuf.h>
+#include <iprt/semaphore.h>
+
+class ATL_NO_VTABLE DataStream
+    : public DataStreamWrap
+{
+public:
+    DECLARE_COMMON_CLASS_METHODS(DataStream)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    HRESULT init(unsigned long aBufferSize);
+    void uninit();
+
+    /// Feed data into the stream, used by the stream source.
+    /// Blocks if the internal buffer cannot take anything, otherwise
+    /// as much as the internal buffer can hold is taken (if smaller
+    /// than @a cbWrite). Modeled after RTStrmWriteEx.
+    int i_write(const void *pvBuf, size_t cbWrite, size_t *pcbWritten);
+
+    /// Marks the end of the stream.
+    int i_close();
+
+private:
+    // wrapped IDataStream attributes and methods
+    HRESULT getReadSize(ULONG *aReadSize);
+    HRESULT read(ULONG aSize, ULONG aTimeoutMS, std::vector<BYTE> &aData);
+
+private:
+    /** The temporary buffer the conversion process writes into and the user reads from. */
+    PRTCIRCBUF        m_pBuffer;
+    /** Event semaphore for waiting until data is available. */
+    RTSEMEVENT        m_hSemEvtDataAvail;
+    /** Event semaphore for waiting until there is room in the buffer for writing. */
+    RTSEMEVENT        m_hSemEvtBufSpcAvail;
+    /** Flag whether the end of stream flag is set. */
+    bool              m_fEos;
+};
+
+#endif /* !MAIN_INCLUDED_DataStreamImpl_h */
+
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/DisplayImpl.h b/src/VBox/Main/include/DisplayImpl.h
new file mode 100644
index 00000000..052bf2f4
--- /dev/null
+++ b/src/VBox/Main/include/DisplayImpl.h
@@ -0,0 +1,562 @@
+/* $Id: DisplayImpl.h $ */
+/** @file
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_DisplayImpl_h
+#define MAIN_INCLUDED_DisplayImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "SchemaDefs.h"
+
+#include <iprt/semaphore.h>
+#include <VBox/vmm/pdmdrv.h>
+#include <VBoxVideo.h>
+#include <VBox/vmm/pdmifs.h>
+#include <VBox/VMMDev.h>  /* For struct VMMDevDisplayDef - why is it in that file? */
+#include "DisplayWrap.h"
+
+#include "DisplaySourceBitmapWrap.h"
+#include "GuestScreenInfoWrap.h"
+
+
+class Console;
+
+typedef struct _DISPLAYFBINFO
+{
+    /* The following 3 fields (u32Offset, u32MaxFramebufferSize and u32InformationSize)
+     * are not used by the current HGSMI. They are needed for backward compatibility with
+     * pre-HGSMI additions.
+     */
+    uint32_t u32Offset;
+    uint32_t u32MaxFramebufferSize;
+    uint32_t u32InformationSize;
+
+    ComPtr<IFramebuffer> pFramebuffer;
+    com::Guid framebufferId;
+    ComPtr<IDisplaySourceBitmap> pSourceBitmap;
+    bool fDisabled;
+
+    uint32_t u32Caps;
+
+    struct
+    {
+        ComPtr<IDisplaySourceBitmap> pSourceBitmap;
+        uint8_t *pu8Address;
+        uint32_t cbLine;
+    } updateImage;
+
+    LONG xOrigin;
+    LONG yOrigin;
+
+    ULONG w;
+    ULONG h;
+
+    uint16_t u16BitsPerPixel;
+    uint8_t *pu8FramebufferVRAM;
+    uint32_t u32LineSize;
+
+    uint16_t flags;
+
+    VBOXVIDEOINFOHOSTEVENTS *pHostEvents;
+
+    /** The framebuffer has default format and must be updates immediately. */
+    bool fDefaultFormat;
+
+#ifdef VBOX_WITH_HGSMI
+    bool fVBVAEnabled;
+    bool fVBVAForceResize;
+    VBVAHOSTFLAGS RT_UNTRUSTED_VOLATILE_GUEST *pVBVAHostFlags;
+#endif /* VBOX_WITH_HGSMI */
+
+#ifdef VBOX_WITH_RECORDING
+    struct
+    {
+        ComPtr<IDisplaySourceBitmap> pSourceBitmap;
+    } Recording;
+#endif /* VBOX_WITH_RECORDING */
+
+    /** Description of the currently plugged monitor with preferred mode,
+     * a.k.a the last mode hint sent. */
+    struct VMMDevDisplayDef monitorDesc;
+} DISPLAYFBINFO;
+
+/* The legacy VBVA (VideoAccel) data.
+ *
+ * Backward compatibility with the Guest Additions 3.x or older.
+ */
+typedef struct VIDEOACCEL
+{
+    VBVAMEMORY *pVbvaMemory;
+    bool        fVideoAccelEnabled;
+
+    uint8_t    *pu8VbvaPartial;
+    uint32_t    cbVbvaPartial;
+
+    /* Old Guest Additions (3.x and older) use both VMMDev and DevVGA refresh timer
+     * to process the VBVABUFFER memory. Therefore the legacy VBVA (VideoAccel) host
+     * code can be executed concurrently by VGA refresh timer and the guest VMMDev
+     * request in SMP VMs. The semaphore serialized this.
+     */
+    RTSEMXROADS hXRoadsVideoAccel;
+
+} VIDEOACCEL;
+
+class DisplayMouseInterface
+{
+public:
+    virtual ~DisplayMouseInterface() { }
+    virtual HRESULT i_getScreenResolution(ULONG cScreen, ULONG *pcx,
+                                          ULONG *pcy, ULONG *pcBPP, LONG *pXOrigin, LONG *pYOrigin) = 0;
+    virtual void i_getFramebufferDimensions(int32_t *px1, int32_t *py1,
+                                            int32_t *px2, int32_t *py2) = 0;
+    virtual HRESULT i_reportHostCursorCapabilities(uint32_t fCapabilitiesAdded, uint32_t fCapabilitiesRemoved) = 0;
+    virtual HRESULT i_reportHostCursorPosition(int32_t x, int32_t y, bool fOutOfRange) = 0;
+    virtual bool i_isInputMappingSet(void) = 0;
+};
+
+class VMMDev;
+
+class ATL_NO_VTABLE Display :
+    public DisplayWrap,
+    public DisplayMouseInterface
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(Display)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Console *aParent);
+    void uninit();
+    int  i_registerSSM(PUVM pUVM);
+
+    // public methods only for internal purposes
+    unsigned i_getMonitorCount() { return mcMonitors; }
+    int i_handleDisplayResize(unsigned uScreenId, uint32_t bpp, void *pvVRAM,
+                              uint32_t cbLine, uint32_t w, uint32_t h, uint16_t flags,
+                              int32_t xOrigin, int32_t yOrigin, bool fVGAResize);
+    void i_handleDisplayUpdate(unsigned uScreenId, int x, int y, int w, int h);
+    void i_handleUpdateVMMDevSupportsGraphics(bool fSupportsGraphics);
+    void i_handleUpdateGuestVBVACapabilities(uint32_t fNewCapabilities);
+    void i_handleUpdateVBVAInputMapping(int32_t xOrigin, int32_t yOrigin, uint32_t cx, uint32_t cy);
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    int  i_handleVHWACommandProcess(int enmCmd, bool fGuestCmd, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand);
+#endif
+    int  i_handle3DNotifyProcess(VBOX3DNOTIFY *p3DNotify);
+
+    int  i_saveVisibleRegion(uint32_t cRect, PRTRECT pRect);
+    int  i_handleSetVisibleRegion(uint32_t cRect, PRTRECT pRect);
+    int  i_handleUpdateMonitorPositions(uint32_t cPositions, PCRTPOINT paPositions);
+    int  i_handleQueryVisibleRegion(uint32_t *pcRects, PRTRECT paRects);
+
+    void i_VRDPConnectionEvent(bool fConnect);
+    void i_VideoAccelVRDP(bool fEnable, int c);
+
+    /* Legacy video acceleration requests coming from the VGA refresh timer. */
+    int  VideoAccelEnableVGA(bool fEnable, VBVAMEMORY *pVbvaMemory);
+
+    /* Legacy video acceleration requests coming from VMMDev. */
+    int  VideoAccelEnableVMMDev(bool fEnable, VBVAMEMORY *pVbvaMemory);
+    void VideoAccelFlushVMMDev(void);
+
+    void i_UpdateDeviceCursorCapabilities(void);
+
+#ifdef VBOX_WITH_RECORDING
+    int  i_recordingInvalidate(void);
+    void i_recordingScreenChanged(unsigned uScreenId);
+#endif
+
+    void i_notifyPowerDown(void);
+
+    // DisplayMouseInterface methods
+    virtual HRESULT i_getScreenResolution(ULONG cScreen, ULONG *pcx,
+                                          ULONG *pcy, ULONG *pcBPP, LONG *pXOrigin, LONG *pYOrigin)
+    {
+        return getScreenResolution(cScreen, pcx, pcy, pcBPP, pXOrigin, pYOrigin, NULL);
+    }
+    virtual void i_getFramebufferDimensions(int32_t *px1, int32_t *py1,
+                                            int32_t *px2, int32_t *py2);
+    virtual HRESULT i_reportHostCursorCapabilities(uint32_t fCapabilitiesAdded, uint32_t fCapabilitiesRemoved);
+    virtual HRESULT i_reportHostCursorPosition(int32_t x, int32_t y, bool fOutOfRange);
+    virtual bool i_isInputMappingSet(void)
+    {
+        return cxInputMapping != 0 && cyInputMapping != 0;
+    }
+
+    static const PDMDRVREG  DrvReg;
+
+private:
+    // Wrapped IDisplay properties
+    virtual HRESULT getGuestScreenLayout(std::vector<ComPtr<IGuestScreenInfo> > &aGuestScreenLayout);
+
+    // Wrapped IDisplay methods
+    virtual HRESULT getScreenResolution(ULONG aScreenId,
+                                        ULONG *aWidth,
+                                        ULONG *aHeight,
+                                        ULONG *aBitsPerPixel,
+                                        LONG *aXOrigin,
+                                        LONG *aYOrigin,
+                                        GuestMonitorStatus_T *aGuestMonitorStatus);
+    virtual HRESULT attachFramebuffer(ULONG aScreenId,
+                                      const ComPtr<IFramebuffer> &aFramebuffer,
+                                      com::Guid &aId);
+    virtual HRESULT detachFramebuffer(ULONG aScreenId,
+                                      const com::Guid &aId);
+    virtual HRESULT queryFramebuffer(ULONG aScreenId,
+                                     ComPtr<IFramebuffer> &aFramebuffer);
+    virtual HRESULT setVideoModeHint(ULONG aDisplay,
+                                     BOOL aEnabled,
+                                     BOOL aChangeOrigin,
+                                     LONG aOriginX,
+                                     LONG aOriginY,
+                                     ULONG aWidth,
+                                     ULONG aHeight,
+                                     ULONG aBitsPerPixel,
+                                     BOOL aNotify);
+    virtual HRESULT getVideoModeHint(ULONG aDisplay,
+                                     BOOL *aEnabled,
+                                     BOOL *aChangeOrigin,
+                                     LONG *aOriginX,
+                                     LONG *aOriginY,
+                                     ULONG *aWidth,
+                                     ULONG *aHeight,
+                                     ULONG *aBitsPerPixel);
+    virtual HRESULT setSeamlessMode(BOOL aEnabled);
+    virtual HRESULT takeScreenShot(ULONG aScreenId,
+                                   BYTE *aAddress,
+                                   ULONG aWidth,
+                                   ULONG aHeight,
+                                   BitmapFormat_T aBitmapFormat);
+    virtual HRESULT takeScreenShotToArray(ULONG aScreenId,
+                                          ULONG aWidth,
+                                          ULONG aHeight,
+                                          BitmapFormat_T aBitmapFormat,
+                                          std::vector<BYTE> &aScreenData);
+    virtual HRESULT drawToScreen(ULONG aScreenId,
+                                 BYTE *aAddress,
+                                 ULONG aX,
+                                 ULONG aY,
+                                 ULONG aWidth,
+                                 ULONG aHeight);
+    virtual HRESULT invalidateAndUpdate();
+    virtual HRESULT invalidateAndUpdateScreen(ULONG aScreenId);
+    virtual HRESULT completeVHWACommand(BYTE *aCommand);
+    virtual HRESULT viewportChanged(ULONG aScreenId,
+                                    ULONG aX,
+                                    ULONG aY,
+                                    ULONG aWidth,
+                                    ULONG aHeight);
+    virtual HRESULT querySourceBitmap(ULONG aScreenId,
+                                      ComPtr<IDisplaySourceBitmap> &aDisplaySourceBitmap);
+    virtual HRESULT notifyScaleFactorChange(ULONG aScreenId,
+                                            ULONG aScaleFactorWMultiplied,
+                                            ULONG aScaleFactorHMultiplied);
+    virtual HRESULT notifyHiDPIOutputPolicyChange(BOOL fUnscaledHiDPI);
+    virtual HRESULT setScreenLayout(ScreenLayoutMode_T aScreenLayoutMode,
+                                    const std::vector<ComPtr<IGuestScreenInfo> > &aGuestScreenInfo);
+    virtual HRESULT detachScreens(const std::vector<LONG> &aScreenIds);
+    virtual HRESULT createGuestScreenInfo(ULONG aDisplay,
+                                          GuestMonitorStatus_T aStatus,
+                                          BOOL aPrimary,
+                                          BOOL aChangeOrigin,
+                                          LONG aOriginX,
+                                          LONG aOriginY,
+                                          ULONG aWidth,
+                                          ULONG aHeight,
+                                          ULONG aBitsPerPixel,
+                                          ComPtr<IGuestScreenInfo> &aGuestScreenInfo);
+
+    // Wrapped IEventListener properties
+
+    // Wrapped IEventListener methods
+    virtual HRESULT handleEvent(const ComPtr<IEvent> &aEvent);
+
+    // other internal methods
+    HRESULT takeScreenShotWorker(ULONG aScreenId,
+                                 BYTE *aAddress,
+                                 ULONG aWidth,
+                                 ULONG aHeight,
+                                 BitmapFormat_T aBitmapFormat,
+                                 ULONG *pcbOut);
+    int processVBVAResize(PCVBVAINFOVIEW pView, PCVBVAINFOSCREEN pScreen, void *pvVRAM, bool fResetInputMapping);
+
+    static DECLCALLBACK(void*) i_drvQueryInterface(PPDMIBASE pInterface, const char *pszIID);
+    static DECLCALLBACK(int)   i_drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
+    static DECLCALLBACK(void)  i_drvDestruct(PPDMDRVINS pDrvIns);
+    static DECLCALLBACK(void)  i_drvPowerOff(PPDMDRVINS pDrvIns);
+    static DECLCALLBACK(int)   i_displayResizeCallback(PPDMIDISPLAYCONNECTOR pInterface, uint32_t bpp, void *pvVRAM,
+                                                       uint32_t cbLine, uint32_t cx, uint32_t cy);
+    static DECLCALLBACK(void)  i_displayUpdateCallback(PPDMIDISPLAYCONNECTOR pInterface,
+                                                       uint32_t x, uint32_t y, uint32_t cx, uint32_t cy);
+    static DECLCALLBACK(void)  i_displayRefreshCallback(PPDMIDISPLAYCONNECTOR pInterface);
+    static DECLCALLBACK(void)  i_displayResetCallback(PPDMIDISPLAYCONNECTOR pInterface);
+    static DECLCALLBACK(void)  i_displayLFBModeChangeCallback(PPDMIDISPLAYCONNECTOR pInterface, bool fEnabled);
+    static DECLCALLBACK(void)  i_displayProcessAdapterDataCallback(PPDMIDISPLAYCONNECTOR pInterface,
+                                                                   void *pvVRAM, uint32_t u32VRAMSize);
+    static DECLCALLBACK(void)  i_displayProcessDisplayDataCallback(PPDMIDISPLAYCONNECTOR pInterface,
+                                                                   void *pvVRAM, unsigned uScreenId);
+
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    static DECLCALLBACK(int)  i_displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, int enmCmd, bool fGuestCmd,
+                                                          VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand);
+#endif
+    static DECLCALLBACK(int)  i_display3DNotifyProcess(PPDMIDISPLAYCONNECTOR pInterface,
+                                                       VBOX3DNOTIFY *p3DNotify);
+
+#ifdef VBOX_WITH_HGSMI
+    static DECLCALLBACK(int)   i_displayVBVAEnable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId,
+                                                   VBVAHOSTFLAGS RT_UNTRUSTED_VOLATILE_GUEST *pHostFlags);
+    static DECLCALLBACK(void)  i_displayVBVADisable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId);
+    static DECLCALLBACK(void)  i_displayVBVAUpdateBegin(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId);
+    static DECLCALLBACK(void)  i_displayVBVAUpdateProcess(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId,
+                                                          struct VBVACMDHDR const RT_UNTRUSTED_VOLATILE_GUEST *pCmd, size_t cbCmd);
+    static DECLCALLBACK(void)  i_displayVBVAUpdateEnd(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, int32_t x, int32_t y,
+                                                      uint32_t cx, uint32_t cy);
+    static DECLCALLBACK(int)   i_displayVBVAResize(PPDMIDISPLAYCONNECTOR pInterface, PCVBVAINFOVIEW pView,
+                                                   PCVBVAINFOSCREEN pScreen, void *pvVRAM,
+                                                   bool fResetInputMapping);
+    static DECLCALLBACK(int)   i_displayVBVAMousePointerShape(PPDMIDISPLAYCONNECTOR pInterface, bool fVisible, bool fAlpha,
+                                                              uint32_t xHot, uint32_t yHot, uint32_t cx, uint32_t cy,
+                                                              const void *pvShape);
+    static DECLCALLBACK(void)  i_displayVBVAGuestCapabilityUpdate(PPDMIDISPLAYCONNECTOR pInterface, uint32_t fCapabilities);
+
+    static DECLCALLBACK(void)  i_displayVBVAInputMappingUpdate(PPDMIDISPLAYCONNECTOR pInterface, int32_t xOrigin, int32_t yOrigin,
+                                                               uint32_t cx, uint32_t cy);
+    static DECLCALLBACK(void)  i_displayVBVAReportCursorPosition(PPDMIDISPLAYCONNECTOR pInterface, uint32_t fFlags, uint32_t uScreen, uint32_t x, uint32_t y);
+#endif
+
+    static DECLCALLBACK(int)  i_displaySSMSaveScreenshot(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser);
+    static DECLCALLBACK(int)  i_displaySSMLoadScreenshot(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser,
+                                                         uint32_t uVersion, uint32_t uPass);
+    static DECLCALLBACK(int)  i_displaySSMSave(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser);
+    static DECLCALLBACK(int)  i_displaySSMLoad(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, void *pvUser,
+                                               uint32_t uVersion, uint32_t uPass);
+
+    Console * const         mParent;
+    /** Pointer to the associated display driver. */
+    struct DRVMAINDISPLAY   *mpDrv;
+
+    unsigned mcMonitors;
+    /** Input mapping rectangle top left X relative to the first screen. */
+    int32_t     xInputMappingOrigin;
+    /** Input mapping rectangle top left Y relative to the first screen. */
+    int32_t     yInputMappingOrigin;
+    uint32_t    cxInputMapping;  /**< Input mapping rectangle width. */
+    uint32_t    cyInputMapping;  /**< Input mapping rectangle height. */
+    DISPLAYFBINFO maFramebuffers[SchemaDefs::MaxGuestMonitors];
+    /** Does the VMM device have the "supports graphics" capability set?
+     *  Does not go into the saved state as it is refreshed on restore. */
+    bool        mfVMMDevSupportsGraphics;
+    /** Mirror of the current guest VBVA capabilities. */
+    uint32_t    mfGuestVBVACapabilities;
+    /** Mirror of the current host cursor capabilities. */
+    uint32_t    mfHostCursorCapabilities;
+
+    bool mfSourceBitmapEnabled;
+    bool volatile fVGAResizing;
+
+    /** Are we in seamless mode?  Not saved, as we exit seamless on saving. */
+    bool        mfSeamlessEnabled;
+    /** Last set seamless visible region, number of rectangles. */
+    uint32_t    mcRectVisibleRegion;
+    /** Last set seamless visible region, data.  Freed on final clean-up. */
+    PRTRECT     mpRectVisibleRegion;
+
+    bool        mfVideoAccelVRDP;
+    uint32_t    mfu32SupportedOrders;
+    /** Number of currently connected VRDP clients. */
+    int32_t volatile mcVRDPRefs;
+
+    /* The legacy VBVA data and methods. */
+    VIDEOACCEL mVideoAccelLegacy;
+
+    int  i_VideoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory, PPDMIDISPLAYPORT pUpPort);
+    void i_VideoAccelFlush(PPDMIDISPLAYPORT pUpPort);
+    bool i_VideoAccelAllowed(void);
+
+    int  i_videoAccelRefreshProcess(PPDMIDISPLAYPORT pUpPort);
+    int  i_videoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory, PPDMIDISPLAYPORT pUpPort);
+    int  i_videoAccelFlush(PPDMIDISPLAYPORT pUpPort);
+
+    /* Legacy pre-HGSMI handlers. */
+    void processAdapterData(void *pvVRAM, uint32_t u32VRAMSize);
+    void processDisplayData(void *pvVRAM, unsigned uScreenId);
+
+    /** Serializes access to mVideoAccelLegacy and mfVideoAccelVRDP, etc between VRDP and Display. */
+    RTCRITSECT           mVideoAccelLock;
+
+#ifdef VBOX_WITH_RECORDING
+    /* Serializes access to video recording source bitmaps. */
+    RTCRITSECT           mVideoRecLock;
+    /** Array which defines which screens are being enabled for recording. */
+    bool                 maRecordingEnabled[SchemaDefs::MaxGuestMonitors];
+#endif
+
+public:
+
+    static DECLCALLBACK(int) i_displayTakeScreenshotEMT(Display *pDisplay, ULONG aScreenId, uint8_t **ppbData, size_t *pcbData,
+                                                        uint32_t *pcx, uint32_t *pcy, bool *pfMemFree);
+
+private:
+    static DECLCALLBACK(int) i_InvalidateAndUpdateEMT(Display *pDisplay, unsigned uId, bool fUpdateAll);
+    static DECLCALLBACK(int) i_drawToScreenEMT(Display *pDisplay, ULONG aScreenId, BYTE *address, ULONG x, ULONG y,
+                                               ULONG width, ULONG height);
+
+    void i_updateGuestGraphicsFacility(void);
+
+#ifdef VBOX_WITH_HGSMI
+    volatile uint32_t mu32UpdateVBVAFlags;
+#endif
+
+private:
+    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(Display); /* Shuts up MSC warning C4625. */
+};
+
+/* The legacy VBVA helpers. */
+int videoAccelConstruct(VIDEOACCEL *pVideoAccel);
+void videoAccelDestroy(VIDEOACCEL *pVideoAccel);
+void i_vbvaSetMemoryFlags(VBVAMEMORY *pVbvaMemory,
+                          bool fVideoAccelEnabled,
+                          bool fVideoAccelVRDP,
+                          uint32_t fu32SupportedOrders,
+                          DISPLAYFBINFO *paFBInfos,
+                          unsigned cFBInfos);
+int videoAccelEnterVGA(VIDEOACCEL *pVideoAccel);
+void videoAccelLeaveVGA(VIDEOACCEL *pVideoAccel);
+int videoAccelEnterVMMDev(VIDEOACCEL *pVideoAccel);
+void videoAccelLeaveVMMDev(VIDEOACCEL *pVideoAccel);
+
+
+/* helper function, code in DisplayResampleImage.cpp */
+void BitmapScale32(uint8_t *dst, int dstW, int dstH,
+                   const uint8_t *src, int iDeltaLine, int srcW, int srcH);
+
+/* helper function, code in DisplayPNGUtul.cpp */
+int DisplayMakePNG(uint8_t *pbData, uint32_t cx, uint32_t cy,
+                   uint8_t **ppu8PNG, uint32_t *pcbPNG, uint32_t *pcxPNG, uint32_t *pcyPNG,
+                     uint8_t fLimitSize);
+
+class ATL_NO_VTABLE DisplaySourceBitmap:
+    public DisplaySourceBitmapWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(DisplaySourceBitmap)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    /* Public initializer/uninitializer for internal purposes only. */
+    HRESULT init(ComObjPtr<Display> pDisplay, unsigned uScreenId, DISPLAYFBINFO *pFBInfo);
+    void uninit();
+
+    bool i_usesVRAM(void) { return m.pu8Allocated == NULL; }
+
+private:
+    // wrapped IDisplaySourceBitmap properties
+    virtual HRESULT getScreenId(ULONG *aScreenId);
+
+    // wrapped IDisplaySourceBitmap methods
+    virtual HRESULT queryBitmapInfo(BYTE **aAddress,
+                                    ULONG *aWidth,
+                                    ULONG *aHeight,
+                                    ULONG *aBitsPerPixel,
+                                    ULONG *aBytesPerLine,
+                                    BitmapFormat_T *aBitmapFormat);
+
+    int initSourceBitmap(unsigned aScreenId, DISPLAYFBINFO *pFBInfo);
+
+    struct Data
+    {
+        ComObjPtr<Display> pDisplay;
+        unsigned uScreenId;
+        DISPLAYFBINFO *pFBInfo;
+
+        uint8_t *pu8Allocated;
+
+        uint8_t *pu8Address;
+        ULONG ulWidth;
+        ULONG ulHeight;
+        ULONG ulBitsPerPixel;
+        ULONG ulBytesPerLine;
+        BitmapFormat_T bitmapFormat;
+    };
+
+    Data m;
+};
+
+class ATL_NO_VTABLE GuestScreenInfo:
+    public GuestScreenInfoWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(GuestScreenInfo)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    /* Public initializer/uninitializer for internal purposes only. */
+    HRESULT init(ULONG aDisplay,
+                 GuestMonitorStatus_T aGuestMonitorStatus,
+                 BOOL aPrimary,
+                 BOOL aChangeOrigin,
+                 LONG aOriginX,
+                 LONG aOriginY,
+                 ULONG aWidth,
+                 ULONG aHeight,
+                 ULONG aBitsPerPixel);
+    void uninit();
+
+private:
+    // wrapped IGuestScreenInfo properties
+    virtual HRESULT getScreenId(ULONG *aScreenId);
+    virtual HRESULT getGuestMonitorStatus(GuestMonitorStatus_T *aGuestMonitorStatus);
+    virtual HRESULT getPrimary(BOOL *aPrimary);
+    virtual HRESULT getOrigin(BOOL *aOrigin);
+    virtual HRESULT getOriginX(LONG *aOriginX);
+    virtual HRESULT getOriginY(LONG *aOriginY);
+    virtual HRESULT getWidth(ULONG *aWidth);
+    virtual HRESULT getHeight(ULONG *aHeight);
+    virtual HRESULT getBitsPerPixel(ULONG *aBitsPerPixel);
+    virtual HRESULT getExtendedInfo(com::Utf8Str &aExtendedInfo);
+
+    ULONG mScreenId;
+    GuestMonitorStatus_T mGuestMonitorStatus;
+    BOOL  mPrimary;
+    BOOL  mOrigin;
+    LONG  mOriginX;
+    LONG  mOriginY;
+    ULONG mWidth;
+    ULONG mHeight;
+    ULONG mBitsPerPixel;
+};
+
+#endif /* !MAIN_INCLUDED_DisplayImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/DisplayUtils.h b/src/VBox/Main/include/DisplayUtils.h
new file mode 100644
index 00000000..90a6f1e8
--- /dev/null
+++ b/src/VBox/Main/include/DisplayUtils.h
@@ -0,0 +1,57 @@
+/* $Id: DisplayUtils.h $ */
+/** @file
+ * Display helper declarations
+ */
+
+/*
+ * Copyright (C) 2010-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
+ */
+
+#ifndef MAIN_INCLUDED_DisplayUtils_h
+#define MAIN_INCLUDED_DisplayUtils_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "VBox/com/string.h"
+
+#include "CryptoUtils.h"
+
+using namespace com;
+
+#define sSSMDisplayScreenshotVer 0x00010001
+#define sSSMDisplayVer 0x00010001
+#define sSSMDisplayVer2 0x00010002
+#define sSSMDisplayVer3 0x00010003
+#define sSSMDisplayVer4 0x00010004
+#define sSSMDisplayVer5 0x00010005
+
+int readSavedGuestScreenInfo(SsmStream &ssmStream, const Utf8Str &strStateFilePath,
+                             uint32_t u32ScreenId, uint32_t *pu32OriginX, uint32_t *pu32OriginY,
+                             uint32_t *pu32Width, uint32_t *pu32Height, uint16_t *pu16Flags);
+
+int readSavedDisplayScreenshot(SsmStream &ssmStream, const Utf8Str &strStateFilePath,
+                               uint32_t u32Type, uint8_t **ppu8Data, uint32_t *pcbData,
+                               uint32_t *pu32Width, uint32_t *pu32Height);
+void freeSavedDisplayScreenshot(uint8_t *pu8Data);
+
+#endif /* !MAIN_INCLUDED_DisplayUtils_h */
+
diff --git a/src/VBox/Main/include/DrvAudioRec.h b/src/VBox/Main/include/DrvAudioRec.h
new file mode 100644
index 00000000..a5d5c5fd
--- /dev/null
+++ b/src/VBox/Main/include/DrvAudioRec.h
@@ -0,0 +1,79 @@
+/* $Id: DrvAudioRec.h $ */
+/** @file
+ * VirtualBox driver interface video recording audio backend.
+ */
+
+/*
+ * Copyright (C) 2017-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
+ */
+
+#ifndef MAIN_INCLUDED_DrvAudioRec_h
+#define MAIN_INCLUDED_DrvAudioRec_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/com/ptr.h>
+#include <VBox/settings.h>
+#include <VBox/vmm/pdmdrv.h>
+#include <VBox/vmm/pdmifs.h>
+
+#include "AudioDriver.h"
+#include "Recording.h"
+
+using namespace com;
+
+class Console;
+
+class AudioVideoRec : public AudioDriver
+{
+
+public:
+
+    AudioVideoRec(Console *pConsole);
+    virtual ~AudioVideoRec(void);
+
+public:
+
+    static const PDMDRVREG DrvReg;
+
+public:
+
+    int applyConfiguration(const settings::RecordingSettings &Settings);
+
+public:
+
+    static DECLCALLBACK(int)  drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
+    static DECLCALLBACK(void) drvDestruct(PPDMDRVINS pDrvIns);
+    static DECLCALLBACK(void) drvPowerOff(PPDMDRVINS pDrvIns);
+
+private:
+
+    virtual int configureDriver(PCFGMNODE pLunCfg, PCVMMR3VTABLE pVMM) RT_OVERRIDE;
+
+    /** Pointer to the associated video recording audio driver. */
+    struct DRVAUDIORECORDING          *mpDrv;
+    /** Recording settings used for configuring the driver. */
+    struct settings::RecordingSettings mSettings;
+};
+
+#endif /* !MAIN_INCLUDED_DrvAudioRec_h */
+
diff --git a/src/VBox/Main/include/DrvAudioVRDE.h b/src/VBox/Main/include/DrvAudioVRDE.h
new file mode 100644
index 00000000..c070c7cf
--- /dev/null
+++ b/src/VBox/Main/include/DrvAudioVRDE.h
@@ -0,0 +1,87 @@
+/* $Id: DrvAudioVRDE.h $ */
+/** @file
+ * VirtualBox driver interface to VRDE backend.
+ */
+
+/*
+ * Copyright (C) 2014-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
+ */
+
+#ifndef MAIN_INCLUDED_DrvAudioVRDE_h
+#define MAIN_INCLUDED_DrvAudioVRDE_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/com/ptr.h>
+#include <VBox/com/string.h>
+
+#include <VBox/RemoteDesktop/VRDE.h>
+
+#include <VBox/vmm/pdmdrv.h>
+#include <VBox/vmm/pdmifs.h>
+
+#include "AudioDriver.h"
+
+using namespace com;
+
+class Console;
+
+class AudioVRDE : public AudioDriver
+{
+
+public:
+
+    AudioVRDE(Console *pConsole);
+    virtual ~AudioVRDE(void);
+
+public:
+
+    static const PDMDRVREG DrvReg;
+
+public:
+
+    void onVRDEClientConnect(uint32_t uClientID);
+    void onVRDEClientDisconnect(uint32_t uClientID);
+    int onVRDEControl(bool fEnable, uint32_t uFlags);
+    int onVRDEInputBegin(void *pvContext, PVRDEAUDIOINBEGIN pVRDEAudioBegin);
+    int onVRDEInputData(void *pvContext, const void *pvData, uint32_t cbData);
+    int onVRDEInputEnd(void *pvContext);
+    int onVRDEInputIntercept(bool fIntercept);
+
+public:
+
+    static DECLCALLBACK(int) drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
+    static DECLCALLBACK(void) drvDestruct(PPDMDRVINS pDrvIns);
+    static DECLCALLBACK(void) drvPowerOff(PPDMDRVINS pDrvIns);
+
+private:
+
+    virtual int configureDriver(PCFGMNODE pLunCfg, PCVMMR3VTABLE pVMM) RT_OVERRIDE;
+
+    /** Pointer to the associated VRDE audio driver. */
+    struct DRVAUDIOVRDE *mpDrv;
+    /** Protects accesses to mpDrv from racing driver destruction. */
+    RTCRITSECT mCritSect;
+};
+
+#endif /* !MAIN_INCLUDED_DrvAudioVRDE_h */
+
diff --git a/src/VBox/Main/include/EBMLWriter.h b/src/VBox/Main/include/EBMLWriter.h
new file mode 100644
index 00000000..eda3f4b1
--- /dev/null
+++ b/src/VBox/Main/include/EBMLWriter.h
@@ -0,0 +1,135 @@
+/* $Id: EBMLWriter.h $ */
+/** @file
+ * EBMLWriter.h - EBML writer.
+ */
+
+/*
+ * Copyright (C) 2013-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
+ */
+
+#ifndef MAIN_INCLUDED_EBMLWriter_h
+#define MAIN_INCLUDED_EBMLWriter_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <stack>
+
+#include <iprt/critsect.h>
+#include <iprt/file.h>
+
+#include <VBox/com/string.h>
+
+
+/** No flags set. */
+#define VBOX_EBMLWRITER_FLAG_NONE               0
+/** The file handle was inherited. */
+#define VBOX_EBMLWRITER_FLAG_HANDLE_INHERITED   RT_BIT(0)
+
+class EBMLWriter
+{
+public:
+    typedef uint32_t EbmlClassId;
+
+private:
+
+    struct EbmlSubElement
+    {
+        uint64_t offset;
+        EbmlClassId classId;
+        EbmlSubElement(uint64_t offs, EbmlClassId cid) : offset(offs), classId(cid) {}
+    };
+
+    /** Stack of EBML sub elements. */
+    std::stack<EbmlSubElement> m_Elements;
+    /** The file's handle. */
+    RTFILE                     m_hFile;
+    /** The file's name (path). */
+    com::Utf8Str               m_strFile;
+    /** Flags. */
+    uint32_t                   m_fFlags;
+
+public:
+
+    EBMLWriter(void)
+        : m_hFile(NIL_RTFILE)
+        , m_fFlags(VBOX_EBMLWRITER_FLAG_NONE) { }
+
+    virtual ~EBMLWriter(void) { close(); }
+
+public:
+
+    int createEx(const char *a_pszFile, PRTFILE phFile);
+
+    int create(const char *a_pszFile, uint64_t fOpen);
+
+    void close(void);
+
+    /** Returns the file name. */
+    const com::Utf8Str& getFileName(void) { return m_strFile; }
+
+    /** Returns file size. */
+    uint64_t getFileSize(void) { return RTFileTell(m_hFile); }
+
+    /** Get reference to file descriptor */
+    inline const RTFILE &getFile(void) { return m_hFile; }
+
+    /** Returns available space on storage. */
+    uint64_t getAvailableSpace(void);
+
+    /**
+     * Returns whether the file is open or not.
+     *
+     * @returns True if open, false if not.
+     */
+    bool isOpen(void) { return RTFileIsValid(m_hFile); }
+
+public:
+
+    EBMLWriter &subStart(EbmlClassId classId);
+
+    EBMLWriter &subEnd(EbmlClassId classId);
+
+    EBMLWriter &serializeString(EbmlClassId classId, const char *str);
+
+    EBMLWriter &serializeUnsignedInteger(EbmlClassId classId, uint64_t parm, size_t size = 0);
+
+    EBMLWriter &serializeFloat(EbmlClassId classId, float value);
+
+    EBMLWriter &serializeData(EbmlClassId classId, const void *pvData, size_t cbData);
+
+    int write(const void *data, size_t size);
+
+    void writeUnsignedInteger(uint64_t value, size_t size = sizeof(uint64_t));
+
+    void writeClassId(EbmlClassId parm);
+
+    void writeSize(uint64_t parm);
+
+    static inline size_t getSizeOfUInt(uint64_t arg);
+
+private:
+
+    void operator=(const EBMLWriter &);
+};
+
+#endif /* !MAIN_INCLUDED_EBMLWriter_h */
+
diff --git a/src/VBox/Main/include/EBML_MKV.h b/src/VBox/Main/include/EBML_MKV.h
new file mode 100644
index 00000000..75d87c0d
--- /dev/null
+++ b/src/VBox/Main/include/EBML_MKV.h
@@ -0,0 +1,106 @@
+/* $Id: EBML_MKV.h $ */
+/** @file
+ * EbmlMkvIDs.h - Matroska EBML Class IDs.
+ */
+
+/*
+ * Copyright (C) 2017-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
+ */
+
+#ifndef MAIN_INCLUDED_EBML_MKV_h
+#define MAIN_INCLUDED_EBML_MKV_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+
+/** Matroska EBML Class IDs supported by WebM.
+ *
+ *  Keep the structure clean and group elements where it makes sense
+ *  for easier reading / lookup. */
+enum MkvElem
+{
+    MkvElem_EBML                    = 0x1A45DFA3,
+    MkvElem_EBMLVersion             = 0x4286,
+    MkvElem_EBMLReadVersion         = 0x42F7,
+    MkvElem_EBMLMaxIDLength         = 0x42F2,
+    MkvElem_EBMLMaxSizeLength       = 0x42F3,
+
+    MkvElem_DocType                 = 0x4282,
+    MkvElem_DocTypeVersion          = 0x4287,
+    MkvElem_DocTypeReadVersion      = 0x4285,
+
+    MkvElem_Segment                 = 0x18538067,
+    MkvElem_Segment_Duration        = 0x4489,
+
+    MkvElem_SeekHead                = 0x114D9B74,
+    MkvElem_Seek                    = 0x4DBB,
+    MkvElem_SeekID                  = 0x53AB,
+    MkvElem_SeekPosition            = 0x53AC,
+
+    MkvElem_Info                    = 0x1549A966,
+    MkvElem_TimecodeScale           = 0x2AD7B1,
+    MkvElem_MuxingApp               = 0x4D80,
+    MkvElem_WritingApp              = 0x5741,
+
+    MkvElem_Tracks                  = 0x1654AE6B,
+    MkvElem_TrackEntry              = 0xAE,
+    MkvElem_TrackNumber             = 0xD7,
+    MkvElem_TrackUID                = 0x73C5,
+    MkvElem_TrackType               = 0x83,
+
+    MkvElem_Language                = 0x22B59C,
+
+    MkvElem_FlagLacing              = 0x9C,
+
+    MkvElem_Cluster                 = 0x1F43B675,
+    MkvElem_Timecode                = 0xE7,
+
+    MkvElem_SimpleBlock             = 0xA3,
+
+    MkvElem_SeekPreRoll             = 0x56BB,
+
+    MkvElem_CodecID                 = 0x86,
+    MkvElem_CodecDelay              = 0x56AA,
+    MkvElem_CodecPrivate            = 0x63A2,
+    MkvElem_CodecName               = 0x258688,
+
+    MkvElem_Video                   = 0xE0,
+    MkvElem_PixelWidth              = 0xB0,
+    MkvElem_PixelHeight             = 0xBA,
+    MkvElem_FrameRate               = 0x2383E3,
+
+    MkvElem_Audio                   = 0xE1,
+    MkvElem_SamplingFrequency       = 0xB5,
+    MkvElem_OutputSamplingFrequency = 0x78B5,
+    MkvElem_Channels                = 0x9F,
+    MkvElem_BitDepth                = 0x6264,
+
+    MkvElem_Cues                    = 0x1C53BB6B,
+    MkvElem_CuePoint                = 0xBB,
+    MkvElem_CueTime                 = 0xB3,
+    MkvElem_CueTrackPositions       = 0xB7,
+    MkvElem_CueTrack                = 0xF7,
+    MkvElem_CueClusterPosition      = 0xF1
+};
+
+#endif /* !MAIN_INCLUDED_EBML_MKV_h */
+
diff --git a/src/VBox/Main/include/EmulatedUSBImpl.h b/src/VBox/Main/include/EmulatedUSBImpl.h
new file mode 100644
index 00000000..7e1ae3e7
--- /dev/null
+++ b/src/VBox/Main/include/EmulatedUSBImpl.h
@@ -0,0 +1,103 @@
+/* $Id: EmulatedUSBImpl.h $ */
+/** @file
+ * Emulated USB devices manager.
+ */
+
+/*
+ * Copyright (C) 2013-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
+ */
+
+#ifndef MAIN_INCLUDED_EmulatedUSBImpl_h
+#define MAIN_INCLUDED_EmulatedUSBImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "EmulatedUSBWrap.h"
+
+#include <VBox/vrdpusb.h>
+
+class Console;
+class EUSBWEBCAM;
+
+typedef std::map<Utf8Str, EUSBWEBCAM *> WebcamsMap;
+
+class ATL_NO_VTABLE EmulatedUSB :
+    public EmulatedUSBWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(EmulatedUSB)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    /* Public initializer/uninitializer for internal purposes only. */
+    HRESULT init(ComObjPtr<Console> pConsole);
+    void uninit();
+
+    /* Public method for internal use. */
+    static DECLCALLBACK(int) i_eusbCallback(void *pv, const char *pszId, uint32_t iEvent,
+                                            const void *pvData, uint32_t cbData);
+
+    PEMULATEDUSBIF i_getEmulatedUsbIf();
+
+    HRESULT i_webcamAttachInternal(const com::Utf8Str &aPath,
+                                   const com::Utf8Str &aSettings,
+                                   const char *pszDriver,
+                                   void *pvObject);
+    HRESULT i_webcamDetachInternal(const com::Utf8Str &aPath);
+
+private:
+
+    static DECLCALLBACK(int) eusbCallbackEMT(EmulatedUSB *pThis, char *pszId, uint32_t iEvent,
+                                             void *pvData, uint32_t cbData);
+
+    static DECLCALLBACK(int) i_QueryEmulatedUsbDataById(void *pvUser, const char *pszId, void **ppvEmUsbCb, void **ppvEmUsbCbData, void **ppvObject);
+
+    HRESULT webcamPathFromId(com::Utf8Str *pPath, const char *pszId);
+
+    // wrapped IEmulatedUSB properties
+    virtual HRESULT getWebcams(std::vector<com::Utf8Str> &aWebcams);
+
+    // wrapped IEmulatedUSB methods
+    virtual HRESULT webcamAttach(const com::Utf8Str &aPath,
+                                 const com::Utf8Str &aSettings);
+    virtual HRESULT webcamDetach(const com::Utf8Str &aPath);
+
+    /* Data. */
+    struct Data
+    {
+        Data()
+        {
+        }
+
+        ComObjPtr<Console> pConsole;
+        WebcamsMap webcams;
+    };
+
+    Data m;
+    EMULATEDUSBIF mEmUsbIf;
+};
+
+#endif /* !MAIN_INCLUDED_EmulatedUSBImpl_h */
+
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/EventImpl.h b/src/VBox/Main/include/EventImpl.h
new file mode 100644
index 00000000..ee196402
--- /dev/null
+++ b/src/VBox/Main/include/EventImpl.h
@@ -0,0 +1,188 @@
+/* $Id: EventImpl.h $ */
+/** @file
+ * VirtualBox COM IEvent implementation
+ */
+
+/*
+ * Copyright (C) 2010-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
+ */
+
+#ifndef MAIN_INCLUDED_EventImpl_h
+#define MAIN_INCLUDED_EventImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "EventWrap.h"
+#include "EventSourceWrap.h"
+#include "VetoEventWrap.h"
+
+
+class ATL_NO_VTABLE VBoxEvent
+    : public EventWrap
+{
+public:
+    DECLARE_COMMON_CLASS_METHODS(VBoxEvent)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(IEventSource *aSource, VBoxEventType_T aType, BOOL aWaitable);
+    void uninit();
+
+private:
+    // wrapped IEvent properties
+    HRESULT getType(VBoxEventType_T *aType);
+    HRESULT getSource(ComPtr<IEventSource> &aSource);
+    HRESULT getWaitable(BOOL *aWaitable);
+
+    // wrapped IEvent methods
+    HRESULT setProcessed();
+    HRESULT waitProcessed(LONG aTimeout, BOOL *aResult);
+
+    struct Data;
+    Data* m;
+};
+
+
+class ATL_NO_VTABLE VBoxVetoEvent
+    : public VetoEventWrap
+{
+public:
+    DECLARE_COMMON_CLASS_METHODS(VBoxVetoEvent)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(IEventSource *aSource, VBoxEventType_T aType);
+    void uninit();
+
+private:
+    // wrapped IEvent properties
+    HRESULT getType(VBoxEventType_T *aType);
+    HRESULT getSource(ComPtr<IEventSource> &aSource);
+    HRESULT getWaitable(BOOL *aWaitable);
+
+    // wrapped IEvent methods
+    HRESULT setProcessed();
+    HRESULT waitProcessed(LONG aTimeout, BOOL *aResult);
+
+    // wrapped IVetoEvent methods
+    HRESULT addVeto(const com::Utf8Str &aReason);
+    HRESULT isVetoed(BOOL *aResult);
+    HRESULT getVetos(std::vector<com::Utf8Str> &aResult);
+    HRESULT addApproval(const com::Utf8Str &aReason);
+    HRESULT isApproved(BOOL *aResult);
+    HRESULT getApprovals(std::vector<com::Utf8Str> &aResult);
+
+    struct Data;
+    Data* m;
+};
+
+class ATL_NO_VTABLE EventSource :
+    public EventSourceWrap
+{
+public:
+    DECLARE_COMMON_CLASS_METHODS(EventSource)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init();
+    void uninit();
+
+private:
+    // wrapped IEventSource methods
+    HRESULT createListener(ComPtr<IEventListener> &aListener);
+    HRESULT createAggregator(const std::vector<ComPtr<IEventSource> > &aSubordinates,
+                             ComPtr<IEventSource> &aResult);
+    HRESULT registerListener(const ComPtr<IEventListener> &aListener,
+                             const std::vector<VBoxEventType_T> &aInteresting,
+                             BOOL aActive);
+    HRESULT unregisterListener(const ComPtr<IEventListener> &aListener);
+    HRESULT fireEvent(const ComPtr<IEvent> &aEvent,
+                      LONG aTimeout,
+                      BOOL *aResult);
+    HRESULT getEvent(const ComPtr<IEventListener> &aListener,
+                     LONG aTimeout,
+                     ComPtr<IEvent> &aEvent);
+    HRESULT eventProcessed(const ComPtr<IEventListener> &aListener,
+                           const ComPtr<IEvent> &aEvent);
+
+
+    struct Data;
+    Data *m;
+
+    friend class ListenerRecord;
+};
+
+class VBoxEventDesc
+{
+public:
+    VBoxEventDesc() : mEvent(0), mEventSource(0)
+    {}
+
+    VBoxEventDesc(IEvent *aEvent, IEventSource *aSource)
+        : mEvent(aEvent), mEventSource(aSource)
+    {}
+
+    ~VBoxEventDesc()
+    {}
+
+    void init(IEvent *aEvent, IEventSource *aSource)
+    {
+        mEvent       = aEvent;
+        mEventSource = aSource;
+    }
+
+    void uninit()
+    {
+        mEvent.setNull();
+        mEventSource.setNull();
+    }
+
+    void getEvent(IEvent **aEvent)
+    {
+        mEvent.queryInterfaceTo(aEvent);
+    }
+
+    BOOL fire(LONG aTimeout)
+    {
+        if (mEventSource && mEvent)
+        {
+            BOOL fDelivered = FALSE;
+            HRESULT hrc = mEventSource->FireEvent(mEvent, aTimeout, &fDelivered);
+            AssertComRCReturn(hrc, FALSE);
+            return fDelivered;
+        }
+        return FALSE;
+    }
+
+private:
+    ComPtr<IEvent>          mEvent;
+    ComPtr<IEventSource>    mEventSource;
+};
+
+
+#endif /* !MAIN_INCLUDED_EventImpl_h */
diff --git a/src/VBox/Main/include/ExtPackManagerImpl.h b/src/VBox/Main/include/ExtPackManagerImpl.h
new file mode 100644
index 00000000..9fde4043
--- /dev/null
+++ b/src/VBox/Main/include/ExtPackManagerImpl.h
@@ -0,0 +1,322 @@
+/* $Id: ExtPackManagerImpl.h $ */
+/** @file
+ * VirtualBox Main - interface for Extension Packs, VBoxSVC & VBoxC.
+ */
+
+/*
+ * Copyright (C) 2010-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
+ */
+
+#ifndef MAIN_INCLUDED_ExtPackManagerImpl_h
+#define MAIN_INCLUDED_ExtPackManagerImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "VirtualBoxBase.h"
+#include <VBox/ExtPack/ExtPack.h>
+#include "ExtPackWrap.h"
+#include "ExtPackFileWrap.h"
+#include "ExtPackManagerWrap.h"
+#include <iprt/fs.h>
+
+
+/** The name of the oracle extension back. */
+#define ORACLE_PUEL_EXTPACK_NAME "Oracle VM VirtualBox Extension Pack"
+
+
+#ifndef VBOX_COM_INPROC
+/**
+ * An extension pack file.
+ */
+class ATL_NO_VTABLE ExtPackFile :
+    public ExtPackFileWrap
+{
+public:
+    /** @name COM and internal init/term/mapping cruft.
+     * @{ */
+    DECLARE_COMMON_CLASS_METHODS(ExtPackFile)
+
+    HRESULT     FinalConstruct();
+    void        FinalRelease();
+    HRESULT     initWithFile(const char *a_pszFile, const char *a_pszDigest, class ExtPackManager *a_pExtPackMgr, VirtualBox *a_pVirtualBox);
+    void        uninit();
+    /** @}  */
+
+private:
+    /** @name Misc init helpers
+     * @{ */
+    HRESULT     initFailed(const char *a_pszWhyFmt, ...);
+    /** @} */
+
+private:
+
+    // wrapped IExtPackFile properties
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT getDescription(com::Utf8Str &aDescription);
+    HRESULT getVersion(com::Utf8Str &aVersion);
+    HRESULT getRevision(ULONG *aRevision);
+    HRESULT getEdition(com::Utf8Str &aEdition);
+    HRESULT getVRDEModule(com::Utf8Str &aVRDEModule);
+    HRESULT getCryptoModule(com::Utf8Str &aCryptoModule);
+    HRESULT getPlugIns(std::vector<ComPtr<IExtPackPlugIn> > &aPlugIns);
+    HRESULT getUsable(BOOL *aUsable);
+    HRESULT getWhyUnusable(com::Utf8Str &aWhyUnusable);
+    HRESULT getShowLicense(BOOL *aShowLicense);
+    HRESULT getLicense(com::Utf8Str &aLicense);
+    HRESULT getFilePath(com::Utf8Str &aFilePath);
+
+    // wrapped IExtPackFile methods
+    HRESULT queryLicense(const com::Utf8Str &aPreferredLocale,
+                         const com::Utf8Str &aPreferredLanguage,
+                         const com::Utf8Str &aFormat,
+                         com::Utf8Str &aLicenseText);
+    HRESULT install(BOOL aReplace,
+                    const com::Utf8Str &aDisplayInfo,
+                    ComPtr<IProgress> &aProgess);
+
+    struct Data;
+    /** Pointer to the private instance. */
+    Data *m;
+
+    friend class ExtPackManager;
+    friend class ExtPackInstallTask;
+};
+#endif /* !VBOX_COM_INPROC */
+
+
+/**
+ * An installed extension pack.
+ */
+class ATL_NO_VTABLE ExtPack :
+    public ExtPackWrap
+{
+public:
+    /** @name COM and internal init/term/mapping cruft.
+     * @{ */
+    DECLARE_COMMON_CLASS_METHODS(ExtPack)
+
+    HRESULT     FinalConstruct();
+    void        FinalRelease();
+    HRESULT     initWithDir(VirtualBox *a_pVirtualBox, VBOXEXTPACKCTX a_enmContext, const char *a_pszName, const char *a_pszDir);
+    void        uninit();
+    RTMEMEF_NEW_AND_DELETE_OPERATORS();
+    /** @}  */
+
+    /** @name Internal interfaces used by ExtPackManager.
+     * @{ */
+#ifndef VBOX_COM_INPROC
+    bool        i_callInstalledHook(IVirtualBox *a_pVirtualBox, AutoWriteLock *a_pLock, PRTERRINFO pErrInfo);
+    HRESULT     i_callUninstallHookAndClose(IVirtualBox *a_pVirtualBox, bool a_fForcedRemoval);
+    bool        i_callVirtualBoxReadyHook(IVirtualBox *a_pVirtualBox, AutoWriteLock *a_pLock);
+#endif
+#ifdef VBOX_COM_INPROC
+    bool        i_callConsoleReadyHook(IConsole *a_pConsole, AutoWriteLock *a_pLock);
+#endif
+#ifndef VBOX_COM_INPROC
+    bool        i_callVmCreatedHook(IVirtualBox *a_pVirtualBox, IMachine *a_pMachine, AutoWriteLock *a_pLock);
+#endif
+#ifdef VBOX_COM_INPROC
+    bool        i_callVmConfigureVmmHook(IConsole *a_pConsole, PVM a_pVM, PCVMMR3VTABLE a_pVMM,
+                                         AutoWriteLock *a_pLock, int *a_pvrc);
+    bool        i_callVmPowerOnHook(IConsole *a_pConsole, PVM a_pVM, PCVMMR3VTABLE a_pVMM, AutoWriteLock *a_pLock, int *a_pvrc);
+    bool        i_callVmPowerOffHook(IConsole *a_pConsole, PVM a_pVM, PCVMMR3VTABLE a_pVMM, AutoWriteLock *a_pLock);
+#endif
+    HRESULT     i_checkVrde(void);
+    HRESULT     i_checkCrypto(void);
+    HRESULT     i_getVrdpLibraryName(Utf8Str *a_pstrVrdeLibrary);
+    HRESULT     i_getCryptoLibraryName(Utf8Str *a_pstrCryptoLibrary);
+    HRESULT     i_getLibraryName(const char *a_pszModuleName, Utf8Str *a_pstrLibrary);
+    bool        i_wantsToBeDefaultVrde(void) const;
+    bool        i_wantsToBeDefaultCrypto(void) const;
+    HRESULT     i_refresh(bool *pfCanDelete);
+#ifndef VBOX_COM_INPROC
+    bool        i_areThereCloudProviderUninstallVetos();
+    void        i_notifyCloudProviderManager();
+#endif
+    /** @}  */
+
+protected:
+    /** @name Internal helper methods.
+     * @{ */
+    void        i_probeAndLoad(void);
+    bool        i_findModule(const char *a_pszName, const char *a_pszExt, VBOXEXTPACKMODKIND a_enmKind,
+                             Utf8Str *a_ppStrFound, bool *a_pfNative, PRTFSOBJINFO a_pObjInfo) const;
+    static bool i_objinfoIsEqual(PCRTFSOBJINFO pObjInfo1, PCRTFSOBJINFO pObjInfo2);
+    /** @}  */
+
+    /** @name Extension Pack Helpers
+     * @{ */
+    static DECLCALLBACK(int)    i_hlpFindModule(PCVBOXEXTPACKHLP pHlp, const char *pszName, const char *pszExt,
+                                                VBOXEXTPACKMODKIND enmKind, char *pszFound, size_t cbFound, bool *pfNative);
+    static DECLCALLBACK(int)    i_hlpGetFilePath(PCVBOXEXTPACKHLP pHlp, const char *pszFilename, char *pszPath, size_t cbPath);
+    static DECLCALLBACK(VBOXEXTPACKCTX) i_hlpGetContext(PCVBOXEXTPACKHLP pHlp);
+    static DECLCALLBACK(int)    i_hlpLoadHGCMService(PCVBOXEXTPACKHLP pHlp, VBOXEXTPACK_IF_CS(IConsole) *pConsole, const char *pszServiceLibrary, const char *pszServiceName);
+    static DECLCALLBACK(int)    i_hlpLoadVDPlugin(PCVBOXEXTPACKHLP pHlp, VBOXEXTPACK_IF_CS(IVirtualBox) *pVirtualBox, const char *pszPluginLibrary);
+    static DECLCALLBACK(int)    i_hlpUnloadVDPlugin(PCVBOXEXTPACKHLP pHlp, VBOXEXTPACK_IF_CS(IVirtualBox) *pVirtualBox, const char *pszPluginLibrary);
+    static DECLCALLBACK(uint32_t) i_hlpCreateProgress(PCVBOXEXTPACKHLP pHlp, VBOXEXTPACK_IF_CS(IUnknown) *pInitiator,
+                                                      const char *pcszDescription, uint32_t cOperations,
+                                                      uint32_t uTotalOperationsWeight, const char *pcszFirstOperationDescription,
+                                                      uint32_t uFirstOperationWeight, VBOXEXTPACK_IF_CS(IProgress) **ppProgressOut);
+    static DECLCALLBACK(uint32_t) i_hlpGetCanceledProgress(PCVBOXEXTPACKHLP pHlp, VBOXEXTPACK_IF_CS(IProgress) *pProgress,
+                                                           bool *pfCanceled);
+    static DECLCALLBACK(uint32_t) i_hlpUpdateProgress(PCVBOXEXTPACKHLP pHlp, VBOXEXTPACK_IF_CS(IProgress) *pProgress,
+                                                      uint32_t uPercent);
+    static DECLCALLBACK(uint32_t) i_hlpNextOperationProgress(PCVBOXEXTPACKHLP pHlp, VBOXEXTPACK_IF_CS(IProgress) *pProgress,
+                                                             const char *pcszNextOperationDescription,
+                                                             uint32_t uNextOperationWeight);
+    static DECLCALLBACK(uint32_t) i_hlpWaitOtherProgress(PCVBOXEXTPACKHLP pHlp, VBOXEXTPACK_IF_CS(IProgress) *pProgress,
+                                                         VBOXEXTPACK_IF_CS(IProgress) *pProgressOther,
+                                                         uint32_t cTimeoutMS);
+    static DECLCALLBACK(uint32_t) i_hlpCompleteProgress(PCVBOXEXTPACKHLP pHlp, VBOXEXTPACK_IF_CS(IProgress) *pProgress,
+                                                        uint32_t uResultCode);
+    static DECLCALLBACK(uint32_t) i_hlpCreateEvent(PCVBOXEXTPACKHLP pHlp,
+                                                   VBOXEXTPACK_IF_CS(IEventSource) *aSource,
+                                                   /* VBoxEventType_T */ uint32_t aType, bool aWaitable,
+                                                   VBOXEXTPACK_IF_CS(IEvent) **ppEventOut);
+    static DECLCALLBACK(uint32_t) i_hlpCreateVetoEvent(PCVBOXEXTPACKHLP pHlp,
+                                                       VBOXEXTPACK_IF_CS(IEventSource) *aSource,
+                                                       /* VBoxEventType_T */ uint32_t aType,
+                                                       VBOXEXTPACK_IF_CS(IVetoEvent) **ppEventOut);
+    static DECLCALLBACK(const char *) i_hlpTranslate(PCVBOXEXTPACKHLP pHlp,
+                                                     const char  *pszComponent,
+                                                     const char  *pszSourceText,
+                                                     const char  *pszComment = NULL,
+                                                     const size_t aNum = ~(size_t)0);
+    static DECLCALLBACK(int)      i_hlpReservedN(PCVBOXEXTPACKHLP pHlp);
+    /** @}  */
+
+private:
+
+    // wrapped IExtPack properties
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT getDescription(com::Utf8Str &aDescription);
+    HRESULT getVersion(com::Utf8Str &aVersion);
+    HRESULT getRevision(ULONG *aRevision);
+    HRESULT getEdition(com::Utf8Str &aEdition);
+    HRESULT getVRDEModule(com::Utf8Str &aVRDEModule);
+    HRESULT getCryptoModule(com::Utf8Str &aCryptoModule);
+    HRESULT getPlugIns(std::vector<ComPtr<IExtPackPlugIn> > &aPlugIns);
+    HRESULT getUsable(BOOL *aUsable);
+    HRESULT getWhyUnusable(com::Utf8Str &aWhyUnusable);
+    HRESULT getShowLicense(BOOL *aShowLicense);
+    HRESULT getLicense(com::Utf8Str &aLicense);
+
+    // wrapped IExtPack methods
+    HRESULT queryLicense(const com::Utf8Str &aPreferredLocale,
+                         const com::Utf8Str &aPreferredLanguage,
+                         const com::Utf8Str &aFormat,
+                         com::Utf8Str &aLicenseText);
+    HRESULT queryObject(const com::Utf8Str &aObjUuid,
+                        ComPtr<IUnknown> &aReturnInterface);
+
+
+    struct Data;
+    /** Pointer to the private instance. */
+    Data *m;
+
+    friend class ExtPackManager;
+};
+
+
+/**
+ * Extension pack manager.
+ */
+class ATL_NO_VTABLE ExtPackManager :
+    public ExtPackManagerWrap
+{
+public:
+    /** @name COM and internal init/term/mapping cruft.
+     * @{ */
+    DECLARE_COMMON_CLASS_METHODS(ExtPackManager)
+
+    HRESULT     FinalConstruct();
+    void        FinalRelease();
+    HRESULT     initExtPackManager(VirtualBox *a_pVirtualBox, VBOXEXTPACKCTX a_enmContext);
+    void        uninit();
+    /** @}  */
+
+    /** @name Internal interfaces used by other Main classes.
+     * @{ */
+#ifndef VBOX_COM_INPROC
+    HRESULT     i_doInstall(ExtPackFile *a_pExtPackFile, bool a_fReplace, Utf8Str const *a_pstrDisplayInfo);
+    HRESULT     i_doUninstall(const Utf8Str *a_pstrName, bool a_fForcedRemoval, const Utf8Str *a_pstrDisplayInfo);
+    void        i_callAllVirtualBoxReadyHooks(void);
+    HRESULT     i_queryObjects(const com::Utf8Str &aObjUuid, std::vector<ComPtr<IUnknown> > &aObjects, std::vector<com::Utf8Str> *a_pstrExtPackNames);
+#endif
+#ifdef VBOX_COM_INPROC
+    void        i_callAllConsoleReadyHooks(IConsole *a_pConsole);
+#endif
+#ifndef VBOX_COM_INPROC
+    void        i_callAllVmCreatedHooks(IMachine *a_pMachine);
+#endif
+#ifdef VBOX_COM_INPROC
+    int         i_callAllVmConfigureVmmHooks(IConsole *a_pConsole, PVM a_pVM, PCVMMR3VTABLE a_pVMM);
+    int         i_callAllVmPowerOnHooks(IConsole *a_pConsole, PVM a_pVM, PCVMMR3VTABLE a_pVMM);
+    void        i_callAllVmPowerOffHooks(IConsole *a_pConsole, PVM a_pVM, PCVMMR3VTABLE a_pVMM);
+#endif
+    HRESULT     i_checkVrdeExtPack(Utf8Str const *a_pstrExtPack);
+    int         i_getVrdeLibraryPathForExtPack(Utf8Str const *a_pstrExtPack, Utf8Str *a_pstrVrdeLibrary);
+    HRESULT     i_checkCryptoExtPack(Utf8Str const *a_pstrExtPack);
+    int         i_getCryptoLibraryPathForExtPack(Utf8Str const *a_pstrExtPack, Utf8Str *a_pstrVrdeLibrary);
+    HRESULT     i_getLibraryPathForExtPack(const char *a_pszModuleName, const char *a_pszExtPack, Utf8Str *a_pstrLibrary);
+    HRESULT     i_getDefaultVrdeExtPack(Utf8Str *a_pstrExtPack);
+    HRESULT     i_getDefaultCryptoExtPack(Utf8Str *a_pstrExtPack);
+    bool        i_isExtPackUsable(const char *a_pszExtPack);
+    void        i_dumpAllToReleaseLog(void);
+    uint64_t    i_getUpdateCounter(void);
+    /** @}  */
+
+private:
+    // wrapped IExtPackManager properties
+    HRESULT getInstalledExtPacks(std::vector<ComPtr<IExtPack> > &aInstalledExtPacks);
+
+   // wrapped IExtPackManager methods
+    HRESULT find(const com::Utf8Str &aName,
+                 ComPtr<IExtPack> &aReturnData);
+    HRESULT openExtPackFile(const com::Utf8Str &aPath,
+                                  ComPtr<IExtPackFile> &aFile);
+    HRESULT uninstall(const com::Utf8Str &aName,
+                      BOOL aForcedRemoval,
+                      const com::Utf8Str &aDisplayInfo,
+                      ComPtr<IProgress> &aProgess);
+    HRESULT cleanup();
+    HRESULT queryAllPlugInsForFrontend(const com::Utf8Str &aFrontendName,
+                                       std::vector<com::Utf8Str> &aPlugInModules);
+    HRESULT isExtPackUsable(const com::Utf8Str &aName,
+                            BOOL *aUsable);
+
+    bool        i_areThereAnyRunningVMs(void) const;
+    HRESULT     i_runSetUidToRootHelper(Utf8Str const *a_pstrDisplayInfo, const char *a_pszCommand, ...);
+    ExtPack    *i_findExtPack(const char *a_pszName);
+    void        i_removeExtPack(const char *a_pszName);
+    HRESULT     i_refreshExtPack(const char *a_pszName, bool a_fUnsuableIsError, ExtPack **a_ppExtPack);
+
+private:
+    struct Data;
+    /** Pointer to the private instance. */
+    Data *m;
+
+    friend class ExtPackUninstallTask;
+};
+
+#endif /* !MAIN_INCLUDED_ExtPackManagerImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/ExtPackUtil.h b/src/VBox/Main/include/ExtPackUtil.h
new file mode 100644
index 00000000..82c0ef0c
--- /dev/null
+++ b/src/VBox/Main/include/ExtPackUtil.h
@@ -0,0 +1,158 @@
+/* $Id: ExtPackUtil.h $ */
+/** @file
+ * VirtualBox Main - Extension Pack Utilities and definitions, VBoxC, VBoxSVC, ++.
+ */
+
+/*
+ * Copyright (C) 2010-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
+ */
+
+#ifndef MAIN_INCLUDED_ExtPackUtil_h
+#define MAIN_INCLUDED_ExtPackUtil_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#ifdef __cplusplus
+# include <iprt/cpp/ministring.h>
+#endif
+#include <iprt/fs.h>
+#include <iprt/vfs.h>
+
+
+/** @name VBOX_EXTPACK_DESCRIPTION_NAME
+ * The name of the description file in an extension pack.  */
+#define VBOX_EXTPACK_DESCRIPTION_NAME   "ExtPack.xml"
+/** @name VBOX_EXTPACK_DESCRIPTION_NAME
+ * The name of the manifest file in an extension pack.  */
+#define VBOX_EXTPACK_MANIFEST_NAME      "ExtPack.manifest"
+/** @name VBOX_EXTPACK_SIGNATURE_NAME
+ * The name of the signature file in an extension pack.  */
+#define VBOX_EXTPACK_SIGNATURE_NAME     "ExtPack.signature"
+/** @name VBOX_EXTPACK_LICENSE_NAME_PREFIX
+ * The name prefix of a license file in an extension pack. There can be
+ * several license files in a pack, the variations being on locale, language
+ * and format (HTML, RTF, plain text). All extension packages shall include
+ * a  */
+#define VBOX_EXTPACK_LICENSE_NAME_PREFIX "ExtPack-license"
+/** @name VBOX_EXTPACK_SUFFIX
+ * The suffix of a extension pack tarball. */
+#define VBOX_EXTPACK_SUFFIX             ".vbox-extpack"
+
+/** The minimum length (strlen) of a extension pack name. */
+#define VBOX_EXTPACK_NAME_MIN_LEN       3
+/** The max length (strlen) of a extension pack name. */
+#define VBOX_EXTPACK_NAME_MAX_LEN       64
+
+/** The architecture-dependent application data subdirectory where the
+ * extension packs are installed.  Relative to RTPathAppPrivateArch. */
+#define VBOX_EXTPACK_INSTALL_DIR        "ExtensionPacks"
+/** The architecture-independent application data subdirectory where the
+ * certificates are installed.  Relative to RTPathAppPrivateNoArch. */
+#define VBOX_EXTPACK_CERT_DIR           "ExtPackCertificates"
+
+/** The maximum entry name length.
+ * Play short and safe. */
+#define VBOX_EXTPACK_MAX_MEMBER_NAME_LENGTH 128
+
+
+#ifdef __cplusplus
+
+/**
+ * Plug-in descriptor.
+ */
+typedef struct VBOXEXTPACKPLUGINDESC
+{
+    /** The name. */
+    RTCString        strName;
+    /** The module name. */
+    RTCString        strModule;
+    /** The description. */
+    RTCString        strDescription;
+    /** The frontend or component which it plugs into. */
+    RTCString        strFrontend;
+} VBOXEXTPACKPLUGINDESC;
+/** Pointer to a plug-in descriptor. */
+typedef VBOXEXTPACKPLUGINDESC *PVBOXEXTPACKPLUGINDESC;
+
+/**
+ * Extension pack descriptor
+ *
+ * This is the internal representation of the ExtPack.xml.
+ */
+typedef struct VBOXEXTPACKDESC
+{
+    /** The name. */
+    RTCString               strName;
+    /** The description. */
+    RTCString               strDescription;
+    /** The version string. */
+    RTCString               strVersion;
+    /** The edition string. */
+    RTCString               strEdition;
+    /** The internal revision number. */
+    uint32_t                uRevision;
+    /** The name of the main module. */
+    RTCString               strMainModule;
+    /** The name of the main VM module, empty if none. */
+    RTCString               strMainVMModule;
+    /** The name of the VRDE module, empty if none. */
+    RTCString               strVrdeModule;
+    /** The name of the cryptographic module, empty if none. */
+    RTCString               strCryptoModule;
+    /** The number of plug-in descriptors. */
+    uint32_t                cPlugIns;
+    /** Pointer to an array of plug-in descriptors. */
+    PVBOXEXTPACKPLUGINDESC  paPlugIns;
+    /** Whether to show the license prior to installation. */
+    bool                    fShowLicense;
+} VBOXEXTPACKDESC;
+
+/** Pointer to a extension pack descriptor. */
+typedef VBOXEXTPACKDESC *PVBOXEXTPACKDESC;
+/** Pointer to a const extension pack descriptor. */
+typedef VBOXEXTPACKDESC const *PCVBOXEXTPACKDESC;
+
+
+void                VBoxExtPackInitDesc(PVBOXEXTPACKDESC a_pExtPackDesc);
+RTCString          *VBoxExtPackLoadDesc(const char *a_pszDir, PVBOXEXTPACKDESC a_pExtPackDesc, PRTFSOBJINFO a_pObjInfo);
+RTCString          *VBoxExtPackLoadDescFromVfsFile(RTVFSFILE hVfsFile, PVBOXEXTPACKDESC a_pExtPackDesc, PRTFSOBJINFO a_pObjInfo);
+RTCString          *VBoxExtPackExtractNameFromTarballPath(const char *pszTarball);
+void                VBoxExtPackFreeDesc(PVBOXEXTPACKDESC a_pExtPackDesc);
+bool                VBoxExtPackIsValidName(const char *pszName);
+bool                VBoxExtPackIsValidMangledName(const char *pszMangledName, size_t cchMax = RTSTR_MAX);
+RTCString          *VBoxExtPackMangleName(const char *pszName);
+RTCString          *VBoxExtPackUnmangleName(const char *pszMangledName, size_t cbMax);
+int                 VBoxExtPackCalcDir(char *pszExtPackDir, size_t cbExtPackDir, const char *pszParentDir, const char *pszName);
+bool                VBoxExtPackIsValidVersionString(const char *pszVersion);
+bool                VBoxExtPackIsValidEditionString(const char *pszEdition);
+bool                VBoxExtPackIsValidModuleString(const char *pszModule);
+
+int                 VBoxExtPackValidateMember(const char *pszName, RTVFSOBJTYPE enmType, RTVFSOBJ hVfsObj, char *pszError, size_t cbError);
+int                 VBoxExtPackOpenTarFss(RTFILE hTarballFile, char *pszError, size_t cbError, PRTVFSFSSTREAM phTarFss, PRTMANIFEST phFileManifest);
+int                 VBoxExtPackValidateTarball(RTFILE hTarballFile, const char *pszExtPackName,
+                                               const char *pszTarball, const char *pszTarballDigest,
+                                               char *pszError, size_t cbError,
+                                               PRTMANIFEST phValidManifest, PRTVFSFILE phXmlFile, RTCString *pStrDigest);
+#endif /* __cplusplus */
+
+#endif /* !MAIN_INCLUDED_ExtPackUtil_h */
+
diff --git a/src/VBox/Main/include/Global.h b/src/VBox/Main/include/Global.h
new file mode 100644
index 00000000..f8b752f7
--- /dev/null
+++ b/src/VBox/Main/include/Global.h
@@ -0,0 +1,255 @@
+/* $Id: Global.h $ */
+/** @file
+ * VirtualBox COM API - Global Declarations and Definitions.
+ */
+
+/*
+ * Copyright (C) 2008-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
+ */
+
+#ifndef MAIN_INCLUDED_Global_h
+#define MAIN_INCLUDED_Global_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+/* interface definitions */
+#include "VBox/com/VirtualBox.h"
+
+#include <VBox/ostypes.h>
+
+#include <iprt/types.h>
+
+#define VBOXOSHINT_NONE                 0
+#define VBOXOSHINT_64BIT                RT_BIT(0)
+#define VBOXOSHINT_HWVIRTEX             RT_BIT(1)
+#define VBOXOSHINT_IOAPIC               RT_BIT(2)
+#define VBOXOSHINT_EFI                  RT_BIT(3)
+#define VBOXOSHINT_PAE                  RT_BIT(4)
+#define VBOXOSHINT_USBHID               RT_BIT(5)
+#define VBOXOSHINT_HPET                 RT_BIT(6)
+#define VBOXOSHINT_USBTABLET            RT_BIT(7)
+#define VBOXOSHINT_RTCUTC               RT_BIT(8)
+#define VBOXOSHINT_ACCEL2D              RT_BIT(9)
+#define VBOXOSHINT_ACCEL3D              RT_BIT(10)
+#define VBOXOSHINT_FLOPPY               RT_BIT(11)
+#define VBOXOSHINT_NOUSB                RT_BIT(12)
+#define VBOXOSHINT_TFRESET              RT_BIT(13)
+#define VBOXOSHINT_USB3                 RT_BIT(14)
+#define VBOXOSHINT_X2APIC               RT_BIT(15)
+#define VBOXOSHINT_EFI_SECUREBOOT       RT_BIT(16)
+#define VBOXOSHINT_TPM                  RT_BIT(17)
+#define VBOXOSHINT_TPM2                 RT_BIT(18)
+#define VBOXOSHINT_WDDM_GRAPHICS        RT_BIT(19)
+
+/** The VBoxVRDP kludge extension pack name.
+ *
+ * This is not a valid extension pack name (dashes are not allowed), and
+ * hence will not conflict with real extension packs.
+ */
+#define VBOXVRDP_KLUDGE_EXTPACK_NAME    "Built-in-VBoxVRDP"
+
+/** The VBoxPuelCrypto kludge extension pack name.
+ *
+ * This is not a valid extension pack name (dashes are not allowed), and
+ * hence will not conflict with real extension packs.
+ */
+#define VBOXPUELCRYPTO_KLUDGE_EXTPACK_NAME    "Built-in-VBoxPuelCrypto"
+
+/**
+ * Contains global static definitions that can be referenced by all COM classes
+ * regardless of the apartment.
+ */
+class Global
+{
+public:
+
+    /** Represents OS Type <-> string mappings. */
+    struct OSType
+    {
+        const char                    *familyId;          /* utf-8 */
+        const char                    *familyDescription; /* utf-8 */
+        const char                    *id;          /* utf-8, VM config file value */
+        const char                    *description; /* utf-8 */
+        const VBOXOSTYPE               osType;
+        const uint32_t                 osHint;
+        const uint32_t                 recommendedCPUCount;
+        const uint32_t                 recommendedRAM;
+        const uint32_t                 recommendedVRAM;
+        const uint64_t                 recommendedHDD;
+        const GraphicsControllerType_T graphicsControllerType;
+        const NetworkAdapterType_T     networkAdapterType;
+        const uint32_t                 numSerialEnabled;
+        const StorageControllerType_T  dvdStorageControllerType;
+        const StorageBus_T             dvdStorageBusType;
+        const StorageControllerType_T  hdStorageControllerType;
+        const StorageBus_T             hdStorageBusType;
+        const ChipsetType_T            chipsetType;
+        const IommuType_T              iommuType;
+        const AudioControllerType_T    audioControllerType;
+        const AudioCodecType_T         audioCodecType;
+    };
+
+    static const OSType sOSTypes[];
+    static size_t cOSTypes;
+
+    /**
+     * Maps VBOXOSTYPE to the OS type which is used in VM configs.
+     */
+    static const char *OSTypeId(VBOXOSTYPE aOSType);
+
+    /**
+     * Maps an OS type ID string to index into sOSTypes.
+     * @returns index on success, UINT32_MAX if not found.
+     */
+    static uint32_t getOSTypeIndexFromId(const char *pszId);
+
+    /**
+     * Get the network adapter limit for each chipset type.
+     */
+    static uint32_t getMaxNetworkAdapters(ChipsetType_T aChipsetType);
+
+    /**
+     * Returns @c true if the given machine state is an online state. This is a
+     * recommended way to detect if the VM is online (being executed in a
+     * dedicated process) or not. Note that some online states are also
+     * transitional states (see #IsTransient()).
+     */
+    static bool IsOnline(MachineState_T aState)
+    {
+        return aState >= MachineState_FirstOnline &&
+               aState <= MachineState_LastOnline;
+    }
+
+    /**
+     * Returns @c true if the given machine state is a transient state. This is
+     * a recommended way to detect if the VM is performing some potentially
+     * lengthy operation (such as starting, stopping, saving, deleting
+     * snapshot, etc.). Note some (but not all) transitional states are also
+     * online states (see #IsOnline()).
+     */
+    static bool IsTransient(MachineState_T aState)
+    {
+        return aState >= MachineState_FirstTransient &&
+               aState <= MachineState_LastTransient;
+    }
+
+    /**
+     * Shortcut to <tt>IsOnline(aState) || IsTransient(aState)</tt>. When it returns
+     * @c false, the VM is turned off (no VM process) and not busy with
+     * another exclusive operation.
+     */
+    static bool IsOnlineOrTransient(MachineState_T aState)
+    {
+        return IsOnline(aState) || IsTransient(aState);
+    }
+
+    /**
+     * Stringify a machine state - translated.
+     *
+     * Drop the Global:: prefix and include StringifyEnums.h for an untranslated
+     * version of this method.
+     *
+     * @returns Pointer to a read only string.
+     * @param   aState      Valid machine state.
+     */
+    static const char *stringifyMachineState(MachineState_T aState);
+
+    /**
+     * Stringify a session state - translated.
+     *
+     * Drop the Global:: prefix and include StringifyEnums.h for an untranslated
+     * version of this method.
+     *
+     * @returns Pointer to a read only string.
+     * @param   aState      Valid session state.
+     */
+    static const char *stringifySessionState(SessionState_T aState);
+
+    /**
+     * Stringify a device type.
+     *
+     * Drop the Global:: prefix and include StringifyEnums.h for an untranslated
+     * version of this method.
+     *
+     * @returns Pointer to a read only string.
+     * @param   aType       The device type.
+     */
+    static const char *stringifyDeviceType(DeviceType_T aType);
+
+    /**
+     * Stringify a storage controller type.
+     *
+     * Drop the Global:: prefix and include StringifyEnums.h for an untranslated
+     * version of this method.
+     *
+     * @returns Pointer to a read only string.
+     * @param   aType       The storage controller type.
+     */
+    static const char *stringifyStorageControllerType(StorageControllerType_T aType);
+
+#if 0 /* unused */
+    /**
+     * Stringify a storage bus type.
+     *
+     * Drop the Global:: prefix and include StringifyEnums.h for an untranslated
+     * version of this method.
+     *
+     * @returns Pointer to a read only string.
+     * @param   aBus        The storage bus type.
+     */
+    static const char *stringifyStorageBus(StorageBus_T aBus);
+
+    /**
+     * Stringify a reason.
+     *
+     * Drop the Global:: prefix and include StringifyEnums.h for an untranslated
+     * version of this method.
+     *
+     * @returns Pointer to a read only string.
+     * @param   aReason     The reason code.
+     */
+    static const char *stringifyReason(Reason_T aReason);
+#endif
+
+    /**
+     * Try convert a COM status code to a VirtualBox status code (VBox/err.h).
+     *
+     * @returns VBox status code.
+     * @param   aComStatus      COM status code.
+     */
+    static int vboxStatusCodeFromCOM(HRESULT aComStatus);
+
+    /**
+     * Try convert a VirtualBox status code (VBox/err.h) to a COM status code.
+     *
+     * This is mainly intended for dealing with vboxStatusCodeFromCOM() return
+     * values.  If used on anything else, it won't be able to cope with most of the
+     * input!
+     *
+     * @returns COM status code.
+     * @param   aVBoxStatus      VBox status code.
+     */
+    static HRESULT vboxStatusCodeToCOM(int aVBoxStatus);
+};
+
+#endif /* !MAIN_INCLUDED_Global_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/GraphicsAdapterImpl.h b/src/VBox/Main/include/GraphicsAdapterImpl.h
new file mode 100644
index 00000000..762037dd
--- /dev/null
+++ b/src/VBox/Main/include/GraphicsAdapterImpl.h
@@ -0,0 +1,88 @@
+/* $Id: GraphicsAdapterImpl.h $ */
+/** @file
+ * Implementation of IGraphicsAdapter in VBoxSVC - Header.
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_GraphicsAdapterImpl_h
+#define MAIN_INCLUDED_GraphicsAdapterImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "GraphicsAdapterWrap.h"
+
+
+namespace settings
+{
+    struct GraphicsAdapter;
+};
+
+
+class ATL_NO_VTABLE GraphicsAdapter :
+    public GraphicsAdapterWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(GraphicsAdapter)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Machine *aParent);
+    HRESULT init(Machine *aParent, GraphicsAdapter *aThat);
+    HRESULT initCopy(Machine *aParent, GraphicsAdapter *aThat);
+    void uninit();
+
+
+    // public methods only for internal purposes
+    HRESULT i_loadSettings(const settings::GraphicsAdapter &data);
+    HRESULT i_saveSettings(settings::GraphicsAdapter &data);
+
+    void i_rollback();
+    void i_commit();
+    void i_copyFrom(GraphicsAdapter *aThat);
+
+private:
+
+    // wrapped IGraphicsAdapter properties
+    HRESULT getGraphicsControllerType(GraphicsControllerType_T *aGraphicsControllerType);
+    HRESULT setGraphicsControllerType(GraphicsControllerType_T aGraphicsControllerType);
+    HRESULT getVRAMSize(ULONG *aVRAMSize);
+    HRESULT setVRAMSize(ULONG aVRAMSize);
+    HRESULT getAccelerate3DEnabled(BOOL *aAccelerate3DEnabled);
+    HRESULT setAccelerate3DEnabled(BOOL aAccelerate3DEnabled);
+    HRESULT getAccelerate2DVideoEnabled(BOOL *aAccelerate2DVideoEnabled);
+    HRESULT setAccelerate2DVideoEnabled(BOOL aAccelerate2DVideoEnabled);
+    HRESULT getMonitorCount(ULONG *aMonitorCount);
+    HRESULT setMonitorCount(ULONG aMonitorCount);
+
+    Machine * const     mParent;
+    const ComObjPtr<GraphicsAdapter> mPeer;
+    Backupable<settings::GraphicsAdapter> mData;
+};
+
+#endif /* !MAIN_INCLUDED_GraphicsAdapterImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/GuestCtrlImplPrivate.h b/src/VBox/Main/include/GuestCtrlImplPrivate.h
new file mode 100644
index 00000000..6287dfd7
--- /dev/null
+++ b/src/VBox/Main/include/GuestCtrlImplPrivate.h
@@ -0,0 +1,1459 @@
+/* $Id: GuestCtrlImplPrivate.h $ */
+/** @file
+ * Internal helpers/structures for guest control functionality.
+ */
+
+/*
+ * Copyright (C) 2011-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
+ */
+
+#ifndef MAIN_INCLUDED_GuestCtrlImplPrivate_h
+#define MAIN_INCLUDED_GuestCtrlImplPrivate_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "ConsoleImpl.h"
+#include "Global.h"
+
+#include <iprt/asm.h>
+#include <iprt/env.h>
+#include <iprt/semaphore.h>
+#include <iprt/cpp/utils.h>
+
+#include <VBox/com/com.h>
+#include <VBox/com/ErrorInfo.h>
+#include <VBox/com/string.h>
+#include <VBox/com/VirtualBox.h>
+#include <VBox/err.h> /* VERR_GSTCTL_GUEST_ERROR */
+
+#include <map>
+#include <vector>
+
+using namespace com;
+
+#ifdef VBOX_WITH_GUEST_CONTROL
+# include <VBox/GuestHost/GuestControl.h>
+# include <VBox/HostServices/GuestControlSvc.h>
+using namespace guestControl;
+#endif
+
+/** Vector holding a process' CPU affinity. */
+typedef std::vector <LONG> ProcessAffinity;
+/** Vector holding process startup arguments. */
+typedef std::vector <Utf8Str> ProcessArguments;
+
+class GuestProcessStreamBlock;
+class GuestSession;
+
+
+/**
+ * Simple structure mantaining guest credentials.
+ */
+struct GuestCredentials
+{
+    Utf8Str                     mUser;
+    Utf8Str                     mPassword;
+    Utf8Str                     mDomain;
+};
+
+
+/**
+ * Wrapper around the RTEnv API, unusable base class.
+ *
+ * @remarks Feel free to elevate this class to iprt/cpp/env.h as RTCEnv.
+ */
+class GuestEnvironmentBase
+{
+public:
+    /**
+     * Default constructor.
+     *
+     * The user must invoke one of the init methods before using the object.
+     */
+    GuestEnvironmentBase(void)
+        : m_hEnv(NIL_RTENV)
+        , m_cRefs(1)
+        , m_fFlags(0)
+    { }
+
+    /**
+     * Destructor.
+     */
+    virtual ~GuestEnvironmentBase(void)
+    {
+        Assert(m_cRefs <= 1);
+        int vrc = RTEnvDestroy(m_hEnv); AssertRC(vrc);
+        m_hEnv = NIL_RTENV;
+    }
+
+    /**
+     * Retains a reference to this object.
+     * @returns New reference count.
+     * @remarks Sharing an object is currently only safe if no changes are made to
+     *          it because RTENV does not yet implement any locking.  For the only
+     *          purpose we need this, implementing IGuestProcess::environment by
+     *          using IGuestSession::environmentBase, that's fine as the session
+     *          base environment is immutable.
+     */
+    uint32_t retain(void)
+    {
+        uint32_t cRefs = ASMAtomicIncU32(&m_cRefs);
+        Assert(cRefs > 1); Assert(cRefs < _1M);
+        return cRefs;
+
+    }
+    /** Useful shortcut. */
+    uint32_t retainConst(void) const { return unconst(this)->retain(); }
+
+    /**
+     * Releases a reference to this object, deleting the object when reaching zero.
+     * @returns New reference count.
+     */
+    uint32_t release(void)
+    {
+        uint32_t cRefs = ASMAtomicDecU32(&m_cRefs);
+        Assert(cRefs < _1M);
+        if (cRefs == 0)
+            delete this;
+        return cRefs;
+    }
+
+    /** Useful shortcut. */
+    uint32_t releaseConst(void) const { return unconst(this)->retain(); }
+
+    /**
+     * Checks if the environment has been successfully initialized or not.
+     *
+     * @returns @c true if initialized, @c false if not.
+     */
+    bool isInitialized(void) const
+    {
+        return m_hEnv != NIL_RTENV;
+    }
+
+    /**
+     * Returns the variable count.
+     * @return Number of variables.
+     * @sa      RTEnvCountEx
+     */
+    uint32_t count(void) const
+    {
+        return RTEnvCountEx(m_hEnv);
+    }
+
+    /**
+     * Deletes the environment change record entirely.
+     *
+     * The count() method will return zero after this call.
+     *
+     * @sa      RTEnvReset
+     */
+    void reset(void)
+    {
+        int vrc = RTEnvReset(m_hEnv);
+        AssertRC(vrc);
+    }
+
+    /**
+     * Exports the environment change block as an array of putenv style strings.
+     *
+     *
+     * @returns VINF_SUCCESS or VERR_NO_MEMORY.
+     * @param   pArray              The output array.
+     */
+    int queryPutEnvArray(std::vector<com::Utf8Str> *pArray) const
+    {
+        uint32_t cVars = RTEnvCountEx(m_hEnv);
+        try
+        {
+            pArray->resize(cVars);
+            for (uint32_t iVar = 0; iVar < cVars; iVar++)
+            {
+                const char *psz = RTEnvGetByIndexRawEx(m_hEnv, iVar);
+                AssertReturn(psz, VERR_INTERNAL_ERROR_3); /* someone is racing us! */
+                (*pArray)[iVar] = psz;
+            }
+            return VINF_SUCCESS;
+        }
+        catch (std::bad_alloc &)
+        {
+            return VERR_NO_MEMORY;
+        }
+    }
+
+    /**
+     * Applies an array of putenv style strings.
+     *
+     * @returns IPRT status code.
+     * @param   rArray          The array with the putenv style strings.
+     * @param   pidxError       Where to return the index causing trouble on
+     *                          failure.  Optional.
+     * @sa      RTEnvPutEx
+     */
+    int applyPutEnvArray(const std::vector<com::Utf8Str> &rArray, size_t *pidxError = NULL)
+    {
+        size_t const cArray = rArray.size();
+        for (size_t i = 0; i < cArray; i++)
+        {
+            int vrc = RTEnvPutEx(m_hEnv, rArray[i].c_str());
+            if (RT_FAILURE(vrc))
+            {
+                if (pidxError)
+                    *pidxError = i;
+                return vrc;
+            }
+        }
+        return VINF_SUCCESS;
+    }
+
+    /**
+     * Applies the changes from another environment to this.
+     *
+     * @returns IPRT status code.
+     * @param   rChanges        Reference to an environment which variables will be
+     *                          imported and, if it's a change record, schedule
+     *                          variable unsets will be applied.
+     * @sa      RTEnvApplyChanges
+     */
+    int applyChanges(const GuestEnvironmentBase &rChanges)
+    {
+        return RTEnvApplyChanges(m_hEnv, rChanges.m_hEnv);
+    }
+
+    /**
+     * See RTEnvQueryUtf8Block for details.
+     * @returns IPRT status code.
+     * @param   ppszzBlock      Where to return the block pointer.
+     * @param   pcbBlock        Where to optionally return the block size.
+     * @sa      RTEnvQueryUtf8Block
+     */
+    int queryUtf8Block(char **ppszzBlock, size_t *pcbBlock)
+    {
+        return RTEnvQueryUtf8Block(m_hEnv, true /*fSorted*/, ppszzBlock, pcbBlock);
+    }
+
+    /**
+     * Frees what queryUtf8Block returned, NULL ignored.
+     * @sa      RTEnvFreeUtf8Block
+     */
+    static void freeUtf8Block(char *pszzBlock)
+    {
+        return RTEnvFreeUtf8Block(pszzBlock);
+    }
+
+    /**
+     * Applies a block on the format returned by queryUtf8Block.
+     *
+     * @returns IPRT status code.
+     * @param   pszzBlock           Pointer to the block.
+     * @param   cbBlock             The size of the block.
+     * @param   fNoEqualMeansUnset  Whether the lack of a '=' (equal) sign in a
+     *                              string means it should be unset (@c true), or if
+     *                              it means the variable should be defined with an
+     *                              empty value (@c false, the default).
+     * @todo move this to RTEnv!
+     */
+    int copyUtf8Block(const char *pszzBlock, size_t cbBlock, bool fNoEqualMeansUnset = false)
+    {
+        int vrc = VINF_SUCCESS;
+        while (cbBlock > 0 && *pszzBlock != '\0')
+        {
+            const char *pszEnd = (const char *)memchr(pszzBlock, '\0', cbBlock);
+            if (!pszEnd)
+                return VERR_BUFFER_UNDERFLOW;
+            int vrc2;
+            if (fNoEqualMeansUnset || strchr(pszzBlock, '='))
+                vrc2 = RTEnvPutEx(m_hEnv, pszzBlock);
+            else
+                vrc2 = RTEnvSetEx(m_hEnv, pszzBlock, "");
+            if (RT_FAILURE(vrc2) && RT_SUCCESS(vrc))
+                vrc = vrc2;
+
+            /* Advance. */
+            cbBlock -= pszEnd - pszzBlock;
+            if (cbBlock < 2)
+                return VERR_BUFFER_UNDERFLOW;
+            cbBlock--;
+            pszzBlock = pszEnd + 1;
+        }
+
+        /* The remainder must be zero padded. */
+        if (RT_SUCCESS(vrc))
+        {
+            if (ASMMemIsZero(pszzBlock, cbBlock))
+                return VINF_SUCCESS;
+            return VERR_TOO_MUCH_DATA;
+        }
+        return vrc;
+    }
+
+    /**
+     * Get an environment variable.
+     *
+     * @returns IPRT status code.
+     * @param   rName               The variable name.
+     * @param   pValue              Where to return the value.
+     * @sa      RTEnvGetEx
+     */
+    int getVariable(const com::Utf8Str &rName, com::Utf8Str *pValue) const
+    {
+        size_t cchNeeded;
+        int vrc = RTEnvGetEx(m_hEnv, rName.c_str(), NULL, 0, &cchNeeded);
+        if (   RT_SUCCESS(vrc)
+            || vrc == VERR_BUFFER_OVERFLOW)
+        {
+            try
+            {
+                pValue->reserve(cchNeeded + 1);
+                vrc = RTEnvGetEx(m_hEnv, rName.c_str(), pValue->mutableRaw(), pValue->capacity(), NULL);
+                pValue->jolt();
+            }
+            catch (std::bad_alloc &)
+            {
+                vrc = VERR_NO_STR_MEMORY;
+            }
+        }
+        return vrc;
+    }
+
+    /**
+     * Checks if the given variable exists.
+     *
+     * @returns @c true if it exists, @c false if not or if it's an scheduled unset
+     *          in a environment change record.
+     * @param   rName               The variable name.
+     * @sa      RTEnvExistEx
+     */
+    bool doesVariableExist(const com::Utf8Str &rName) const
+    {
+        return RTEnvExistEx(m_hEnv, rName.c_str());
+    }
+
+    /**
+     * Set an environment variable.
+     *
+     * @returns IPRT status code.
+     * @param   rName               The variable name.
+     * @param   rValue              The value of the variable.
+     * @sa      RTEnvSetEx
+     */
+    int setVariable(const com::Utf8Str &rName, const com::Utf8Str &rValue)
+    {
+        return RTEnvSetEx(m_hEnv, rName.c_str(), rValue.c_str());
+    }
+
+    /**
+     * Unset an environment variable.
+     *
+     * @returns IPRT status code.
+     * @param   rName               The variable name.
+     * @sa      RTEnvUnsetEx
+     */
+    int unsetVariable(const com::Utf8Str &rName)
+    {
+        return RTEnvUnsetEx(m_hEnv, rName.c_str());
+    }
+
+protected:
+    /**
+     * Copy constructor.
+     * @throws HRESULT
+     */
+    GuestEnvironmentBase(const GuestEnvironmentBase &rThat, bool fChangeRecord, uint32_t fFlags = 0)
+        : m_hEnv(NIL_RTENV)
+        , m_cRefs(1)
+        , m_fFlags(fFlags)
+    {
+        int vrc = cloneCommon(rThat, fChangeRecord);
+        if (RT_FAILURE(vrc))
+            throw Global::vboxStatusCodeToCOM(vrc);
+    }
+
+    /**
+     * Common clone/copy method with type conversion abilities.
+     *
+     * @returns IPRT status code.
+     * @param   rThat           The object to clone.
+     * @param   fChangeRecord   Whether the this instance is a change record (true)
+     *                          or normal (false) environment.
+     */
+    int cloneCommon(const GuestEnvironmentBase &rThat, bool fChangeRecord)
+    {
+        int   vrc = VINF_SUCCESS;
+        RTENV hNewEnv = NIL_RTENV;
+        if (rThat.m_hEnv != NIL_RTENV)
+        {
+            /*
+             * Clone it.
+             */
+            if (RTEnvIsChangeRecord(rThat.m_hEnv) == fChangeRecord)
+                vrc = RTEnvClone(&hNewEnv, rThat.m_hEnv);
+            else
+            {
+                /* Need to type convert it. */
+                if (fChangeRecord)
+                    vrc = RTEnvCreateChangeRecordEx(&hNewEnv, rThat.m_fFlags);
+                else
+                    vrc = RTEnvCreateEx(&hNewEnv, rThat.m_fFlags);
+                if (RT_SUCCESS(vrc))
+                {
+                    vrc = RTEnvApplyChanges(hNewEnv, rThat.m_hEnv);
+                    if (RT_FAILURE(vrc))
+                        RTEnvDestroy(hNewEnv);
+                }
+            }
+        }
+        else
+        {
+            /*
+             * Create an empty one so the object works smoothly.
+             * (Relevant for GuestProcessStartupInfo and internal commands.)
+             */
+            if (fChangeRecord)
+                vrc = RTEnvCreateChangeRecordEx(&hNewEnv, rThat.m_fFlags);
+            else
+                vrc = RTEnvCreateEx(&hNewEnv, rThat.m_fFlags);
+        }
+        if (RT_SUCCESS(vrc))
+        {
+            RTEnvDestroy(m_hEnv);
+            m_hEnv = hNewEnv;
+            m_fFlags = rThat.m_fFlags;
+        }
+        return vrc;
+    }
+
+
+    /** The environment change record. */
+    RTENV               m_hEnv;
+    /** Reference counter. */
+    uint32_t volatile   m_cRefs;
+    /** RTENV_CREATE_F_XXX. */
+    uint32_t            m_fFlags;
+};
+
+class GuestEnvironmentChanges;
+
+
+/**
+ * Wrapper around the RTEnv API for a normal environment.
+ */
+class GuestEnvironment : public GuestEnvironmentBase
+{
+public:
+    /**
+     * Default constructor.
+     *
+     * The user must invoke one of the init methods before using the object.
+     */
+    GuestEnvironment(void)
+        : GuestEnvironmentBase()
+    { }
+
+    /**
+     * Copy operator.
+     * @param   rThat       The object to copy.
+     * @throws HRESULT
+     */
+    GuestEnvironment(const GuestEnvironment &rThat)
+        : GuestEnvironmentBase(rThat, false /*fChangeRecord*/)
+    { }
+
+    /**
+     * Copy operator.
+     * @param   rThat       The object to copy.
+     * @throws HRESULT
+     */
+    GuestEnvironment(const GuestEnvironmentBase &rThat)
+        : GuestEnvironmentBase(rThat, false /*fChangeRecord*/)
+    { }
+
+    /**
+     * Initialize this as a normal environment block.
+     * @returns IPRT status code.
+     * @param   fFlags      RTENV_CREATE_F_XXX
+     */
+    int initNormal(uint32_t fFlags)
+    {
+        AssertReturn(m_hEnv == NIL_RTENV, VERR_WRONG_ORDER);
+        m_fFlags = fFlags;
+        return RTEnvCreateEx(&m_hEnv, fFlags);
+    }
+
+    /**
+     * Replaces this environemnt with that in @a rThat.
+     *
+     * @returns IPRT status code
+     * @param   rThat       The environment to copy. If it's a different type
+     *                      we'll convert the data to a normal environment block.
+     */
+    int copy(const GuestEnvironmentBase &rThat)
+    {
+        return cloneCommon(rThat, false /*fChangeRecord*/);
+    }
+
+    /**
+     * @copydoc GuestEnvironment::copy()
+     */
+    GuestEnvironment &operator=(const GuestEnvironmentBase &rThat)
+    {
+        int vrc = copy(rThat);
+        if (RT_FAILURE(vrc))
+            throw Global::vboxStatusCodeToCOM(vrc);
+        return *this;
+    }
+
+    /** @copydoc GuestEnvironment::copy() */
+    GuestEnvironment &operator=(const GuestEnvironment &rThat)
+    {   return operator=((const GuestEnvironmentBase &)rThat); }
+
+    /** @copydoc GuestEnvironment::copy() */
+    GuestEnvironment &operator=(const GuestEnvironmentChanges &rThat)
+    {   return operator=((const GuestEnvironmentBase &)rThat); }
+
+};
+
+
+/**
+ * Wrapper around the RTEnv API for a environment change record.
+ *
+ * This class is used as a record of changes to be applied to a different
+ * environment block (in VBoxService before launching a new process).
+ */
+class GuestEnvironmentChanges : public GuestEnvironmentBase
+{
+public:
+    /**
+     * Default constructor.
+     *
+     * The user must invoke one of the init methods before using the object.
+     */
+    GuestEnvironmentChanges(void)
+        : GuestEnvironmentBase()
+    { }
+
+    /**
+     * Copy operator.
+     * @param   rThat       The object to copy.
+     * @throws HRESULT
+     */
+    GuestEnvironmentChanges(const GuestEnvironmentChanges &rThat)
+        : GuestEnvironmentBase(rThat, true /*fChangeRecord*/)
+    { }
+
+    /**
+     * Copy operator.
+     * @param   rThat       The object to copy.
+     * @throws HRESULT
+     */
+    GuestEnvironmentChanges(const GuestEnvironmentBase &rThat)
+        : GuestEnvironmentBase(rThat, true /*fChangeRecord*/)
+    { }
+
+    /**
+     * Initialize this as a environment change record.
+     * @returns IPRT status code.
+     * @param   fFlags      RTENV_CREATE_F_XXX
+     */
+    int initChangeRecord(uint32_t fFlags)
+    {
+        AssertReturn(m_hEnv == NIL_RTENV, VERR_WRONG_ORDER);
+        m_fFlags = fFlags;
+        return RTEnvCreateChangeRecordEx(&m_hEnv, fFlags);
+    }
+
+    /**
+     * Replaces this environemnt with that in @a rThat.
+     *
+     * @returns IPRT status code
+     * @param   rThat       The environment to copy. If it's a different type
+     *                      we'll convert the data to a set of changes.
+     */
+    int copy(const GuestEnvironmentBase &rThat)
+    {
+        return cloneCommon(rThat, true /*fChangeRecord*/);
+    }
+
+    /**
+     * @copydoc GuestEnvironmentChanges::copy()
+     * @throws  HRESULT
+     */
+    GuestEnvironmentChanges &operator=(const GuestEnvironmentBase &rThat)
+    {
+        int vrc = copy(rThat);
+        if (RT_FAILURE(vrc))
+            throw Global::vboxStatusCodeToCOM(vrc);
+        return *this;
+    }
+
+    /** @copydoc GuestEnvironmentChanges::copy()
+     * @throws  HRESULT */
+    GuestEnvironmentChanges &operator=(const GuestEnvironmentChanges &rThat)
+    {   return operator=((const GuestEnvironmentBase &)rThat); }
+
+    /** @copydoc GuestEnvironmentChanges::copy()
+     * @throws  HRESULT */
+    GuestEnvironmentChanges &operator=(const GuestEnvironment &rThat)
+    {   return operator=((const GuestEnvironmentBase &)rThat); }
+};
+
+/**
+ * Class for keeping guest error information.
+ */
+class GuestErrorInfo
+{
+public:
+
+    /**
+     * Enumeration for specifying the guest error type.
+     */
+    enum Type
+    {
+        /** Guest error is anonymous. Avoid this. */
+        Type_Anonymous = 0,
+        /** Guest error is from a guest session. */
+        Type_Session,
+        /** Guest error is from a guest process. */
+        Type_Process,
+        /** Guest error is from a guest file object. */
+        Type_File,
+        /** Guest error is from a guest directory object. */
+        Type_Directory,
+        /** Guest error is from a the built-in toolbox "vbox_cat" command. */
+        Type_ToolCat,
+        /** Guest error is from a the built-in toolbox "vbox_ls" command. */
+        Type_ToolLs,
+        /** Guest error is from a the built-in toolbox "vbox_rm" command. */
+        Type_ToolRm,
+        /** Guest error is from a the built-in toolbox "vbox_mkdir" command. */
+        Type_ToolMkDir,
+        /** Guest error is from a the built-in toolbox "vbox_mktemp" command. */
+        Type_ToolMkTemp,
+        /** Guest error is from a the built-in toolbox "vbox_stat" command. */
+        Type_ToolStat,
+        /** The usual 32-bit hack. */
+        Type_32BIT_HACK = 0x7fffffff
+    };
+
+    /**
+     * Initialization constructor.
+     *
+     * @param   eType           Error type to use.
+     * @param   vrc             VBox status code to use.
+     * @param   pcszWhat        Subject to use.
+     */
+    GuestErrorInfo(GuestErrorInfo::Type eType, int vrc, const char *pcszWhat)
+    {
+        int vrc2 = setV(eType, vrc, pcszWhat);
+        if (RT_FAILURE(vrc2))
+            throw vrc2;
+    }
+
+    /**
+     * Returns the VBox status code for this error.
+     *
+     * @returns VBox status code.
+     */
+    int getVrc(void) const { return mVrc; }
+
+    /**
+     * Returns the type of this error.
+     *
+     * @returns Error type.
+     */
+    Type getType(void) const { return mType; }
+
+    /**
+     * Returns the subject of this error.
+     *
+     * @returns Subject as a string.
+     */
+    Utf8Str getWhat(void) const { return mWhat; }
+
+    /**
+     * Sets the error information using a variable arguments list (va_list).
+     *
+     * @returns VBox status code.
+     * @param   eType           Error type to use.
+     * @param   vrc             VBox status code to use.
+     * @param   pcszWhat        Subject to use.
+     */
+    int setV(GuestErrorInfo::Type eType, int vrc, const char *pcszWhat)
+    {
+        mType = eType;
+        mVrc  = vrc;
+        mWhat = pcszWhat;
+
+        return VINF_SUCCESS;
+    }
+
+protected:
+
+    /** Error type. */
+    Type    mType;
+    /** VBox status (error) code. */
+    int     mVrc;
+    /** Subject string related to this error. */
+    Utf8Str mWhat;
+};
+
+/**
+ * Structure for keeping all the relevant guest directory
+ * information around.
+ */
+struct GuestDirectoryOpenInfo
+{
+    GuestDirectoryOpenInfo(void)
+        : mFlags(0) { }
+
+    /** The directory path. */
+    Utf8Str                 mPath;
+    /** Then open filter. */
+    Utf8Str                 mFilter;
+    /** Opening flags. */
+    uint32_t                mFlags;
+};
+
+
+/**
+ * Structure for keeping all the relevant guest file
+ * information around.
+ */
+struct GuestFileOpenInfo
+{
+    GuestFileOpenInfo(void)
+        : mAccessMode((FileAccessMode_T)0)
+        , mOpenAction((FileOpenAction_T)0)
+        , mSharingMode((FileSharingMode_T)0)
+        , mCreationMode(0)
+        , mfOpenEx(0) { }
+
+    /**
+     * Validates a file open info.
+     *
+     * @returns \c true if valid, \c false if not.
+     */
+    bool IsValid(void) const
+    {
+        if (mfOpenEx) /** @todo Open flags not implemented yet. */
+            return false;
+
+        switch (mOpenAction)
+        {
+            case FileOpenAction_OpenExisting:
+                break;
+            case FileOpenAction_OpenOrCreate:
+                break;
+            case FileOpenAction_CreateNew:
+                break;
+            case FileOpenAction_CreateOrReplace:
+                break;
+            case FileOpenAction_OpenExistingTruncated:
+            {
+                if (   mAccessMode == FileAccessMode_ReadOnly
+                    || mAccessMode == FileAccessMode_AppendOnly
+                    || mAccessMode == FileAccessMode_AppendRead)
+                    return false;
+                break;
+            }
+            case FileOpenAction_AppendOrCreate: /* Deprecated, do not use. */
+                break;
+            default:
+                AssertFailedReturn(false);
+                break;
+        }
+
+        return true; /** @todo Do we need more checks here? */
+    }
+
+    /** The filename. */
+    Utf8Str                 mFilename;
+    /** The file access mode. */
+    FileAccessMode_T        mAccessMode;
+    /** The file open action.  */
+    FileOpenAction_T        mOpenAction;
+    /** The file sharing mode. */
+    FileSharingMode_T       mSharingMode;
+    /** Octal creation mode. */
+    uint32_t                mCreationMode;
+    /** Extended open flags (currently none defined). */
+    uint32_t                mfOpenEx;
+};
+
+
+/**
+ * Structure representing information of a
+ * file system object.
+ */
+struct GuestFsObjData
+{
+    GuestFsObjData(void)
+        : mType(FsObjType_Unknown)
+        , mObjectSize(0)
+        , mAllocatedSize(0)
+        , mAccessTime(0)
+        , mBirthTime(0)
+        , mChangeTime(0)
+        , mModificationTime(0)
+        , mUID(0)
+        , mGID(0)
+        , mNodeID(0)
+        , mNodeIDDevice(0)
+        , mNumHardLinks(0)
+        , mDeviceNumber(0)
+        , mGenerationID(0)
+        , mUserFlags(0) { }
+
+    /** @name Helper functions to extract the data from a certin VBoxService tool's guest stream block.
+     * @{ */
+    int FromLs(const GuestProcessStreamBlock &strmBlk, bool fLong);
+    int FromRm(const GuestProcessStreamBlock &strmBlk);
+    int FromStat(const GuestProcessStreamBlock &strmBlk);
+    int FromMkTemp(const GuestProcessStreamBlock &strmBlk);
+    /** @}  */
+
+    /** @name Static helper functions to work with time from stream block keys.
+     * @{ */
+    static PRTTIMESPEC TimeSpecFromKey(const GuestProcessStreamBlock &strmBlk, const Utf8Str &strKey, PRTTIMESPEC pTimeSpec);
+    static int64_t UnixEpochNsFromKey(const GuestProcessStreamBlock &strmBlk, const Utf8Str &strKey);
+    /** @}  */
+
+    /** @name helper functions to work with IPRT stuff.
+     * @{ */
+    RTFMODE GetFileMode(void) const;
+    /** @}  */
+
+    Utf8Str              mName;
+    FsObjType_T          mType;
+    Utf8Str              mFileAttrs;
+    int64_t              mObjectSize;
+    int64_t              mAllocatedSize;
+    int64_t              mAccessTime;
+    int64_t              mBirthTime;
+    int64_t              mChangeTime;
+    int64_t              mModificationTime;
+    Utf8Str              mUserName;
+    int32_t              mUID;
+    int32_t              mGID;
+    Utf8Str              mGroupName;
+    Utf8Str              mACL;
+    int64_t              mNodeID;
+    uint32_t             mNodeIDDevice;
+    uint32_t             mNumHardLinks;
+    uint32_t             mDeviceNumber;
+    uint32_t             mGenerationID;
+    uint32_t             mUserFlags;
+};
+
+
+/**
+ * Structure for keeping all the relevant guest session
+ * startup parameters around.
+ */
+class GuestSessionStartupInfo
+{
+public:
+
+    GuestSessionStartupInfo(void)
+        : mID(UINT32_MAX)
+        , mIsInternal(false /* Non-internal session */)
+        , mOpenTimeoutMS(30 * 1000 /* 30s opening timeout */)
+        , mOpenFlags(0 /* No opening flags set */) { }
+
+    /** The session's friendly name. Optional. */
+    Utf8Str                     mName;
+    /** The session's unique ID. Used to encode a context ID.
+     *  UINT32_MAX if not initialized. */
+    uint32_t                    mID;
+    /** Flag indicating if this is an internal session
+     *  or not. Internal session are not accessible by
+     *  public API clients. */
+    bool                        mIsInternal;
+    /** Timeout (in ms) used for opening the session. */
+    uint32_t                    mOpenTimeoutMS;
+    /** Session opening flags. */
+    uint32_t                    mOpenFlags;
+};
+
+
+/**
+ * Structure for keeping all the relevant guest process
+ * startup parameters around.
+ */
+class GuestProcessStartupInfo
+{
+public:
+
+    GuestProcessStartupInfo(void)
+        : mFlags(ProcessCreateFlag_None)
+        , mTimeoutMS(UINT32_MAX /* No timeout by default */)
+        , mPriority(ProcessPriority_Default)
+        , mAffinity(0) { }
+
+    /** The process' friendly name. */
+    Utf8Str                     mName;
+    /** The executable. */
+    Utf8Str                     mExecutable;
+    /** Arguments vector (starting with argument \#0). */
+    ProcessArguments            mArguments;
+    /** The process environment change record.  */
+    GuestEnvironmentChanges     mEnvironmentChanges;
+    /** Process creation flags. */
+    uint32_t                    mFlags;
+    /** Timeout (in ms) the process is allowed to run.
+     *  Specify UINT32_MAX if no timeout (unlimited run time) is given. */
+    ULONG                       mTimeoutMS;
+    /** Process priority. */
+    ProcessPriority_T           mPriority;
+    /** Process affinity. At the moment we
+     *  only support 64 VCPUs. API and
+     *  guest can do more already!  */
+    uint64_t                    mAffinity;
+};
+
+
+/**
+ * Class representing the "value" side of a "key=value" pair.
+ */
+class GuestProcessStreamValue
+{
+public:
+
+    GuestProcessStreamValue(void) { }
+    GuestProcessStreamValue(const char *pszValue, size_t cwcValue = RTSTR_MAX)
+        : mValue(pszValue, cwcValue) {}
+
+    GuestProcessStreamValue(const GuestProcessStreamValue& aThat)
+           : mValue(aThat.mValue) { }
+
+    /** Copy assignment operator. */
+    GuestProcessStreamValue &operator=(GuestProcessStreamValue const &a_rThat) RT_NOEXCEPT
+    {
+        mValue = a_rThat.mValue;
+
+        return *this;
+    }
+
+    Utf8Str mValue;
+};
+
+/** Map containing "key=value" pairs of a guest process stream. */
+typedef std::pair< Utf8Str, GuestProcessStreamValue > GuestCtrlStreamPair;
+typedef std::map < Utf8Str, GuestProcessStreamValue > GuestCtrlStreamPairMap;
+typedef std::map < Utf8Str, GuestProcessStreamValue >::iterator GuestCtrlStreamPairMapIter;
+typedef std::map < Utf8Str, GuestProcessStreamValue >::const_iterator GuestCtrlStreamPairMapIterConst;
+
+class GuestProcessStream;
+
+/**
+ * Class representing a block of stream pairs (key=value). Each block in a raw guest
+ * output stream is separated by "\0\0", each pair is separated by "\0". The overall
+ * end of a guest stream is marked by "\0\0\0\0".
+ *
+ * An empty stream block will be treated as being incomplete.
+ *
+ * Only used for the busybox-like toolbox commands within VBoxService.
+ * Deprecated, do not use anymore.
+ */
+class GuestProcessStreamBlock
+{
+    friend GuestProcessStream;
+
+public:
+
+    GuestProcessStreamBlock(void);
+
+    virtual ~GuestProcessStreamBlock(void);
+
+public:
+
+    void Clear(void);
+
+#ifdef DEBUG
+    void DumpToLog(void) const;
+#endif
+
+    const char *GetString(const char *pszKey) const;
+    size_t      GetCount(void) const;
+    int         GetVrc(bool fSucceedIfNotFound = false) const;
+    int         GetInt64Ex(const char *pszKey, int64_t *piVal) const;
+    int64_t     GetInt64(const char *pszKey) const;
+    int         GetUInt32Ex(const char *pszKey, uint32_t *puVal) const;
+    uint32_t    GetUInt32(const char *pszKey, uint32_t uDefault = 0) const;
+    int32_t     GetInt32(const char *pszKey, int32_t iDefault = 0) const;
+
+    bool        IsComplete(void) const { return !m_mapPairs.empty() && m_fComplete; }
+    bool        IsEmpty(void) const { return m_mapPairs.empty(); }
+
+    int         SetValueEx(const char *pszKey, size_t cwcKey, const char *pszValue, size_t cwcValue, bool fOverwrite = false);
+    int         SetValue(const char *pszKey, const char *pszValue);
+
+protected:
+
+    /** Wheter the stream block is marked as complete.
+     *  An empty stream block is considered as incomplete. */
+    bool                   m_fComplete;
+    /** Map of stream pairs this block contains.*/
+    GuestCtrlStreamPairMap m_mapPairs;
+};
+
+/** Vector containing multiple allocated stream pair objects. */
+typedef std::vector< GuestProcessStreamBlock > GuestCtrlStreamObjects;
+typedef std::vector< GuestProcessStreamBlock >::iterator GuestCtrlStreamObjectsIter;
+typedef std::vector< GuestProcessStreamBlock >::const_iterator GuestCtrlStreamObjectsIterConst;
+
+/** Defines a single terminator as a single char. */
+#define GUESTTOOLBOX_STRM_TERM                      '\0'
+/** Defines a single terminator as a string. */
+#define GUESTTOOLBOX_STRM_TERM_STR                  "\0"
+/** Defines the termination sequence for a single key/value pair. */
+#define GUESTTOOLBOX_STRM_TERM_PAIR_STR             GUESTTOOLBOX_STRM_TERM_STR
+/** Defines the termination sequence for a single stream block. */
+#define GUESTTOOLBOX_STRM_TERM_BLOCK_STR            GUESTTOOLBOX_STRM_TERM_STR GUESTTOOLBOX_STRM_TERM_STR
+/** Defines the termination sequence for the stream. */
+#define GUESTTOOLBOX_STRM_TERM_STREAM_STR           GUESTTOOLBOX_STRM_TERM_STR GUESTTOOLBOX_STRM_TERM_STR GUESTTOOLBOX_STRM_TERM_STR GUESTTOOLBOX_STRM_TERM_STR
+/** Defines how many consequtive terminators a key/value pair has. */
+#define GUESTTOOLBOX_STRM_PAIR_TERM_CNT             1
+/** Defines how many consequtive terminators a stream block has. */
+#define GUESTTOOLBOX_STRM_BLK_TERM_CNT              2
+/** Defines how many consequtive terminators a stream has. */
+#define GUESTTOOLBOX_STRM_TERM_CNT                  4
+
+/**
+ * Class for parsing machine-readable guest process output by VBoxService'
+ * toolbox commands ("vbox_ls", "vbox_stat" etc), aka "guest stream".
+ */
+class GuestProcessStream
+{
+
+public:
+
+    GuestProcessStream();
+
+    virtual ~GuestProcessStream();
+
+public:
+
+    int AddData(const BYTE *pbData, size_t cbData);
+
+    void Destroy();
+
+#ifdef DEBUG
+    void Dump(const char *pszFile);
+#endif
+
+    size_t GetOffset(void) const { return m_offBuf; }
+
+    size_t GetSize(void) const { return m_cbUsed; }
+
+    size_t GetBlocks(void) const { return m_cBlocks; }
+
+    int ParseBlock(GuestProcessStreamBlock &streamBlock);
+
+protected:
+
+    /** Maximum allowed size the stream buffer can grow to.
+     *  Defaults to 32 MB. */
+    size_t m_cbMax;
+    /** Currently allocated size of internal stream buffer. */
+    size_t m_cbAllocated;
+    /** Currently used size at m_offBuffer. */
+    size_t m_cbUsed;
+    /** Current byte offset within the internal stream buffer. */
+    size_t m_offBuf;
+    /** Internal stream buffer. */
+    BYTE  *m_pbBuffer;
+    /** How many completed stream blocks already were processed. */
+    size_t m_cBlocks;
+};
+
+class Guest;
+class Progress;
+
+class GuestWaitEventPayload
+{
+
+public:
+
+    GuestWaitEventPayload(void)
+        : uType(0)
+        , cbData(0)
+        , pvData(NULL)
+    { }
+
+    /**
+     * Initialization constructor.
+     *
+     * @throws  VBox status code (vrc).
+     *
+     * @param   uTypePayload    Payload type to set.
+     * @param   pvPayload       Pointer to payload data to set (deep copy).
+     * @param   cbPayload       Size (in bytes) of payload data to set.
+     */
+    GuestWaitEventPayload(uint32_t uTypePayload, const void *pvPayload, uint32_t cbPayload)
+        : uType(0)
+        , cbData(0)
+        , pvData(NULL)
+    {
+        int vrc = copyFrom(uTypePayload, pvPayload, cbPayload);
+        if (RT_FAILURE(vrc))
+            throw vrc;
+    }
+
+    virtual ~GuestWaitEventPayload(void)
+    {
+        Clear();
+    }
+
+    GuestWaitEventPayload& operator=(const GuestWaitEventPayload &that)
+    {
+        CopyFromDeep(that);
+        return *this;
+    }
+
+public:
+
+    void Clear(void)
+    {
+        if (pvData)
+        {
+            Assert(cbData);
+            RTMemFree(pvData);
+            cbData = 0;
+            pvData = NULL;
+        }
+        uType = 0;
+    }
+
+    int CopyFromDeep(const GuestWaitEventPayload &payload)
+    {
+        return copyFrom(payload.uType, payload.pvData, payload.cbData);
+    }
+
+    const void* Raw(void) const { return pvData; }
+
+    size_t Size(void) const { return cbData; }
+
+    uint32_t Type(void) const { return uType; }
+
+    void* MutableRaw(void) { return pvData; }
+
+    Utf8Str ToString(void)
+    {
+        const char  *pszStr = (const char *)pvData;
+              size_t cbStr  = cbData;
+
+        if (RT_FAILURE(RTStrValidateEncodingEx(pszStr, cbStr,
+                                               RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED | RTSTR_VALIDATE_ENCODING_EXACT_LENGTH)))
+        {
+            AssertFailed();
+            return "";
+        }
+
+        return Utf8Str(pszStr, cbStr);
+    }
+
+protected:
+
+    int copyFrom(uint32_t uTypePayload, const void *pvPayload, uint32_t cbPayload)
+    {
+        if (cbPayload > _64K) /* Paranoia. */
+            return VERR_TOO_MUCH_DATA;
+
+        Clear();
+
+        int vrc = VINF_SUCCESS;
+        if (cbPayload)
+        {
+            pvData = RTMemAlloc(cbPayload);
+            if (pvData)
+            {
+                uType = uTypePayload;
+
+                memcpy(pvData, pvPayload, cbPayload);
+                cbData = cbPayload;
+            }
+            else
+                vrc = VERR_NO_MEMORY;
+        }
+        else
+        {
+            uType = uTypePayload;
+
+            pvData = NULL;
+            cbData = 0;
+        }
+
+        return vrc;
+    }
+
+protected:
+
+    /** Type of payload. */
+    uint32_t uType;
+    /** Size (in bytes) of payload. */
+    uint32_t cbData;
+    /** Pointer to actual payload data. */
+    void    *pvData;
+};
+
+class GuestWaitEventBase
+{
+
+protected:
+
+    GuestWaitEventBase(void);
+    virtual ~GuestWaitEventBase(void);
+
+public:
+
+    uint32_t                ContextID(void) { return mCID; };
+    int                     GuestResult(void) { return mGuestRc; }
+    int                     Result(void) { return mVrc; }
+    GuestWaitEventPayload  &Payload(void) { return mPayload; }
+    int                     SignalInternal(int vrc, int vrcGuest, const GuestWaitEventPayload *pPayload);
+    int                     Wait(RTMSINTERVAL uTimeoutMS);
+
+protected:
+
+    int             Init(uint32_t uCID);
+
+protected:
+
+    /** Shutdown indicator. */
+    bool                       mfAborted;
+    /** Associated context ID (CID). */
+    uint32_t                   mCID;
+    /** The event semaphore for triggering the actual event. */
+    RTSEMEVENT                 mEventSem;
+    /** The event's overall result.
+     * If set to VERR_GSTCTL_GUEST_ERROR, mGuestRc will contain the actual
+     * error code from the guest side. */
+    int                        mVrc;
+    /** The event'S overall result from the guest side.
+     * If used, mVrc must be set to VERR_GSTCTL_GUEST_ERROR. */
+    int                        mGuestRc;
+    /** The event's payload data. Optional. */
+    GuestWaitEventPayload      mPayload;
+};
+
+/** List of public guest event types. */
+typedef std::list < VBoxEventType_T > GuestEventTypes;
+
+class GuestWaitEvent : public GuestWaitEventBase
+{
+
+public:
+
+    GuestWaitEvent(void);
+    virtual ~GuestWaitEvent(void);
+
+public:
+
+    int                              Init(uint32_t uCID);
+    int                              Init(uint32_t uCID, const GuestEventTypes &lstEvents);
+    int                              Cancel(void);
+    const ComPtr<IEvent>             Event(void) { return mEvent; }
+    bool                             HasGuestError(void) const { return mVrc == VERR_GSTCTL_GUEST_ERROR; }
+    int                              GetGuestError(void) const { return mGuestRc; }
+    int                              SignalExternal(IEvent *pEvent);
+    const GuestEventTypes           &Types(void) { return mEventTypes; }
+    size_t                           TypeCount(void) { return mEventTypes.size(); }
+
+protected:
+
+    /** List of public event types this event should
+     *  be signalled on. Optional. */
+    GuestEventTypes            mEventTypes;
+    /** Pointer to the actual public event, if any. */
+    ComPtr<IEvent>             mEvent;
+};
+/** Map of pointers to guest events. The primary key
+ *  contains the context ID. */
+typedef std::map < uint32_t, GuestWaitEvent* > GuestWaitEvents;
+/** Map of wait events per public guest event. Nice for
+ *  faster lookups when signalling a whole event group. */
+typedef std::map < VBoxEventType_T, GuestWaitEvents > GuestEventGroup;
+
+class GuestBase
+{
+
+public:
+
+    GuestBase(void);
+    virtual ~GuestBase(void);
+
+public:
+
+    /** Signals a wait event using a public guest event; also used for
+     *  for external event listeners. */
+    int signalWaitEvent(VBoxEventType_T aType, IEvent *aEvent);
+    /** Signals a wait event using a guest vrc. */
+    int signalWaitEventInternal(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, int vrcGuest, const GuestWaitEventPayload *pPayload);
+    /** Signals a wait event without letting public guest events know,
+     *  extended director's cut version. */
+    int signalWaitEventInternalEx(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, int vrc, int vrcGuest, const GuestWaitEventPayload *pPayload);
+
+public:
+
+    int baseInit(void);
+    void baseUninit(void);
+    int cancelWaitEvents(void);
+    int dispatchGeneric(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
+    int generateContextID(uint32_t uSessionID, uint32_t uObjectID, uint32_t *puContextID);
+    int registerWaitEvent(uint32_t uSessionID, uint32_t uObjectID, GuestWaitEvent **ppEvent);
+    int registerWaitEventEx(uint32_t uSessionID, uint32_t uObjectID, const GuestEventTypes &lstEvents, GuestWaitEvent **ppEvent);
+    int unregisterWaitEvent(GuestWaitEvent *pEvent);
+    int waitForEvent(GuestWaitEvent *pEvent, uint32_t uTimeoutMS, VBoxEventType_T *pType, IEvent **ppEvent);
+
+public:
+
+    static FsObjType_T fileModeToFsObjType(RTFMODE fMode);
+    static const char *fsObjTypeToStr(FsObjType_T enmType);
+    static const char *pathStyleToStr(PathStyle_T enmPathStyle);
+    static Utf8Str getErrorAsString(const Utf8Str &strAction, const GuestErrorInfo& guestErrorInfo);
+    static Utf8Str getErrorAsString(const GuestErrorInfo &guestErrorInfo);
+
+protected:
+
+    /** Pointer to the console object. Needed
+     *  for HGCM (VMMDev) communication. */
+    Console                 *mConsole;
+    /**  The next context ID counter component for this object. */
+    uint32_t                 mNextContextID;
+    /** Local listener for handling the waiting events
+     *  internally. */
+    ComPtr<IEventListener>   mLocalListener;
+    /** Critical section for wait events access. */
+    RTCRITSECT               mWaitEventCritSect;
+    /** Map of registered wait events per event group. */
+    GuestEventGroup          mWaitEventGroups;
+    /** Map of registered wait events. */
+    GuestWaitEvents          mWaitEvents;
+};
+
+/**
+ * Virtual class (interface) for guest objects (processes, files, ...) --
+ * contains all per-object callback management.
+ */
+class GuestObject : public GuestBase
+{
+    friend class GuestSession;
+
+public:
+
+    GuestObject(void);
+    virtual ~GuestObject(void);
+
+public:
+
+    ULONG getObjectID(void) { return mObjectID; }
+
+protected:
+
+    /**
+     * Called by IGuestSession when the session status has been changed.
+     *
+     * @returns VBox status code.
+     * @param   enmSessionStatus    New session status.
+     */
+    virtual int i_onSessionStatusChange(GuestSessionStatus_T enmSessionStatus) = 0;
+
+    /**
+     * Called by IGuestSession right before this object gets
+     * unregistered (removed) from the public object list.
+     */
+    virtual int i_onUnregister(void) = 0;
+
+    /** Callback dispatcher -- must be implemented by the actual object. */
+    virtual int i_callbackDispatcher(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb) = 0;
+
+protected:
+
+    int bindToSession(Console *pConsole, GuestSession *pSession, uint32_t uObjectID);
+    int registerWaitEvent(const GuestEventTypes &lstEvents, GuestWaitEvent **ppEvent);
+    int sendMessage(uint32_t uFunction, uint32_t cParms, PVBOXHGCMSVCPARM paParms);
+
+protected:
+
+    /** @name Common parameters for all derived objects.  They have their own
+     * mData structure to keep their specific data around.
+     * @{ */
+    /** Pointer to parent session. Per definition
+     *  this objects *always* lives shorter than the
+     *  parent.
+     * @todo r=bird: When wanting to use mSession in the
+     * IGuestProcess::getEnvironment() implementation I wanted to access
+     * GuestSession::mData::mpBaseEnvironment.  Seeing the comment in
+     * GuestProcess::terminate() saying:
+     *      "Now only API clients still can hold references to it."
+     * and recalling seeing similar things in VirtualBox.xidl or some such place,
+     * I'm wondering how this "per definition" behavior is enforced.  Is there any
+     * GuestProcess:uninit() call or similar magic that invalidates objects that
+     * GuestSession loses track of in place like GuestProcess::terminate() that I've
+     * failed to spot?
+     *
+     * Please enlighten me.
+     */
+    GuestSession            *mSession;
+    /** The object ID -- must be unique for each guest
+     *  object and is encoded into the context ID. Must
+     *  be set manually when initializing the object.
+     *
+     *  For guest processes this is the internal PID,
+     *  for guest files this is the internal file ID. */
+    uint32_t                 mObjectID;
+    /** @} */
+};
+
+/** Returns the path separator based on \a a_enmPathStyle as a C-string. */
+#define PATH_STYLE_SEP_STR(a_enmPathStyle) a_enmPathStyle == PathStyle_DOS ? "\\" : "/"
+#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
+# define PATH_STYLE_NATIVE               PathStyle_DOS
+#else
+# define PATH_STYLE_NATIVE               PathStyle_UNIX
+#endif
+
+/**
+ * Class for handling guest / host path functions.
+ */
+class GuestPath
+{
+private:
+
+    /**
+     * Default constructor.
+     *
+     * Not directly instantiable (yet).
+     */
+    GuestPath(void) { }
+
+public:
+
+    /** @name Static helper functions.
+     * @{ */
+    static int BuildDestinationPath(const Utf8Str &strSrcPath, PathStyle_T enmSrcPathStyle, Utf8Str &strDstPath, PathStyle_T enmDstPathStyle);
+    static int Translate(Utf8Str &strPath, PathStyle_T enmSrcPathStyle, PathStyle_T enmDstPathStyle, bool fForce = false);
+    /** @}  */
+};
+#endif /* !MAIN_INCLUDED_GuestCtrlImplPrivate_h */
+
diff --git a/src/VBox/Main/include/GuestDebugControlImpl.h b/src/VBox/Main/include/GuestDebugControlImpl.h
new file mode 100644
index 00000000..76263a13
--- /dev/null
+++ b/src/VBox/Main/include/GuestDebugControlImpl.h
@@ -0,0 +1,82 @@
+/* $Id: GuestDebugControlImpl.h $ */
+/** @file
+ *
+ * VirtualBox/GuestDebugControl COM class implementation
+ */
+
+/*
+ * Copyright (C) 2022-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
+ */
+
+#ifndef MAIN_INCLUDED_GuestDebugControlImpl_h
+#define MAIN_INCLUDED_GuestDebugControlImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "GuestDebugControlWrap.h"
+
+namespace settings
+{
+    struct Debugging;
+}
+
+class ATL_NO_VTABLE GuestDebugControl :
+    public GuestDebugControlWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(GuestDebugControl)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Machine *aParent);
+    HRESULT init(Machine *aParent, GuestDebugControl *aThat);
+    HRESULT initCopy(Machine *aParent, GuestDebugControl *aThat);
+    void uninit();
+
+    // public internal methods
+    HRESULT i_loadSettings(const settings::Debugging &data);
+    HRESULT i_saveSettings(settings::Debugging &data);
+    void i_rollback();
+    void i_commit();
+    void i_copyFrom(GuestDebugControl *aThat);
+    Machine *i_getMachine() const;
+
+private:
+
+    // wrapped IGuestDebugControl properties
+    HRESULT getDebugProvider(GuestDebugProvider_T *aDebugProvider);
+    HRESULT setDebugProvider(GuestDebugProvider_T aDebugProvider);
+    HRESULT getDebugIoProvider(GuestDebugIoProvider_T *aDebugIoProvider);
+    HRESULT setDebugIoProvider(GuestDebugIoProvider_T aDebugIoProvider);
+    HRESULT getDebugAddress(com::Utf8Str &aAddress);
+    HRESULT setDebugAddress(const com::Utf8Str &aAddress);
+    HRESULT getDebugPort(ULONG *aPort);
+    HRESULT setDebugPort(ULONG aPort);
+
+    struct Data;
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_GuestDebugControlImpl_h */
diff --git a/src/VBox/Main/include/GuestDirectoryImpl.h b/src/VBox/Main/include/GuestDirectoryImpl.h
new file mode 100644
index 00000000..9dc2223b
--- /dev/null
+++ b/src/VBox/Main/include/GuestDirectoryImpl.h
@@ -0,0 +1,108 @@
+/* $Id: GuestDirectoryImpl.h $ */
+/** @file
+ * VirtualBox Main - Guest directory handling implementation.
+ */
+
+/*
+ * Copyright (C) 2012-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
+ */
+
+#ifndef MAIN_INCLUDED_GuestDirectoryImpl_h
+#define MAIN_INCLUDED_GuestDirectoryImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "GuestDirectoryWrap.h"
+#include "GuestFsObjInfoImpl.h"
+#include "GuestProcessImpl.h"
+
+class GuestSession;
+
+/**
+ * TODO
+ */
+class ATL_NO_VTABLE GuestDirectory :
+    public GuestDirectoryWrap,
+    public GuestObject
+{
+public:
+    /** @name COM and internal init/term/mapping cruft.
+     * @{ */
+    DECLARE_COMMON_CLASS_METHODS(GuestDirectory)
+
+    int     init(Console *pConsole, GuestSession *pSession, ULONG aObjectID, const GuestDirectoryOpenInfo &openInfo);
+    void    uninit(void);
+
+    HRESULT FinalConstruct(void);
+    void    FinalRelease(void);
+    /** @}  */
+
+public:
+    /** @name Implemented virtual methods from GuestObject.
+     * @{ */
+    int            i_callbackDispatcher(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
+    int            i_onUnregister(void);
+    int            i_onSessionStatusChange(GuestSessionStatus_T enmSessionStatus);
+    /** @}  */
+
+public:
+    /** @name Public internal methods.
+     * @{ */
+    int            i_closeInternal(int *pvrcGuest);
+    int            i_read(ComObjPtr<GuestFsObjInfo> &fsObjInfo, int *pvrcGuest);
+    int            i_readInternal(GuestFsObjData &objData, int *prcGuest);
+    /** @}  */
+
+public:
+    /** @name Public static internal methods.
+     * @{ */
+    static Utf8Str i_guestErrorToString(int vrcGuest, const char *pcszWhat);
+    /** @}  */
+
+private:
+
+    /** Wrapped @name IGuestDirectory properties
+     * @{ */
+    HRESULT getDirectoryName(com::Utf8Str &aDirectoryName);
+    HRESULT getFilter(com::Utf8Str &aFilter);
+    /** @}  */
+
+    /** Wrapped @name IGuestDirectory methods.
+     * @{ */
+    HRESULT close();
+    HRESULT read(ComPtr<IFsObjInfo> &aObjInfo);
+    /** @}  */
+
+    struct Data
+    {
+        /** The directory's open info. */
+        GuestDirectoryOpenInfo     mOpenInfo;
+        /** The process tool instance to use. */
+        GuestProcessTool           mProcessTool;
+        /** Object data cache.
+         *  Its mName attribute acts as a beacon if the cache is valid or not. */
+        GuestFsObjData             mObjData;
+    } mData;
+};
+
+#endif /* !MAIN_INCLUDED_GuestDirectoryImpl_h */
+
diff --git a/src/VBox/Main/include/GuestDnDPrivate.h b/src/VBox/Main/include/GuestDnDPrivate.h
new file mode 100644
index 00000000..ca5d3a96
--- /dev/null
+++ b/src/VBox/Main/include/GuestDnDPrivate.h
@@ -0,0 +1,1108 @@
+/* $Id: GuestDnDPrivate.h $ */
+/** @file
+ * Private guest drag and drop code, used by GuestDnDTarget +
+ * GuestDnDSource.
+ */
+
+/*
+ * Copyright (C) 2011-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
+ */
+
+#ifndef MAIN_INCLUDED_GuestDnDPrivate_h
+#define MAIN_INCLUDED_GuestDnDPrivate_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/dir.h>
+#include <iprt/file.h>
+#include <iprt/path.h>
+
+#include <VBox/hgcmsvc.h> /* For PVBOXHGCMSVCPARM. */
+#include <VBox/GuestHost/DragAndDrop.h>
+#include <VBox/GuestHost/DragAndDropDefs.h>
+#include <VBox/HostServices/DragAndDropSvc.h>
+
+/**
+ * Forward prototype declarations.
+ */
+class Guest;
+class GuestDnDBase;
+class GuestDnDState;
+class GuestDnDSource;
+class GuestDnDTarget;
+class Progress;
+
+/**
+ * Type definitions.
+ */
+
+/** List (vector) of MIME types. */
+typedef std::vector<com::Utf8Str> GuestDnDMIMEList;
+
+/**
+ * Class to handle a guest DnD callback event.
+ */
+class GuestDnDCallbackEvent
+{
+public:
+
+    GuestDnDCallbackEvent(void)
+        : m_SemEvent(NIL_RTSEMEVENT)
+        , m_vrc(VINF_SUCCESS) { }
+
+    virtual ~GuestDnDCallbackEvent(void);
+
+public:
+
+    int Reset(void);
+
+    int Notify(int vrc = VINF_SUCCESS);
+
+    int Result(void) const { return m_vrc; }
+
+    int Wait(RTMSINTERVAL msTimeout);
+
+protected:
+
+    /** Event semaphore to notify on error/completion. */
+    RTSEMEVENT m_SemEvent;
+    /** Callback result. */
+    int        m_vrc;
+};
+
+/**
+ * Struct for handling the (raw) meta data.
+ */
+struct GuestDnDMetaData
+{
+    GuestDnDMetaData(void)
+        : pvData(NULL)
+        , cbData(0)
+        , cbAllocated(0)
+        , cbAnnounced(0) { }
+
+    virtual ~GuestDnDMetaData(void)
+    {
+        reset();
+    }
+
+    /**
+     * Adds new meta data.
+     *
+     * @returns New (total) meta data size in bytes.
+     * @param   pvDataAdd       Pointer of data to add.
+     * @param   cbDataAdd       Size (in bytes) of data to add.
+     */
+    size_t add(const void *pvDataAdd, size_t cbDataAdd)
+    {
+        LogFlowThisFunc(("cbAllocated=%zu, cbAnnounced=%zu, pvDataAdd=%p, cbDataAdd=%zu\n",
+                         cbAllocated, cbAnnounced, pvDataAdd, cbDataAdd));
+        if (!cbDataAdd)
+            return 0;
+        AssertPtrReturn(pvDataAdd, 0);
+
+        const size_t cbAllocatedTmp = cbData + cbDataAdd;
+        if (cbAllocatedTmp > cbAllocated)
+        {
+            int vrc = resize(cbAllocatedTmp);
+            if (RT_FAILURE(vrc))
+                return 0;
+        }
+
+        Assert(cbAllocated >= cbData + cbDataAdd);
+        memcpy((uint8_t *)pvData + cbData, pvDataAdd, cbDataAdd);
+
+        cbData     += cbDataAdd;
+        cbAnnounced = cbData;
+
+        return cbData;
+    }
+
+    /**
+     * Adds new meta data.
+     *
+     * @returns New (total) meta data size in bytes.
+     * @param   vecAdd          Meta data to add.
+     */
+    size_t add(const std::vector<BYTE> &vecAdd)
+    {
+        if (!vecAdd.size())
+            return 0;
+
+        if (vecAdd.size() > UINT32_MAX) /* Paranoia. */
+            return 0;
+
+        return add(&vecAdd.front(), (uint32_t)vecAdd.size());
+    }
+
+    /**
+     * Resets (clears) all data.
+     */
+    void reset(void)
+    {
+        strFmt = "";
+
+        if (pvData)
+        {
+            Assert(cbAllocated);
+            RTMemFree(pvData);
+            pvData = NULL;
+        }
+
+        cbData      = 0;
+        cbAllocated = 0;
+        cbAnnounced = 0;
+    }
+
+    /**
+     * Resizes the allocation size.
+     *
+     * @returns VBox status code.
+     * @param   cbSize          New allocation size (in bytes).
+     */
+    int resize(size_t cbSize)
+    {
+        if (!cbSize)
+        {
+            reset();
+            return VINF_SUCCESS;
+        }
+
+        if (cbSize == cbAllocated)
+            return VINF_SUCCESS;
+
+        cbSize = RT_ALIGN_Z(cbSize, PAGE_SIZE);
+
+        if (cbSize > _32M) /* Meta data can be up to 32MB. */
+            return VERR_BUFFER_OVERFLOW;
+
+        void *pvTmp = NULL;
+        if (!cbAllocated)
+        {
+            Assert(cbData == 0);
+            pvTmp = RTMemAllocZ(cbSize);
+        }
+        else
+        {
+            AssertPtr(pvData);
+            pvTmp = RTMemRealloc(pvData, cbSize);
+        }
+
+        if (pvTmp)
+        {
+            pvData      = pvTmp;
+            cbAllocated = cbSize;
+            return VINF_SUCCESS;
+        }
+
+        return VERR_NO_MEMORY;
+    }
+
+    /** Format string of this meta data. */
+    com::Utf8Str strFmt;
+    /** Pointer to allocated meta data. */
+    void        *pvData;
+    /** Used bytes of meta data. Must not exceed cbAllocated. */
+    size_t       cbData;
+    /** Size (in bytes) of allocated meta data. */
+    size_t       cbAllocated;
+    /** Size (in bytes) of announced meta data. */
+    size_t       cbAnnounced;
+};
+
+/**
+ * Struct for accounting shared DnD data to be sent/received.
+ */
+struct GuestDnDData
+{
+    GuestDnDData(void)
+        : cbExtra(0)
+        , cbProcessed(0) { }
+
+    virtual ~GuestDnDData(void)
+    {
+        reset();
+    }
+
+    /**
+     * Adds processed data to the internal accounting.
+     *
+     * @returns New processed data size.
+     * @param   cbDataAdd       Bytes to add as done processing.
+     */
+    size_t addProcessed(size_t cbDataAdd)
+    {
+        const size_t cbTotal = getTotalAnnounced(); RT_NOREF(cbTotal);
+        AssertReturn(cbProcessed + cbDataAdd <= cbTotal, 0);
+        cbProcessed += cbDataAdd;
+        return cbProcessed;
+    }
+
+    /**
+     * Returns whether all data has been processed or not.
+     *
+     * @returns \c true if all data has been processed, \c false if not.
+     */
+    bool isComplete(void) const
+    {
+        const size_t cbTotal = getTotalAnnounced();
+        LogFlowFunc(("cbProcessed=%zu, cbTotal=%zu\n", cbProcessed, cbTotal));
+        AssertReturn(cbProcessed <= cbTotal, true);
+        return (cbProcessed == cbTotal);
+    }
+
+    /**
+     * Returns the percentage (0-100) of the already processed data.
+     *
+     * @returns Percentage (0-100) of the already processed data.
+     */
+    uint8_t getPercentComplete(void) const
+    {
+        const size_t cbTotal = getTotalAnnounced();
+        return (uint8_t)(cbProcessed * 100 / RT_MAX(cbTotal, 1));
+    }
+
+    /**
+     * Returns the remaining (outstanding) data left for processing.
+     *
+     * @returns Remaining (outstanding) data (in bytes) left for processing.
+     */
+    size_t getRemaining(void) const
+    {
+        const size_t cbTotal = getTotalAnnounced();
+        AssertReturn(cbProcessed <= cbTotal, 0);
+        return cbTotal - cbProcessed;
+    }
+
+    /**
+     * Returns the total data size (in bytes) announced.
+     *
+     * @returns Total data size (in bytes) announced.
+     */
+    size_t getTotalAnnounced(void) const
+    {
+        return Meta.cbAnnounced + cbExtra;
+    }
+
+    /**
+     * Returns the total data size (in bytes) available.
+     * For receiving data, this represents the already received data.
+     * For sending data, this represents the data left to send.
+     *
+     * @returns Total data size (in bytes) available.
+     */
+    size_t getTotalAvailable(void) const
+    {
+        return Meta.cbData + cbExtra;
+    }
+
+    /**
+     * Resets all data.
+     */
+    void reset(void)
+    {
+        Meta.reset();
+
+        cbExtra     = 0;
+        cbProcessed = 0;
+    }
+
+    /** For storing the actual meta data.
+     *  This might be an URI list or just plain raw data,
+     *  according to the format being sent. */
+    GuestDnDMetaData   Meta;
+    /** Extra data to send/receive (in bytes). Can be 0 for raw data.
+     *  For (file) transfers this is the total size for all files. */
+    size_t             cbExtra;
+    /** Overall size (in bytes) of processed data. */
+    size_t             cbProcessed;
+};
+
+/** Initial object context state / no state set. */
+#define DND_OBJ_STATE_NONE           0
+/** The header was received / sent. */
+#define DND_OBJ_STATE_HAS_HDR        RT_BIT(0)
+/** Validation mask for object context state. */
+#define DND_OBJ_STATE_VALID_MASK     UINT32_C(0x00000001)
+
+/**
+ * Base class for keeping around DnD (file) transfer data.
+ * Used for sending / receiving transfer data.
+ */
+struct GuestDnDTransferData
+{
+
+public:
+
+    GuestDnDTransferData(void)
+        : cObjToProcess(0)
+        , cObjProcessed(0)
+        , pvScratchBuf(NULL)
+        , cbScratchBuf(0) { }
+
+    virtual ~GuestDnDTransferData(void)
+    {
+        destroy();
+    }
+
+    /**
+     * Initializes a transfer data object.
+     *
+     * @param   cbBuf           Scratch buffer size (in bytes) to use.
+     *                          If not specified, DND_DEFAULT_CHUNK_SIZE will be used.
+     */
+    int init(size_t cbBuf = DND_DEFAULT_CHUNK_SIZE)
+    {
+        reset();
+
+        pvScratchBuf = RTMemAlloc(cbBuf);
+        if (!pvScratchBuf)
+            return VERR_NO_MEMORY;
+
+        cbScratchBuf = cbBuf;
+        return VINF_SUCCESS;
+    }
+
+    /**
+     * Destroys a transfer data object.
+     */
+    void destroy(void)
+    {
+        reset();
+
+        if (pvScratchBuf)
+        {
+            Assert(cbScratchBuf);
+            RTMemFree(pvScratchBuf);
+            pvScratchBuf = NULL;
+        }
+        cbScratchBuf = 0;
+    }
+
+    /**
+     * Resets a transfer data object.
+     */
+    void reset(void)
+    {
+        LogFlowFuncEnter();
+
+        cObjToProcess = 0;
+        cObjProcessed = 0;
+    }
+
+    /**
+     * Returns whether this transfer object is complete or not.
+     *
+     * @returns \c true if complete, \c false if not.
+     */
+    bool isComplete(void) const
+    {
+        return (cObjProcessed == cObjToProcess);
+    }
+
+    /** Number of objects to process. */
+    uint64_t cObjToProcess;
+    /** Number of objects already processed. */
+    uint64_t cObjProcessed;
+    /** Pointer to an optional scratch buffer to use for
+     *  doing the actual chunk transfers. */
+    void    *pvScratchBuf;
+    /** Size (in bytes) of scratch buffer. */
+    size_t   cbScratchBuf;
+};
+
+/**
+ * Class for keeping around DnD transfer send data (Host -> Guest).
+ */
+struct GuestDnDTransferSendData : public GuestDnDTransferData
+{
+    GuestDnDTransferSendData()
+        : fObjState(0)
+    {
+        RT_ZERO(List);
+        int vrc2 = DnDTransferListInit(&List);
+        AssertRC(vrc2);
+    }
+
+    virtual ~GuestDnDTransferSendData()
+    {
+        destroy();
+    }
+
+    /**
+     * Destroys the object.
+     */
+    void destroy(void)
+    {
+        DnDTransferListDestroy(&List);
+    }
+
+    /**
+     * Resets the object.
+     */
+    void reset(void)
+    {
+        DnDTransferListReset(&List);
+        fObjState = 0;
+
+        GuestDnDTransferData::reset();
+    }
+
+    /** Transfer List to handle. */
+    DNDTRANSFERLIST                     List;
+    /** Current state of object in transfer.
+     *  This is needed for keeping compatibility to old(er) DnD HGCM protocols.
+     *
+     *  At the moment we only support transferring one object at a time. */
+    uint32_t                            fObjState;
+};
+
+/**
+ * Context structure for sending data to the guest.
+ */
+struct GuestDnDSendCtx : public GuestDnDData
+{
+    GuestDnDSendCtx(void);
+
+    /**
+     * Resets the object.
+     */
+    void reset(void);
+
+    /** Pointer to guest target class this context belongs to. */
+    GuestDnDTarget                     *pTarget;
+    /** Pointer to guest state this context belongs to. */
+    GuestDnDState                      *pState;
+    /** Target (VM) screen ID. */
+    uint32_t                            uScreenID;
+    /** Transfer data structure. */
+    GuestDnDTransferSendData            Transfer;
+    /** Callback event to use. */
+    GuestDnDCallbackEvent               EventCallback;
+};
+
+struct GuestDnDTransferRecvData : public GuestDnDTransferData
+{
+    GuestDnDTransferRecvData()
+    {
+        RT_ZERO(DroppedFiles);
+        int vrc2 = DnDDroppedFilesInit(&DroppedFiles);
+        AssertRC(vrc2);
+
+        RT_ZERO(List);
+        vrc2 = DnDTransferListInit(&List);
+        AssertRC(vrc2);
+
+        RT_ZERO(ObjCur);
+        vrc2 = DnDTransferObjectInit(&ObjCur);
+        AssertRC(vrc2);
+    }
+
+    virtual ~GuestDnDTransferRecvData()
+    {
+        destroy();
+    }
+
+    /**
+     * Destroys the object.
+     */
+    void destroy(void)
+    {
+        DnDTransferListDestroy(&List);
+    }
+
+    /**
+     * Resets the object.
+     */
+    void reset(void)
+    {
+        DnDDroppedFilesClose(&DroppedFiles);
+        DnDTransferListReset(&List);
+        DnDTransferObjectReset(&ObjCur);
+
+        GuestDnDTransferData::reset();
+    }
+
+    /** The "VirtualBox Dropped Files" directory on the host we're going
+     *  to utilize for transferring files from guest to the host. */
+    DNDDROPPEDFILES                     DroppedFiles;
+    /** Transfer List to handle.
+     *  Currently we only support one transfer list at a time. */
+    DNDTRANSFERLIST                     List;
+    /** Current transfer object being handled.
+     *  Currently we only support one transfer object at a time. */
+    DNDTRANSFEROBJECT                   ObjCur;
+};
+
+/**
+ * Context structure for receiving data from the guest.
+ */
+struct GuestDnDRecvCtx : public GuestDnDData
+{
+    GuestDnDRecvCtx(void);
+
+    /**
+     * Resets the object.
+     */
+    void reset(void);
+
+    /** Pointer to guest source class this context belongs to. */
+    GuestDnDSource                     *pSource;
+    /** Pointer to guest state this context belongs to. */
+    GuestDnDState                      *pState;
+    /** Formats offered by the guest (and supported by the host). */
+    GuestDnDMIMEList                    lstFmtOffered;
+    /** Original drop format requested to receive from the guest. */
+    com::Utf8Str                        strFmtReq;
+    /** Intermediate drop format to be received from the guest.
+     *  Some original drop formats require a different intermediate
+     *  drop format:
+     *
+     *  Receiving a file link as "text/plain"  requires still to
+     *  receive the file from the guest as "text/uri-list" first,
+     *  then pointing to the file path on the host with the data
+     *  in "text/plain" format returned. */
+    com::Utf8Str                        strFmtRecv;
+    /** Desired drop action to perform on the host.
+     *  Needed to tell the guest if data has to be
+     *  deleted e.g. when moving instead of copying. */
+    VBOXDNDACTION                       enmAction;
+    /** Transfer data structure. */
+    GuestDnDTransferRecvData            Transfer;
+    /** Callback event to use. */
+    GuestDnDCallbackEvent               EventCallback;
+};
+
+/**
+ * Class for maintainig a (buffered) guest DnD message.
+ */
+class GuestDnDMsg
+{
+public:
+
+    GuestDnDMsg(void)
+        : uMsg(0)
+        , cParms(0)
+        , cParmsAlloc(0)
+        , paParms(NULL) { }
+
+    virtual ~GuestDnDMsg(void)
+    {
+        reset();
+    }
+
+public:
+
+    /**
+     * Appends a new HGCM parameter to the message and returns the pointer to it.
+     */
+    PVBOXHGCMSVCPARM getNextParam(void)
+    {
+        if (cParms >= cParmsAlloc)
+        {
+            if (!paParms)
+                paParms = (PVBOXHGCMSVCPARM)RTMemAlloc(4 * sizeof(VBOXHGCMSVCPARM));
+            else
+                paParms = (PVBOXHGCMSVCPARM)RTMemRealloc(paParms, (cParmsAlloc + 4) * sizeof(VBOXHGCMSVCPARM));
+            if (!paParms)
+                throw VERR_NO_MEMORY;
+            RT_BZERO(&paParms[cParmsAlloc], 4 * sizeof(VBOXHGCMSVCPARM));
+            cParmsAlloc += 4;
+        }
+
+        return &paParms[cParms++];
+    }
+
+    /**
+     * Returns the current parameter count.
+     *
+     * @returns Current parameter count.
+     */
+    uint32_t getCount(void) const { return cParms; }
+
+    /**
+     * Returns the pointer to the beginning of the HGCM parameters array. Use with care.
+     *
+     * @returns Pointer to the beginning of the HGCM parameters array.
+     */
+    PVBOXHGCMSVCPARM getParms(void) const { return paParms; }
+
+    /**
+     * Returns the message type.
+     *
+     * @returns Message type.
+     */
+    uint32_t getType(void) const { return uMsg; }
+
+    /**
+     * Resets the object.
+     */
+    void reset(void)
+    {
+        if (paParms)
+        {
+            /* Remove deep copies. */
+            for (uint32_t i = 0; i < cParms; i++)
+            {
+                if (   paParms[i].type == VBOX_HGCM_SVC_PARM_PTR
+                    && paParms[i].u.pointer.size)
+                {
+                    AssertPtr(paParms[i].u.pointer.addr);
+                    RTMemFree(paParms[i].u.pointer.addr);
+                }
+            }
+
+            RTMemFree(paParms);
+            paParms = NULL;
+        }
+
+        uMsg = cParms = cParmsAlloc = 0;
+    }
+
+    /**
+     * Appends a new message parameter of type pointer.
+     *
+     * @returns VBox status code.
+     * @param   pvBuf           Pointer to data to use.
+     * @param   cbBuf           Size (in bytes) of data to use.
+     */
+    int appendPointer(void *pvBuf, uint32_t cbBuf)
+    {
+        PVBOXHGCMSVCPARM pParm = getNextParam();
+        if (!pParm)
+            return VERR_NO_MEMORY;
+
+        void *pvTmp = NULL;
+        if (cbBuf)
+        {
+            AssertPtr(pvBuf);
+            pvTmp = RTMemDup(pvBuf, cbBuf);
+            if (!pvTmp)
+                return VERR_NO_MEMORY;
+        }
+
+        HGCMSvcSetPv(pParm, pvTmp, cbBuf);
+        return VINF_SUCCESS;
+    }
+
+    /**
+     * Appends a new message parameter of type string.
+     *
+     * @returns VBox status code.
+     * @param   pszString       Pointer to string data to use.
+     */
+    int appendString(const char *pszString)
+    {
+        PVBOXHGCMSVCPARM pParm = getNextParam();
+        if (!pParm)
+            return VERR_NO_MEMORY;
+
+        char *pszTemp = RTStrDup(pszString);
+        if (!pszTemp)
+            return VERR_NO_MEMORY;
+
+        HGCMSvcSetStr(pParm, pszTemp);
+        return VINF_SUCCESS;
+    }
+
+    /**
+     * Appends a new message parameter of type uint32_t.
+     *
+     * @returns VBox status code.
+     * @param   u32Val          uint32_t value to use.
+     */
+    int appendUInt32(uint32_t u32Val)
+    {
+        PVBOXHGCMSVCPARM pParm = getNextParam();
+        if (!pParm)
+            return VERR_NO_MEMORY;
+
+        HGCMSvcSetU32(pParm, u32Val);
+        return VINF_SUCCESS;
+    }
+
+    /**
+     * Appends a new message parameter of type uint64_t.
+     *
+     * @returns VBox status code.
+     * @param   u64Val          uint64_t value to use.
+     */
+    int appendUInt64(uint64_t u64Val)
+    {
+        PVBOXHGCMSVCPARM pParm = getNextParam();
+        if (!pParm)
+            return VERR_NO_MEMORY;
+
+        HGCMSvcSetU64(pParm, u64Val);
+        return VINF_SUCCESS;
+    }
+
+    /**
+     * Sets the HGCM message type (function number).
+     *
+     * @param   uMsgType        Message type to set.
+     */
+    void setType(uint32_t uMsgType) { uMsg = uMsgType; }
+
+protected:
+
+    /** Message type. */
+    uint32_t                    uMsg;
+    /** Message parameters. */
+    uint32_t                    cParms;
+    /** Size of array. */
+    uint32_t                    cParmsAlloc;
+    /** Array of HGCM parameters */
+    PVBOXHGCMSVCPARM            paParms;
+};
+
+/** Guest DnD callback function definition. */
+typedef DECLCALLBACKPTR(int, PFNGUESTDNDCALLBACK,(uint32_t uMsg, void *pvParms, size_t cbParms, void *pvUser));
+
+/**
+ * Structure for keeping a guest DnD callback.
+ * Each callback can handle one HGCM message, however, multiple HGCM messages can be registered
+ * to the same callback (function).
+ */
+typedef struct GuestDnDCallback
+{
+    GuestDnDCallback(void)
+        : uMessgage(0)
+        , pfnCallback(NULL)
+        , pvUser(NULL) { }
+
+    GuestDnDCallback(PFNGUESTDNDCALLBACK pvCB, uint32_t uMsg, void *pvUsr = NULL)
+        : uMessgage(uMsg)
+        , pfnCallback(pvCB)
+        , pvUser(pvUsr) { }
+
+    /** The HGCM message ID to handle. */
+    uint32_t             uMessgage;
+    /** Pointer to callback function. */
+    PFNGUESTDNDCALLBACK  pfnCallback;
+    /** Pointer to user-supplied data. */
+    void                *pvUser;
+} GuestDnDCallback;
+
+/** Contains registered callback pointers for specific HGCM message types. */
+typedef std::map<uint32_t, GuestDnDCallback> GuestDnDCallbackMap;
+
+/**
+ * Class for keeping a DnD guest state around.
+ */
+class GuestDnDState
+{
+
+public:
+    DECLARE_TRANSLATE_METHODS(GuestDnDState)
+
+    GuestDnDState(const ComObjPtr<Guest>& pGuest);
+    virtual ~GuestDnDState(void);
+
+public:
+
+    VBOXDNDSTATE get(void) const { return m_enmState; }
+    int set(VBOXDNDSTATE enmState) { LogRel3(("DnD: State %s -> %s\n", DnDStateToStr(m_enmState), DnDStateToStr(enmState))); m_enmState = enmState; return 0; }
+    void lock() { RTCritSectEnter(&m_CritSect); };
+    void unlock() { RTCritSectLeave(&m_CritSect); };
+
+    /** @name Guest response handling.
+     * @{ */
+    int notifyAboutGuestResponse(int vrcGuest = VINF_SUCCESS);
+    int waitForGuestResponseEx(RTMSINTERVAL msTimeout = 3000, int *pvrcGuest = NULL);
+    int waitForGuestResponse(int *pvrcGuest = NULL);
+    /** @} */
+
+    void setActionsAllowed(VBOXDNDACTIONLIST a) { m_dndLstActionsAllowed = a; }
+    VBOXDNDACTIONLIST getActionsAllowed(void) const { return m_dndLstActionsAllowed; }
+
+    void setActionDefault(VBOXDNDACTION a) { m_dndActionDefault = a; }
+    VBOXDNDACTION getActionDefault(void) const { return m_dndActionDefault; }
+
+    void setFormats(const GuestDnDMIMEList &lstFormats) { m_lstFormats = lstFormats; }
+    GuestDnDMIMEList formats(void) const { return m_lstFormats; }
+
+    void reset(void);
+
+    /** @name Callback handling.
+     * @{ */
+    static DECLCALLBACK(int) i_defaultCallback(uint32_t uMsg, void *pvParms, size_t cbParms, void *pvUser);
+    int setCallback(uint32_t uMsg, PFNGUESTDNDCALLBACK pfnCallback, void *pvUser = NULL);
+    /** @} */
+
+    /** @name Progress handling.
+     * @{ */
+    bool isProgressCanceled(void) const;
+    bool isProgressRunning(void) const;
+    int setProgress(unsigned uPercentage, uint32_t uStatus, int vrcOp = VINF_SUCCESS, const Utf8Str &strMsg = Utf8Str::Empty);
+    HRESULT resetProgress(const ComObjPtr<Guest>& pParent, const Utf8Str &strDesc);
+    HRESULT queryProgressTo(IProgress **ppProgress);
+    /** @} */
+
+public:
+
+    /** @name HGCM callback handling.
+       @{ */
+    int onDispatch(uint32_t u32Function, void *pvParms, uint32_t cbParms);
+    /** @}  */
+
+public:
+
+    /** Pointer to context this class is tied to. */
+    void                 *m_pvCtx;
+    RTCRITSECT            m_CritSect;
+    /** The current state we're in. */
+    VBOXDNDSTATE          m_enmState;
+    /** The DnD protocol version to use, depending on the
+     *  installed Guest Additions. See DragAndDropSvc.h for
+     *  a protocol changelog. */
+    uint32_t              m_uProtocolVersion;
+    /** The guest feature flags reported to the host (VBOX_DND_GF_XXX).  */
+    uint64_t              m_fGuestFeatures0;
+    /** Event for waiting for response. */
+    RTSEMEVENT            m_EventSem;
+    /** Last error reported from guest.
+     *  Set to VERR_IPE_UNINITIALIZED_STATUS if not set yet. */
+    int                   m_vrcGuest;
+    /** Default action to perform in case of a
+     *  successful drop. */
+    VBOXDNDACTION         m_dndActionDefault;
+    /** Actions supported by the guest in case of a successful drop. */
+    VBOXDNDACTIONLIST     m_dndLstActionsAllowed;
+    /** Format(s) requested/supported from the guest. */
+    GuestDnDMIMEList      m_lstFormats;
+    /** Pointer to IGuest parent object. */
+    ComObjPtr<Guest>      m_pParent;
+    /** Pointer to associated progress object. Optional. */
+    ComObjPtr<Progress>   m_pProgress;
+    /** Callback map. */
+    GuestDnDCallbackMap   m_mapCallbacks;
+};
+
+/**
+ * Private singleton class for the guest's DnD implementation.
+ *
+ * Can't be instanciated directly, only via the factory pattern.
+ * Keeps track of all ongoing DnD transfers.
+ */
+class GuestDnD
+{
+public:
+
+    /**
+     * Creates the Singleton GuestDnD object.
+     *
+     * @returns Newly created Singleton object, or NULL on failure.
+     */
+    static GuestDnD *createInstance(const ComObjPtr<Guest>& pGuest)
+    {
+        Assert(NULL == GuestDnD::s_pInstance);
+        GuestDnD::s_pInstance = new GuestDnD(pGuest);
+        return GuestDnD::s_pInstance;
+    }
+
+    /**
+     * Destroys the Singleton GuestDnD object.
+     */
+    static void destroyInstance(void)
+    {
+        if (GuestDnD::s_pInstance)
+        {
+            delete GuestDnD::s_pInstance;
+            GuestDnD::s_pInstance = NULL;
+        }
+    }
+
+    /**
+     * Returns the Singleton GuestDnD object.
+     *
+     * @returns Pointer to Singleton GuestDnD object, or NULL if not created yet.
+     */
+    static inline GuestDnD *getInstance(void)
+    {
+        AssertPtr(GuestDnD::s_pInstance);
+        return GuestDnD::s_pInstance;
+    }
+
+protected:
+
+    /** List of registered DnD sources. */
+    typedef std::list< ComObjPtr<GuestDnDSource> > GuestDnDSrcList;
+    /** List of registered DnD targets. */
+    typedef std::list< ComObjPtr<GuestDnDTarget> > GuestDnDTgtList;
+
+    /** Constructor; will throw vrc on failure. */
+    GuestDnD(const ComObjPtr<Guest>& pGuest);
+    virtual ~GuestDnD(void);
+
+public:
+
+    /** @name Public helper functions.
+     * @{ */
+    HRESULT           adjustScreenCoordinates(ULONG uScreenId, ULONG *puX, ULONG *puY) const;
+    GuestDnDState    *getState(uint32_t = 0) const;
+    int               hostCall(uint32_t u32Function, uint32_t cParms, PVBOXHGCMSVCPARM paParms) const;
+    GuestDnDMIMEList  defaultFormats(void) const { return m_strDefaultFormats; }
+    /** @}  */
+
+    /** @name Source / target management.
+     * @{ */
+    int               registerSource(const ComObjPtr<GuestDnDSource> &Source);
+    int               unregisterSource(const ComObjPtr<GuestDnDSource> &Source);
+    size_t            getSourceCount(void);
+
+    int               registerTarget(const ComObjPtr<GuestDnDTarget> &Target);
+    int               unregisterTarget(const ComObjPtr<GuestDnDTarget> &Target);
+    size_t            getTargetCount(void);
+    /** @}  */
+
+public:
+
+    /** @name Static low-level HGCM callback handler.
+     * @{ */
+    static DECLCALLBACK(int)   notifyDnDDispatcher(void *pvExtension, uint32_t u32Function, void *pvParms, uint32_t cbParms);
+    /** @}  */
+
+    /** @name Static helper methods.
+     * @{ */
+    static bool                     isFormatInFormatList(const com::Utf8Str &strFormat, const GuestDnDMIMEList &lstFormats);
+    static GuestDnDMIMEList         toFormatList(const com::Utf8Str &strFormats, const com::Utf8Str &strSep = DND_FORMATS_SEPARATOR_STR);
+    static com::Utf8Str             toFormatString(const GuestDnDMIMEList &lstFormats, const com::Utf8Str &strSep = DND_FORMATS_SEPARATOR_STR);
+    static GuestDnDMIMEList         toFilteredFormatList(const GuestDnDMIMEList &lstFormatsSupported, const GuestDnDMIMEList &lstFormatsWanted);
+    static GuestDnDMIMEList         toFilteredFormatList(const GuestDnDMIMEList &lstFormatsSupported, const com::Utf8Str &strFormatsWanted);
+    static DnDAction_T              toMainAction(VBOXDNDACTION dndAction);
+    static std::vector<DnDAction_T> toMainActions(VBOXDNDACTIONLIST dndActionList);
+    static VBOXDNDACTION            toHGCMAction(DnDAction_T enmAction);
+    static void                     toHGCMActions(DnDAction_T enmDefAction, VBOXDNDACTION *pDefAction, const std::vector<DnDAction_T> vecAllowedActions, VBOXDNDACTIONLIST *pLstAllowedActions);
+    /** @}  */
+
+protected:
+
+    /** @name Singleton properties.
+     * @{ */
+    /** List of supported default MIME/Content-type formats. */
+    GuestDnDMIMEList            m_strDefaultFormats;
+    /** Pointer to guest implementation. */
+    const ComObjPtr<Guest>      m_pGuest;
+    /** The current state from the guest. At the
+     *  moment we only support only state a time (ARQ-style). */
+    GuestDnDState              *m_pState;
+    /** Critical section to serialize access. */
+    RTCRITSECT                  m_CritSect;
+    /** Number of active transfers (guest->host or host->guest). */
+    uint32_t                    m_cTransfersPending;
+    GuestDnDSrcList             m_lstSrc;
+    GuestDnDTgtList             m_lstTgt;
+    /** @}  */
+
+private:
+
+    /** Static pointer to singleton instance. */
+    static GuestDnD           *s_pInstance;
+};
+
+/** Access to the GuestDnD's singleton instance. */
+#define GuestDnDInst() GuestDnD::getInstance()
+
+/** List of pointers to guest DnD Messages. */
+typedef std::list<GuestDnDMsg *> GuestDnDMsgList;
+
+/**
+ * IDnDBase class implementation for sharing code between
+ * IGuestDnDSource and IGuestDnDTarget implementation.
+ */
+class GuestDnDBase
+{
+protected:
+
+    GuestDnDBase(VirtualBoxBase *pBase);
+
+    virtual ~GuestDnDBase(void);
+
+protected:
+
+    /** Shared (internal) IDnDBase method implementations.
+     * @{ */
+    bool i_isFormatSupported(const com::Utf8Str &aFormat) const;
+    const GuestDnDMIMEList &i_getFormats(void) const;
+    HRESULT i_addFormats(const GuestDnDMIMEList &aFormats);
+    HRESULT i_removeFormats(const GuestDnDMIMEList &aFormats);
+    /** @}  */
+
+    /** @name Error handling.
+     * @{ */
+    HRESULT i_setErrorV(int vrc, const char *pcszMsgFmt, va_list va);
+    HRESULT i_setError(int vrc, const char *pcszMsgFmt, ...);
+    HRESULT i_setErrorAndReset(const char *pcszMsgFmt, ...);
+    HRESULT i_setErrorAndReset(int vrc, const char *pcszMsgFmt, ...);
+    /** @}  */
+
+protected:
+
+    /** @name Pure virtual functions needed to be implemented by the actual (derived) implementation.
+     * @{ */
+    virtual void i_reset(void) = 0;
+    /** @}  */
+
+protected:
+
+    /** @name Functions for handling a simple host HGCM message queue.
+     * @{ */
+    int msgQueueAdd(GuestDnDMsg *pMsg);
+    GuestDnDMsg *msgQueueGetNext(void);
+    void msgQueueRemoveNext(void);
+    void msgQueueClear(void);
+    /** @}  */
+
+    int sendCancel(void);
+    int updateProgress(GuestDnDData *pData, GuestDnDState *pState, size_t cbDataAdd = 0);
+    int waitForEvent(GuestDnDCallbackEvent *pEvent, GuestDnDState *pState, RTMSINTERVAL msTimeout);
+
+protected:
+
+    /** Pointer to base class to use for stuff like error handlng. */
+    VirtualBoxBase                 *m_pBase;
+    /** @name Public attributes (through getters/setters).
+     * @{ */
+    /** Pointer to guest implementation. */
+    const ComObjPtr<Guest>          m_pGuest;
+    /** List of supported MIME types by the source. */
+    GuestDnDMIMEList                m_lstFmtSupported;
+    /** List of offered MIME types to the counterpart. */
+    GuestDnDMIMEList                m_lstFmtOffered;
+    /** Whether the object still is in pending state. */
+    bool                            m_fIsPending;
+    /** Pointer to state bound to this object. */
+    GuestDnDState                  *m_pState;
+    /** @}  */
+
+    /**
+     * Internal stuff.
+     */
+    struct
+    {
+        /** Outgoing message queue (FIFO). */
+        GuestDnDMsgList             lstMsgOut;
+    } m_DataBase;
+};
+#endif /* !MAIN_INCLUDED_GuestDnDPrivate_h */
+
diff --git a/src/VBox/Main/include/GuestDnDSourceImpl.h b/src/VBox/Main/include/GuestDnDSourceImpl.h
new file mode 100644
index 00000000..42373620
--- /dev/null
+++ b/src/VBox/Main/include/GuestDnDSourceImpl.h
@@ -0,0 +1,131 @@
+/* $Id: GuestDnDSourceImpl.h $ */
+/** @file
+ * VBox Console COM Class implementation - Guest drag'n drop source.
+ */
+
+/*
+ * Copyright (C) 2014-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
+ */
+
+#ifndef MAIN_INCLUDED_GuestDnDSourceImpl_h
+#define MAIN_INCLUDED_GuestDnDSourceImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/GuestHost/DragAndDrop.h>
+#include <VBox/HostServices/DragAndDropSvc.h>
+
+using namespace DragAndDropSvc;
+
+#include "GuestDnDSourceWrap.h"
+#include "GuestDnDPrivate.h"
+
+class GuestDnDRecvDataTask;
+struct GuestDnDRecvCtx;
+
+class ATL_NO_VTABLE GuestDnDSource :
+    public GuestDnDSourceWrap,
+    public GuestDnDBase
+{
+public:
+    GuestDnDSource(void);
+    virtual ~GuestDnDSource(void);
+
+    /** @name COM and internal init/term/mapping cruft.
+     * @{ */
+    DECLARE_TRANSLATE_METHODS(GuestDnDSource);
+
+    HRESULT init(const ComObjPtr<Guest>& pGuest);
+    void    uninit(void);
+
+    HRESULT FinalConstruct(void);
+    void    FinalRelease(void);
+    /** @}  */
+
+private:
+
+    /** Private wrapped @name IDnDBase methods.
+     * @{ */
+    HRESULT isFormatSupported(const com::Utf8Str &aFormat, BOOL *aSupported);
+    HRESULT getFormats(GuestDnDMIMEList &aFormats);
+    HRESULT addFormats(const GuestDnDMIMEList &aFormats);
+    HRESULT removeFormats(const GuestDnDMIMEList &aFormats);
+    /** @}  */
+
+    /** Private wrapped @name IDnDSource methods.
+     * @{ */
+    HRESULT dragIsPending(ULONG uScreenId, GuestDnDMIMEList &aFormats, std::vector<DnDAction_T> &aAllowedActions, DnDAction_T *aDefaultAction);
+    HRESULT drop(const com::Utf8Str &aFormat, DnDAction_T aAction, ComPtr<IProgress> &aProgress);
+    HRESULT receiveData(std::vector<BYTE> &aData);
+    /** @}  */
+
+protected:
+
+    /** @name Implemented virtual functions.
+     * @{ */
+    void i_reset(void);
+    /** @}  */
+
+#ifdef VBOX_WITH_DRAG_AND_DROP_GH
+    /** @name Dispatch handlers for the HGCM callbacks.
+     * @{ */
+    int i_onReceiveDataHdr(GuestDnDRecvCtx *pCtx, PVBOXDNDSNDDATAHDR pDataHdr);
+    int i_onReceiveData(GuestDnDRecvCtx *pCtx, PVBOXDNDSNDDATA pSndData);
+    int i_onReceiveDir(GuestDnDRecvCtx *pCtx, const char *pszPath, uint32_t cbPath, uint32_t fMode);
+    int i_onReceiveFileHdr(GuestDnDRecvCtx *pCtx, const char *pszPath, uint32_t cbPath, uint64_t cbSize, uint32_t fMode, uint32_t fFlags);
+    int i_onReceiveFileData(GuestDnDRecvCtx *pCtx,const void *pvData, uint32_t cbData);
+    /** @}  */
+#endif
+
+protected:
+
+    static Utf8Str i_guestErrorToString(int guestRc);
+    static Utf8Str i_hostErrorToString(int hostRc);
+
+    /** @name Callbacks for dispatch handler.
+     * @{ */
+    static DECLCALLBACK(int) i_receiveRawDataCallback(uint32_t uMsg, void *pvParms, size_t cbParms, void *pvUser);
+    static DECLCALLBACK(int) i_receiveTransferDataCallback(uint32_t uMsg, void *pvParms, size_t cbParms, void *pvUser);
+    /** @}  */
+
+protected:
+
+    int i_receiveData(GuestDnDRecvCtx *pCtx, RTMSINTERVAL msTimeout);
+    int i_receiveRawData(GuestDnDRecvCtx *pCtx, RTMSINTERVAL msTimeout);
+    int i_receiveTransferData(GuestDnDRecvCtx *pCtx, RTMSINTERVAL msTimeout);
+
+protected:
+
+    struct
+    {
+        /** Maximum data block size (in bytes) the source can handle. */
+        uint32_t    mcbBlockSize;
+        /** The context for receiving data from the guest.
+         *  At the moment only one transfer at a time is supported. */
+        GuestDnDRecvCtx mRecvCtx;
+    } mData;
+
+    friend class GuestDnDRecvDataTask;
+};
+
+#endif /* !MAIN_INCLUDED_GuestDnDSourceImpl_h */
+
diff --git a/src/VBox/Main/include/GuestDnDTargetImpl.h b/src/VBox/Main/include/GuestDnDTargetImpl.h
new file mode 100644
index 00000000..0b7fc268
--- /dev/null
+++ b/src/VBox/Main/include/GuestDnDTargetImpl.h
@@ -0,0 +1,128 @@
+/* $Id: GuestDnDTargetImpl.h $ */
+/** @file
+ * VBox Console COM Class implementation - Guest drag'n drop target.
+ */
+
+/*
+ * Copyright (C) 2014-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
+ */
+
+#ifndef MAIN_INCLUDED_GuestDnDTargetImpl_h
+#define MAIN_INCLUDED_GuestDnDTargetImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "GuestDnDTargetWrap.h"
+#include "GuestDnDPrivate.h"
+
+#include <VBox/GuestHost/DragAndDrop.h>
+#include <VBox/HostServices/DragAndDropSvc.h>
+
+struct GuestDnDSendCtx;
+class GuestDnDSendDataTask;
+
+class ATL_NO_VTABLE GuestDnDTarget :
+    public GuestDnDTargetWrap,
+    public GuestDnDBase
+{
+public:
+    GuestDnDTarget(void);
+    virtual ~GuestDnDTarget(void);
+
+    /** @name COM and internal init/term/mapping cruft.
+     * @{ */
+    DECLARE_TRANSLATE_METHODS(GuestDnDTarget);
+
+    HRESULT init(const ComObjPtr<Guest>& pGuest);
+    void    uninit(void);
+
+    HRESULT FinalConstruct(void);
+    void    FinalRelease(void);
+    /** @}  */
+
+private:
+
+    /** Private wrapped @name IDnDBase methods.
+     * @{ */
+    HRESULT isFormatSupported(const com::Utf8Str &aFormat, BOOL *aSupported);
+    HRESULT getFormats(GuestDnDMIMEList &aFormats);
+    HRESULT addFormats(const GuestDnDMIMEList &aFormats);
+    HRESULT removeFormats(const GuestDnDMIMEList &aFormats);
+    /** @}  */
+
+    /** Private wrapped @name IDnDTarget methods.
+     * @{ */
+    HRESULT enter(ULONG aScreenId, ULONG ax, ULONG aY, DnDAction_T aDefaultAction, const std::vector<DnDAction_T> &aAllowedActions, const GuestDnDMIMEList &aFormats, DnDAction_T *aResultAction);
+    HRESULT move(ULONG aScreenId, ULONG aX, ULONG aY, DnDAction_T aDefaultAction, const std::vector<DnDAction_T> &aAllowedActions, const GuestDnDMIMEList &aFormats, DnDAction_T *aResultAction);
+    HRESULT leave(ULONG aScreenId);
+    HRESULT drop(ULONG aScreenId, ULONG aX, ULONG aY, DnDAction_T aDefaultAction, const std::vector<DnDAction_T> &aAllowedActions, const GuestDnDMIMEList &aFormats, com::Utf8Str &aFormat, DnDAction_T *aResultAction);
+    HRESULT sendData(ULONG aScreenId, const com::Utf8Str &aFormat, const std::vector<BYTE> &aData, ComPtr<IProgress> &aProgress);
+    HRESULT cancel(BOOL *aVeto);
+    /** @}  */
+
+protected:
+
+    static Utf8Str i_guestErrorToString(int guestRc);
+    static Utf8Str i_hostErrorToString(int hostRc);
+
+    /** @name Callbacks for dispatch handler.
+     * @{ */
+    static DECLCALLBACK(int) i_sendTransferDataCallback(uint32_t uMsg, void *pvParms, size_t cbParms, void *pvUser);
+    /** @}  */
+
+protected:
+
+    /** @name Implemented virtual functions.
+     * @{ */
+    void i_reset(void);
+    /** @}  */
+
+    int i_sendData(GuestDnDSendCtx *pCtx, RTMSINTERVAL msTimeout);
+
+    int i_sendMetaDataBody(GuestDnDSendCtx *pCtx);
+    int i_sendMetaDataHeader(GuestDnDSendCtx *pCtx);
+
+    int i_sendTransferData(GuestDnDSendCtx *pCtx, RTMSINTERVAL msTimeout);
+    int i_sendTransferListObject(GuestDnDSendCtx *pCtx,  PDNDTRANSFERLIST pList, GuestDnDMsg *pMsg);
+
+    int i_sendDirectory(GuestDnDSendCtx *pCtx, PDNDTRANSFEROBJECT pObj, GuestDnDMsg *pMsg);
+    int i_sendFile(GuestDnDSendCtx *pCtx, PDNDTRANSFEROBJECT pObj, GuestDnDMsg *pMsg);
+    int i_sendFileData(GuestDnDSendCtx *pCtx, PDNDTRANSFEROBJECT pObj, GuestDnDMsg *pMsg);
+
+    int i_sendRawData(GuestDnDSendCtx *pCtx, RTMSINTERVAL msTimeout);
+
+protected:
+
+    struct
+    {
+        /** Maximum data block size (in bytes) the target can handle. */
+        uint32_t        mcbBlockSize;
+        /** The context for sending data to the guest.
+         *  At the moment only one transfer at a time is supported. */
+        GuestDnDSendCtx mSendCtx;
+    } mData;
+
+    friend class GuestDnDSendDataTask;
+};
+
+#endif /* !MAIN_INCLUDED_GuestDnDTargetImpl_h */
+
diff --git a/src/VBox/Main/include/GuestFileImpl.h b/src/VBox/Main/include/GuestFileImpl.h
new file mode 100644
index 00000000..b6feda07
--- /dev/null
+++ b/src/VBox/Main/include/GuestFileImpl.h
@@ -0,0 +1,161 @@
+/* $Id: GuestFileImpl.h $ */
+/** @file
+ * VirtualBox Main - Guest file handling implementation.
+ */
+
+/*
+ * Copyright (C) 2012-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
+ */
+
+#ifndef MAIN_INCLUDED_GuestFileImpl_h
+#define MAIN_INCLUDED_GuestFileImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "VirtualBoxBase.h"
+#include "EventImpl.h"
+
+#include "GuestCtrlImplPrivate.h"
+#include "GuestFileWrap.h"
+
+class Console;
+class GuestSession;
+class GuestProcess;
+
+class ATL_NO_VTABLE GuestFile :
+    public GuestFileWrap,
+    public GuestObject
+{
+public:
+    /** @name COM and internal init/term/mapping cruft.
+     * @{ */
+    DECLARE_COMMON_CLASS_METHODS(GuestFile)
+
+    int     init(Console *pConsole, GuestSession *pSession, ULONG uFileID, const GuestFileOpenInfo &openInfo);
+    void    uninit(void);
+
+    HRESULT FinalConstruct(void);
+    void    FinalRelease(void);
+    /** @}  */
+
+public:
+    /** @name Implemented virtual methods from GuestObject.
+     * @{ */
+    int             i_callbackDispatcher(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
+    int             i_onUnregister(void);
+    int             i_onSessionStatusChange(GuestSessionStatus_T enmSessionStatus);
+    /** @}  */
+
+public:
+    /** @name Public internal methods.
+     * @{ */
+    int             i_closeFile(int *pGuestRc);
+    EventSource    *i_getEventSource(void) { return mEventSource; }
+    int             i_onFileNotify(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
+    int             i_onGuestDisconnected(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
+    int             i_openFile(uint32_t uTimeoutMS, int *pGuestRc);
+    int             i_queryInfo(GuestFsObjData &objData, int *prcGuest);
+    int             i_readData(uint32_t uSize, uint32_t uTimeoutMS, void* pvData, uint32_t cbData, uint32_t* pcbRead);
+    int             i_readDataAt(uint64_t uOffset, uint32_t uSize, uint32_t uTimeoutMS,
+                                 void* pvData, size_t cbData, size_t* pcbRead);
+    int             i_seekAt(int64_t iOffset, GUEST_FILE_SEEKTYPE eSeekType, uint32_t uTimeoutMS, uint64_t *puOffset);
+    int             i_setFileStatus(FileStatus_T fileStatus, int vrcFile);
+    int             i_waitForOffsetChange(GuestWaitEvent *pEvent, uint32_t uTimeoutMS, uint64_t *puOffset);
+    int             i_waitForRead(GuestWaitEvent *pEvent, uint32_t uTimeoutMS, void *pvData, size_t cbData, uint32_t *pcbRead);
+    int             i_waitForStatusChange(GuestWaitEvent *pEvent, uint32_t uTimeoutMS, FileStatus_T *pFileStatus, int *pGuestRc);
+    int             i_waitForWrite(GuestWaitEvent *pEvent, uint32_t uTimeoutMS, uint32_t *pcbWritten);
+    int             i_writeData(uint32_t uTimeoutMS, const void *pvData, uint32_t cbData, uint32_t *pcbWritten);
+    int             i_writeDataAt(uint64_t uOffset, uint32_t uTimeoutMS, const void *pvData, uint32_t cbData, uint32_t *pcbWritten);
+    /** @}  */
+
+    /** @name Static helper methods.
+     * @{ */
+    static Utf8Str  i_guestErrorToString(int guestRc, const char *pcszWhat);
+    /** @}  */
+
+public:
+
+    /** @name Wrapped IGuestFile properties.
+     * @{ */
+    HRESULT getCreationMode(ULONG *aCreationMode);
+    HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
+    HRESULT getId(ULONG *aId);
+    HRESULT getInitialSize(LONG64 *aInitialSize);
+    HRESULT getOffset(LONG64 *aOffset);
+    HRESULT getStatus(FileStatus_T *aStatus);
+    HRESULT getFilename(com::Utf8Str &aFilename);
+    HRESULT getAccessMode(FileAccessMode_T *aAccessMode);
+    HRESULT getOpenAction(FileOpenAction_T *aOpenAction);
+    /** @}  */
+
+    /** @name Wrapped IGuestFile methods.
+     * @{ */
+    HRESULT close();
+    HRESULT queryInfo(ComPtr<IFsObjInfo> &aObjInfo);
+    HRESULT querySize(LONG64 *aSize);
+    HRESULT read(ULONG aToRead,
+                 ULONG aTimeoutMS,
+                 std::vector<BYTE> &aData);
+    HRESULT readAt(LONG64 aOffset,
+                   ULONG aToRead,
+                   ULONG aTimeoutMS,
+                   std::vector<BYTE> &aData);
+    HRESULT seek(LONG64 aOffset,
+                 FileSeekOrigin_T aWhence,
+                 LONG64 *aNewOffset);
+    HRESULT setACL(const com::Utf8Str &aAcl,
+                   ULONG aMode);
+    HRESULT setSize(LONG64 aSize);
+    HRESULT write(const std::vector<BYTE> &aData,
+                  ULONG aTimeoutMS,
+                  ULONG *aWritten);
+    HRESULT writeAt(LONG64 aOffset,
+                    const std::vector<BYTE> &aData,
+                    ULONG aTimeoutMS,
+                    ULONG *aWritten);
+    /** @}  */
+
+private:
+
+    /** This can safely be used without holding any locks.
+     * An AutoCaller suffices to prevent it being destroy while in use and
+     * internally there is a lock providing the necessary serialization. */
+    const ComObjPtr<EventSource> mEventSource;
+
+    struct Data
+    {
+        /** The file's open info. */
+        GuestFileOpenInfo       mOpenInfo;
+        /** The file's initial size on open. */
+        uint64_t                mInitialSize;
+        /** The current file status. */
+        FileStatus_T            mStatus;
+        /** The last returned process status
+         *  returned from the guest side. */
+        int                     mLastError;
+        /** The file's current offset. */
+        uint64_t                mOffCurrent;
+    } mData;
+};
+
+#endif /* !MAIN_INCLUDED_GuestFileImpl_h */
+
diff --git a/src/VBox/Main/include/GuestFsObjInfoImpl.h b/src/VBox/Main/include/GuestFsObjInfoImpl.h
new file mode 100644
index 00000000..8e8e4789
--- /dev/null
+++ b/src/VBox/Main/include/GuestFsObjInfoImpl.h
@@ -0,0 +1,86 @@
+/* $Id: GuestFsObjInfoImpl.h $ */
+/** @file
+ * VirtualBox Main - Guest file system object information implementation.
+ */
+
+/*
+ * Copyright (C) 2012-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
+ */
+
+#ifndef MAIN_INCLUDED_GuestFsObjInfoImpl_h
+#define MAIN_INCLUDED_GuestFsObjInfoImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "GuestFsObjInfoWrap.h"
+#include "GuestCtrlImplPrivate.h"
+
+class ATL_NO_VTABLE GuestFsObjInfo
+    : public GuestFsObjInfoWrap
+{
+public:
+    /** @name COM and internal init/term/mapping cruft.
+     * @{ */
+    DECLARE_COMMON_CLASS_METHODS(GuestFsObjInfo)
+
+    int     init(const GuestFsObjData &objData);
+    void    uninit(void);
+
+    HRESULT FinalConstruct(void);
+    void    FinalRelease(void);
+    /** @}  */
+
+    /** @name Internal access helpers.
+     * @{ */
+    const GuestFsObjData &i_getData() const { return mData; }
+    /** @}  */
+
+private:
+
+    /** Wrapped @name IGuestFsObjInfo properties.
+     * @{ */
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT getType(FsObjType_T *aType);
+    HRESULT getFileAttributes(com::Utf8Str &aFileAttributes);
+    HRESULT getObjectSize(LONG64 *aObjectSize);
+    HRESULT getAllocatedSize(LONG64 *aAllocatedSize);
+    HRESULT getAccessTime(LONG64 *aAccessTime);
+    HRESULT getBirthTime(LONG64 *aBirthTime);
+    HRESULT getChangeTime(LONG64 *aChangeTime);
+    HRESULT getModificationTime(LONG64 *aModificationTime);
+    HRESULT getUID(LONG *aUID);
+    HRESULT getUserName(com::Utf8Str &aUserName);
+    HRESULT getGID(LONG *aGID);
+    HRESULT getGroupName(com::Utf8Str &aGroupName);
+    HRESULT getNodeId(LONG64 *aNodeId);
+    HRESULT getNodeIdDevice(ULONG *aNodeIdDevice);
+    HRESULT getHardLinks(ULONG *aHardLinks);
+    HRESULT getDeviceNumber(ULONG *aDeviceNumber);
+    HRESULT getGenerationId(ULONG *aGenerationId);
+    HRESULT getUserFlags(ULONG *aUserFlags);
+    /** @}  */
+
+    GuestFsObjData mData;
+};
+
+#endif /* !MAIN_INCLUDED_GuestFsObjInfoImpl_h */
+
diff --git a/src/VBox/Main/include/GuestImpl.h b/src/VBox/Main/include/GuestImpl.h
new file mode 100644
index 00000000..622c87b3
--- /dev/null
+++ b/src/VBox/Main/include/GuestImpl.h
@@ -0,0 +1,282 @@
+/* $Id: GuestImpl.h $ */
+/** @file
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_GuestImpl_h
+#define MAIN_INCLUDED_GuestImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "GuestWrap.h"
+#include "VirtualBoxBase.h"
+#include <iprt/list.h>
+#include <iprt/time.h>
+#include <VBox/ostypes.h>
+#include <VBox/param.h>
+#include <VBox/vmm/stam.h>
+
+#include "AdditionsFacilityImpl.h"
+#ifdef VBOX_WITH_GUEST_CONTROL
+# include "GuestCtrlImplPrivate.h"
+# include "GuestSessionImpl.h"
+#endif
+#ifdef VBOX_WITH_DRAG_AND_DROP
+# include "GuestDnDSourceImpl.h"
+# include "GuestDnDTargetImpl.h"
+#endif
+#include "EventImpl.h"
+#include "HGCM.h"
+
+typedef enum
+{
+    GUESTSTATTYPE_CPUUSER     = 0,
+    GUESTSTATTYPE_CPUKERNEL   = 1,
+    GUESTSTATTYPE_CPUIDLE     = 2,
+    GUESTSTATTYPE_MEMTOTAL    = 3,
+    GUESTSTATTYPE_MEMFREE     = 4,
+    GUESTSTATTYPE_MEMBALLOON  = 5,
+    GUESTSTATTYPE_MEMCACHE    = 6,
+    GUESTSTATTYPE_PAGETOTAL   = 7,
+    GUESTSTATTYPE_PAGEFREE    = 8,
+    GUESTSTATTYPE_MAX         = 9
+} GUESTSTATTYPE;
+
+class Console;
+
+class ATL_NO_VTABLE Guest :
+    public GuestWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS (Guest)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // Public initializer/uninitializer for internal purposes only.
+    HRESULT init(Console *aParent);
+    void uninit();
+
+
+public:
+    /** @name Static internal methods.
+     * @{ */
+#ifdef VBOX_WITH_GUEST_CONTROL
+    /** Static callback for handling guest control notifications. */
+    static DECLCALLBACK(int) i_notifyCtrlDispatcher(void *pvExtension, uint32_t u32Function, void *pvData, uint32_t cbData);
+#endif
+    static DECLCALLBACK(void) i_staticUpdateStats(RTTIMERLR hTimerLR, void *pvUser, uint64_t iTick);
+    /** @}  */
+
+public:
+    /** @name Public internal methods.
+     * @{ */
+    void i_enableVMMStatistics(BOOL aEnable) { mCollectVMMStats = aEnable; };
+    void i_setAdditionsInfo(const com::Utf8Str &aInterfaceVersion, VBOXOSTYPE aOsType);
+    void i_setAdditionsInfo2(uint32_t a_uFullVersion, const char *a_pszName, uint32_t a_uRevision, uint32_t a_fFeatures);
+    bool i_facilityIsActive(VBoxGuestFacilityType enmFacility);
+    bool i_facilityUpdate(VBoxGuestFacilityType a_enmFacility, VBoxGuestFacilityStatus a_enmStatus,
+                          uint32_t a_fFlags, PCRTTIMESPEC a_pTimeSpecTS);
+    ComObjPtr<Console> i_getConsole(void) { return mParent; }
+    void i_setAdditionsStatus(VBoxGuestFacilityType a_enmFacility, VBoxGuestFacilityStatus a_enmStatus,
+                              uint32_t a_fFlags, PCRTTIMESPEC a_pTimeSpecTS);
+    void i_onUserStateChanged(const Utf8Str &aUser, const Utf8Str &aDomain, VBoxGuestUserState enmState,
+                              const uint8_t *puDetails, uint32_t cbDetails);
+    void i_setSupportedFeatures(uint32_t aCaps);
+    HRESULT i_setStatistic(ULONG aCpuId, GUESTSTATTYPE enmType, ULONG aVal);
+    BOOL i_isPageFusionEnabled();
+    void i_setCpuCount(uint32_t aCpus) { mCpus = aCpus; }
+    static HRESULT i_setErrorStatic(HRESULT aResultCode, const char *aText, ...)
+    {
+        va_list va;
+        va_start(va, aText);
+        HRESULT hrc = setErrorInternalV(aResultCode, getStaticClassIID(), getStaticComponentName(), aText, va, false, true);
+        va_end(va);
+        return hrc;
+    }
+    uint32_t    i_getAdditionsRevision(void) { return mData.mAdditionsRevision; }
+    uint32_t    i_getAdditionsVersion(void) { return mData.mAdditionsVersionFull; }
+    VBOXOSTYPE  i_getGuestOSType(void) const { return mData.mOSType; }
+    /** Checks if the guest OS type is part of the windows NT family.  */
+    bool        i_isGuestInWindowsNtFamily(void) const
+    {
+        return mData.mOSType < VBOXOSTYPE_OS2 && mData.mOSType >= VBOXOSTYPE_WinNT;
+    }
+#ifdef VBOX_WITH_GUEST_CONTROL
+    int         i_dispatchToSession(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
+    int         i_sessionCreate(const GuestSessionStartupInfo &ssInfo, const GuestCredentials &guestCreds,
+                                ComObjPtr<GuestSession> &pGuestSession);
+    int         i_sessionDestroy(uint32_t uSessionID);
+    inline bool i_sessionExists(uint32_t uSessionID);
+    /** Returns the VBOX_GUESTCTRL_GF_0_XXX mask reported by the guest. */
+    uint64_t    i_getGuestControlFeatures0() const { return mData.mfGuestFeatures0; }
+    /** Returns the VBOX_GUESTCTRL_GF_1_XXX mask reported by the guest. */
+    uint64_t    i_getGuestControlFeatures1() const { return mData.mfGuestFeatures1; }
+#endif
+    /** @}  */
+
+private:
+
+     // wrapped IGuest properties
+     HRESULT getOSTypeId(com::Utf8Str &aOSTypeId);
+     HRESULT getAdditionsRunLevel(AdditionsRunLevelType_T *aAdditionsRunLevel);
+     HRESULT getAdditionsVersion(com::Utf8Str &aAdditionsVersion);
+     HRESULT getAdditionsRevision(ULONG *aAdditionsRevision);
+     HRESULT getDnDSource(ComPtr<IGuestDnDSource> &aDnDSource);
+     HRESULT getDnDTarget(ComPtr<IGuestDnDTarget> &aDnDTarget);
+     HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
+     HRESULT getFacilities(std::vector<ComPtr<IAdditionsFacility> > &aFacilities);
+     HRESULT getSessions(std::vector<ComPtr<IGuestSession> > &aSessions);
+     HRESULT getMemoryBalloonSize(ULONG *aMemoryBalloonSize);
+     HRESULT setMemoryBalloonSize(ULONG aMemoryBalloonSize);
+     HRESULT getStatisticsUpdateInterval(ULONG *aStatisticsUpdateInterval);
+     HRESULT setStatisticsUpdateInterval(ULONG aStatisticsUpdateInterval);
+     HRESULT internalGetStatistics(ULONG *aCpuUser,
+                                   ULONG *aCpuKernel,
+                                   ULONG *aCpuIdle,
+                                   ULONG *aMemTotal,
+                                   ULONG *aMemFree,
+                                   ULONG *aMemBalloon,
+                                   ULONG *aMemShared,
+                                   ULONG *aMemCache,
+                                   ULONG *aPagedTotal,
+                                   ULONG *aMemAllocTotal,
+                                   ULONG *aMemFreeTotal,
+                                   ULONG *aMemBalloonTotal,
+                                   ULONG *aMemSharedTotal);
+     HRESULT getFacilityStatus(AdditionsFacilityType_T aFacility,
+                               LONG64 *aTimestamp,
+                               AdditionsFacilityStatus_T *aStatus);
+     HRESULT getAdditionsStatus(AdditionsRunLevelType_T aLevel,
+                                BOOL *aActive);
+     HRESULT setCredentials(const com::Utf8Str &aUserName,
+                            const com::Utf8Str &aPassword,
+                            const com::Utf8Str &aDomain,
+                            BOOL aAllowInteractiveLogon);
+
+     // wrapped IGuest methods
+     HRESULT createSession(const com::Utf8Str &aUser,
+                           const com::Utf8Str &aPassword,
+                           const com::Utf8Str &aDomain,
+                           const com::Utf8Str &aSessionName,
+                           ComPtr<IGuestSession> &aGuestSession);
+
+     HRESULT findSession(const com::Utf8Str &aSessionName,
+                         std::vector<ComPtr<IGuestSession> > &aSessions);
+     HRESULT shutdown(const std::vector<GuestShutdownFlag_T> &aFlags);
+     HRESULT updateGuestAdditions(const com::Utf8Str &aSource,
+                                  const std::vector<com::Utf8Str> &aArguments,
+                                  const std::vector<AdditionsUpdateFlag_T> &aFlags,
+                                  ComPtr<IProgress> &aProgress);
+
+
+    /** @name Private internal methods.
+     * @{ */
+    void i_updateStats(uint64_t iTick);
+    static DECLCALLBACK(int) i_staticEnumStatsCallback(const char *pszName, STAMTYPE enmType, void *pvSample,
+                                                       STAMUNIT enmUnit, const char *pszUnit, STAMVISIBILITY enmVisiblity,
+                                                       const char *pszDesc, void *pvUser);
+
+    /** @}  */
+
+    typedef std::map< AdditionsFacilityType_T, ComObjPtr<AdditionsFacility> > FacilityMap;
+    typedef std::map< AdditionsFacilityType_T, ComObjPtr<AdditionsFacility> >::iterator FacilityMapIter;
+    typedef std::map< AdditionsFacilityType_T, ComObjPtr<AdditionsFacility> >::const_iterator FacilityMapIterConst;
+
+#ifdef VBOX_WITH_GUEST_CONTROL
+    /** Map for keeping the guest sessions. The primary key marks the guest session ID. */
+    typedef std::map <uint32_t, ComObjPtr<GuestSession> > GuestSessions;
+#endif
+
+    struct Data
+    {
+        Data() : mOSType(VBOXOSTYPE_Unknown),  mAdditionsRunLevel(AdditionsRunLevelType_None)
+            , mAdditionsVersionFull(0), mAdditionsRevision(0), mAdditionsFeatures(0)
+#ifdef VBOX_WITH_GUEST_CONTROL
+            , mfGuestFeatures0(0), mfGuestFeatures1(0)
+#endif
+        { }
+
+        VBOXOSTYPE                  mOSType;        /**@< For internal used. VBOXOSTYPE_Unknown if not reported. */
+        Utf8Str                     mOSTypeId;
+        FacilityMap                 mFacilityMap;
+        AdditionsRunLevelType_T     mAdditionsRunLevel;
+        uint32_t                    mAdditionsVersionFull;
+        Utf8Str                     mAdditionsVersionNew;
+        uint32_t                    mAdditionsRevision;
+        uint32_t                    mAdditionsFeatures;
+        Utf8Str                     mInterfaceVersion;
+#ifdef VBOX_WITH_GUEST_CONTROL
+        GuestSessions               mGuestSessions;
+        /** Guest control features (reported by the guest), VBOX_GUESTCTRL_GF_0_XXX. */
+        uint64_t                    mfGuestFeatures0;
+        /** Guest control features (reported by the guest), VBOX_GUESTCTRL_GF_1_XXX. */
+        uint64_t                    mfGuestFeatures1;
+#endif
+    } mData;
+
+    ULONG                           mMemoryBalloonSize;
+    ULONG                           mStatUpdateInterval; /**< In seconds. */
+    uint64_t                        mNetStatRx;
+    uint64_t                        mNetStatTx;
+    uint64_t                        mNetStatLastTs;
+    ULONG                           mCurrentGuestStat[GUESTSTATTYPE_MAX];
+    ULONG                           mCurrentGuestCpuUserStat[VMM_MAX_CPU_COUNT];
+    ULONG                           mCurrentGuestCpuKernelStat[VMM_MAX_CPU_COUNT];
+    ULONG                           mCurrentGuestCpuIdleStat[VMM_MAX_CPU_COUNT];
+    ULONG                           mVmValidStats;
+    BOOL                            mCollectVMMStats;
+    BOOL                            mfPageFusionEnabled;
+    uint32_t                        mCpus;
+
+    const ComObjPtr<Console>        mParent;
+
+    /**
+     * This can safely be used without holding any locks.
+     * An AutoCaller suffices to prevent it being destroy while in use and
+     * internally there is a lock providing the necessary serialization.
+     */
+    const ComObjPtr<EventSource>    mEventSource;
+#ifdef VBOX_WITH_GUEST_CONTROL
+    /** General extension callback for guest control. */
+    HGCMSVCEXTHANDLE                mhExtCtrl;
+#endif
+
+#ifdef VBOX_WITH_DRAG_AND_DROP
+    /** The guest's DnD source. */
+    const ComObjPtr<GuestDnDSource> mDnDSource;
+    /** The guest's DnD target. */
+    const ComObjPtr<GuestDnDTarget> mDnDTarget;
+#endif
+
+    RTTIMERLR                       mStatTimer;
+    uint32_t                        mMagic; /** @todo r=andy Rename this to something more meaningful. */
+};
+#define GUEST_MAGIC 0xCEED2006u /** @todo r=andy Not very well defined!? */
+
+#endif /* !MAIN_INCLUDED_GuestImpl_h */
+
diff --git a/src/VBox/Main/include/GuestOSTypeImpl.h b/src/VBox/Main/include/GuestOSTypeImpl.h
new file mode 100644
index 00000000..354edfa3
--- /dev/null
+++ b/src/VBox/Main/include/GuestOSTypeImpl.h
@@ -0,0 +1,131 @@
+/* $Id: GuestOSTypeImpl.h $ */
+/** @file
+ *
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_GuestOSTypeImpl_h
+#define MAIN_INCLUDED_GuestOSTypeImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "Global.h"
+#include "GuestOSTypeWrap.h"
+
+class ATL_NO_VTABLE GuestOSType :
+    public GuestOSTypeWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(GuestOSType)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(const Global::OSType &ostype);
+    void uninit();
+
+    // public methods only for internal purposes
+    const Utf8Str &i_id() const { return mID; }
+    const Utf8Str &i_familyId() const { return mFamilyID; }
+    bool i_is64Bit() const { return !!(mOSHint & VBOXOSHINT_64BIT); }
+    bool i_recommendedIOAPIC() const { return !!(mOSHint & VBOXOSHINT_IOAPIC); }
+    bool i_recommendedX2APIC() const { return !!(mOSHint & VBOXOSHINT_X2APIC); }
+    bool i_recommendedVirtEx() const { return !!(mOSHint & VBOXOSHINT_HWVIRTEX); }
+    bool i_recommendedEFI() const { return !!(mOSHint & VBOXOSHINT_EFI); }
+    bool i_recommendedEFISecureBoot() const { return !!(mOSHint & VBOXOSHINT_EFI_SECUREBOOT); }
+    bool i_recommendedTpm2() const { return !!(mOSHint & VBOXOSHINT_TPM2); }
+    NetworkAdapterType_T i_networkAdapterType() const { return mNetworkAdapterType; }
+    uint32_t i_numSerialEnabled() const { return mNumSerialEnabled; }
+
+private:
+
+    // Wrapped IGuestOSType properties
+    HRESULT getFamilyId(com::Utf8Str &aFamilyId);
+    HRESULT getFamilyDescription(com::Utf8Str &aFamilyDescription);
+    HRESULT getId(com::Utf8Str &aId);
+    HRESULT getDescription(com::Utf8Str &aDescription);
+    HRESULT getIs64Bit(BOOL *aIs64Bit);
+    HRESULT getRecommendedIOAPIC(BOOL *aRecommendedIOAPIC);
+    HRESULT getRecommendedVirtEx(BOOL *aRecommendedVirtEx);
+    HRESULT getRecommendedRAM(ULONG *RAMSize);
+    HRESULT getRecommendedGraphicsController(GraphicsControllerType_T *aRecommendedGraphicsController);
+    HRESULT getRecommendedVRAM(ULONG *aVRAMSize);
+    HRESULT getRecommended2DVideoAcceleration(BOOL *aRecommended2DVideoAcceleration);
+    HRESULT getRecommended3DAcceleration(BOOL *aRecommended3DAcceleration);
+    HRESULT getRecommendedHDD(LONG64 *aHDDSize);
+    HRESULT getAdapterType(NetworkAdapterType_T *aNetworkAdapterType);
+    HRESULT getRecommendedPAE(BOOL *aRecommendedPAE);
+    HRESULT getRecommendedDVDStorageController(StorageControllerType_T *aStorageControllerType);
+    HRESULT getRecommendedFirmware(FirmwareType_T *aFirmwareType);
+    HRESULT getRecommendedDVDStorageBus(StorageBus_T *aStorageBusType);
+    HRESULT getRecommendedHDStorageController(StorageControllerType_T *aStorageControllerType);
+    HRESULT getRecommendedHDStorageBus(StorageBus_T *aStorageBusType);
+    HRESULT getRecommendedUSBHID(BOOL *aRecommendedUSBHID);
+    HRESULT getRecommendedHPET(BOOL *aRecommendedHPET);
+    HRESULT getRecommendedUSBTablet(BOOL *aRecommendedUSBTablet);
+    HRESULT getRecommendedRTCUseUTC(BOOL *aRecommendedRTCUseUTC);
+    HRESULT getRecommendedChipset(ChipsetType_T *aChipsetType);
+    HRESULT getRecommendedIommuType(IommuType_T *aIommuType);
+    HRESULT getRecommendedAudioController(AudioControllerType_T *aAudioController);
+    HRESULT getRecommendedAudioCodec(AudioCodecType_T *aAudioCodec);
+    HRESULT getRecommendedFloppy(BOOL *aRecommendedFloppy);
+    HRESULT getRecommendedUSB(BOOL *aRecommendedUSB);
+    HRESULT getRecommendedUSB3(BOOL *aRecommendedUSB3);
+    HRESULT getRecommendedTFReset(BOOL *aRecommendedTFReset);
+    HRESULT getRecommendedX2APIC(BOOL *aRecommendedX2APIC);
+    HRESULT getRecommendedCPUCount(ULONG *aRecommendedCPUCount);
+    HRESULT getRecommendedTpmType(TpmType_T *aRecommendedTpmType);
+    HRESULT getRecommendedSecureBoot(BOOL *aRecommendedSecureBoot);
+    HRESULT getRecommendedWDDMGraphics(BOOL *aRecommendedWDDMGraphics);
+
+
+    const Utf8Str mFamilyID;
+    const Utf8Str mFamilyDescription;
+    const Utf8Str mID;
+    const Utf8Str mDescription;
+    const VBOXOSTYPE mOSType;
+    const uint32_t mOSHint;
+    const uint32_t mRAMSize;
+    const uint32_t mCPUCount;
+    const GraphicsControllerType_T mGraphicsControllerType;
+    const uint32_t mVRAMSize;
+    const uint64_t mHDDSize;
+    const NetworkAdapterType_T mNetworkAdapterType;
+    const uint32_t mNumSerialEnabled;
+    const StorageControllerType_T mDVDStorageControllerType;
+    const StorageBus_T mDVDStorageBusType;
+    const StorageControllerType_T mHDStorageControllerType;
+    const StorageBus_T mHDStorageBusType;
+    const ChipsetType_T mChipsetType;
+    const IommuType_T mIommuType;
+    const AudioControllerType_T mAudioControllerType;
+    const AudioCodecType_T mAudioCodecType;
+};
+
+#endif /* !MAIN_INCLUDED_GuestOSTypeImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/GuestProcessImpl.h b/src/VBox/Main/include/GuestProcessImpl.h
new file mode 100644
index 00000000..793b6db6
--- /dev/null
+++ b/src/VBox/Main/include/GuestProcessImpl.h
@@ -0,0 +1,310 @@
+/* $Id: GuestProcessImpl.h $ */
+/** @file
+ * VirtualBox Main - Guest process handling implementation.
+ */
+
+/*
+ * Copyright (C) 2012-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
+ */
+
+#ifndef MAIN_INCLUDED_GuestProcessImpl_h
+#define MAIN_INCLUDED_GuestProcessImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "GuestCtrlImplPrivate.h"
+#include "GuestProcessWrap.h"
+
+#include <iprt/cpp/utils.h>
+
+class Console;
+class GuestSession;
+class GuestProcessStartTask;
+
+/**
+ * Class for handling a guest process.
+ */
+class ATL_NO_VTABLE GuestProcess :
+    public GuestProcessWrap,
+    public GuestObject
+{
+public:
+    /** @name COM and internal init/term/mapping cruft.
+     * @{ */
+    DECLARE_COMMON_CLASS_METHODS(GuestProcess)
+
+    int     init(Console *aConsole, GuestSession *aSession, ULONG aObjectID,
+                 const GuestProcessStartupInfo &aProcInfo, const GuestEnvironment *pBaseEnv);
+    void    uninit(void);
+    HRESULT FinalConstruct(void);
+    void    FinalRelease(void);
+    /** @}  */
+
+public:
+    /** @name Implemented virtual methods from GuestObject.
+     * @{ */
+    int i_callbackDispatcher(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
+    int i_onUnregister(void);
+    int i_onSessionStatusChange(GuestSessionStatus_T enmSessionStatus);
+    /** @}  */
+
+public:
+    /** @name Public internal methods.
+     * @{ */
+    inline int i_checkPID(uint32_t uPID);
+    ProcessStatus_T i_getStatus(void);
+    int i_readData(uint32_t uHandle, uint32_t uSize, uint32_t uTimeoutMS, void *pvData, size_t cbData, uint32_t *pcbRead, int *pvrcGuest);
+    int i_startProcess(uint32_t cMsTimeout, int *pvrcGuest);
+    int i_startProcessInner(uint32_t cMsTimeout, AutoWriteLock &rLock, GuestWaitEvent *pEvent, int *pvrcGuest);
+    int i_startProcessAsync(void);
+    int i_terminateProcess(uint32_t uTimeoutMS, int *pvrcGuest);
+    ProcessWaitResult_T i_waitFlagsToResult(uint32_t fWaitFlags);
+    int i_waitFor(uint32_t fWaitFlags, ULONG uTimeoutMS, ProcessWaitResult_T &waitResult, int *pvrcGuest);
+    int i_waitForInputNotify(GuestWaitEvent *pEvent, uint32_t uHandle, uint32_t uTimeoutMS, ProcessInputStatus_T *pInputStatus, uint32_t *pcbProcessed);
+    int i_waitForOutput(GuestWaitEvent *pEvent, uint32_t uHandle, uint32_t uTimeoutMS, void* pvData, size_t cbData, uint32_t *pcbRead);
+    int i_waitForStatusChange(GuestWaitEvent *pEvent, uint32_t uTimeoutMS, ProcessStatus_T *pProcessStatus, int *pvrcGuest);
+    int i_writeData(uint32_t uHandle, uint32_t uFlags, void *pvData, size_t cbData, uint32_t uTimeoutMS, uint32_t *puWritten, int *pvrcGuest);
+    /** @}  */
+
+    /** @name Static internal methods.
+     * @{ */
+    static Utf8Str i_guestErrorToString(int vrcGuest, const char *pcszWhat);
+    static Utf8Str i_statusToString(ProcessStatus_T enmStatus);
+    static bool i_isGuestError(int guestRc);
+    static ProcessWaitResult_T i_waitFlagsToResultEx(uint32_t fWaitFlags, ProcessStatus_T oldStatus, ProcessStatus_T newStatus, uint32_t uProcFlags, uint32_t uProtocol);
+#if 0 /* unused */
+    static bool i_waitResultImpliesEx(ProcessWaitResult_T waitResult, ProcessStatus_T procStatus, uint32_t uProtocol);
+#endif
+    /** @}  */
+
+protected:
+    /** @name Protected internal methods.
+     * @{ */
+    inline bool i_isAlive(void);
+    inline bool i_hasEnded(void);
+    int i_onGuestDisconnected(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
+    int i_onProcessInputStatus(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
+    int i_onProcessNotifyIO(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
+    int i_onProcessStatusChange(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
+    int i_onProcessOutput(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
+    int i_prepareExecuteEnv(const char *pszEnv, void **ppvList, ULONG *pcbList, ULONG *pcEnvVars);
+    int i_setProcessStatus(ProcessStatus_T procStatus, int vrcProc);
+    static int i_startProcessThreadTask(GuestProcessStartTask *pTask);
+    /** @}  */
+
+private:
+    /** Wrapped @name IProcess properties.
+     * @{ */
+    HRESULT getArguments(std::vector<com::Utf8Str> &aArguments);
+    HRESULT getEnvironment(std::vector<com::Utf8Str> &aEnvironment);
+    HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
+    HRESULT getExecutablePath(com::Utf8Str &aExecutablePath);
+    HRESULT getExitCode(LONG *aExitCode);
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT getPID(ULONG *aPID);
+    HRESULT getStatus(ProcessStatus_T *aStatus);
+    /** @}  */
+
+    /** Wrapped @name IProcess methods.
+     * @{ */
+    HRESULT waitFor(ULONG aWaitFor,
+                    ULONG aTimeoutMS,
+                    ProcessWaitResult_T *aReason);
+    HRESULT waitForArray(const std::vector<ProcessWaitForFlag_T> &aWaitFor,
+                         ULONG aTimeoutMS,
+                         ProcessWaitResult_T *aReason);
+    HRESULT read(ULONG aHandle,
+                 ULONG aToRead,
+                 ULONG aTimeoutMS,
+                 std::vector<BYTE> &aData);
+    HRESULT write(ULONG aHandle,
+                  ULONG aFlags,
+                  const std::vector<BYTE> &aData,
+                  ULONG aTimeoutMS,
+                  ULONG *aWritten);
+    HRESULT writeArray(ULONG aHandle,
+                       const std::vector<ProcessInputFlag_T> &aFlags,
+                       const std::vector<BYTE> &aData,
+                       ULONG aTimeoutMS,
+                       ULONG *aWritten);
+    HRESULT terminate(void);
+    /** @}  */
+
+    /**
+     * This can safely be used without holding any locks.
+     * An AutoCaller suffices to prevent it being destroy while in use and
+     * internally there is a lock providing the necessary serialization.
+     */
+    const ComObjPtr<EventSource> mEventSource;
+
+    struct Data
+    {
+        /** The process startup information. */
+        GuestProcessStartupInfo  mProcess;
+        /** Reference to the immutable session base environment. NULL if the
+         * environment feature isn't supported.
+         * @remarks If there is proof that the uninit order of GuestSession and
+         *          this class is what GuestObjectBase claims, then this isn't
+         *          strictly necessary. */
+        GuestEnvironment const  *mpSessionBaseEnv;
+        /** Exit code if process has been terminated. */
+        LONG                     mExitCode;
+        /** PID reported from the guest.
+         *  Note: This is *not* the internal object ID! */
+        ULONG                    mPID;
+        /** The current process status. */
+        ProcessStatus_T          mStatus;
+        /** The last returned process status
+         *  returned from the guest side. */
+        int                      mLastError;
+
+        Data(void) : mpSessionBaseEnv(NULL)
+        { }
+        ~Data(void)
+        {
+            if (mpSessionBaseEnv)
+            {
+                mpSessionBaseEnv->releaseConst();
+                mpSessionBaseEnv = NULL;
+            }
+        }
+    } mData;
+
+    friend class GuestProcessStartTask;
+};
+
+/**
+ * Guest process tool wait flags.
+ */
+/** No wait flags specified; wait until process terminates.
+ *  The maximum waiting time is set in the process' startup
+ *  info. */
+#define GUESTPROCESSTOOL_WAIT_FLAG_NONE            0
+/** Wait until next stream block from stdout has been
+ *  read in completely, then return.
+ */
+#define GUESTPROCESSTOOL_WAIT_FLAG_STDOUT_BLOCK    RT_BIT(0)
+
+/**
+ * Structure for keeping a VBoxService toolbox tool's error info around.
+ */
+struct GuestProcessToolErrorInfo
+{
+    /** Return (VBox status) code from the guest side for executing the process tool. */
+    int     vrcGuest;
+    /** The process tool's returned exit code. */
+    int32_t iExitCode;
+};
+
+/**
+ * Internal class for handling the BusyBox-like tools built into VBoxService
+ * on the guest side. It's also called the VBoxService Toolbox (tm).
+ *
+ * Those initially were necessary to guarantee execution of commands (like "ls", "cat")
+ * under the behalf of a certain guest user.
+ *
+ * This class essentially helps to wrap all the gory details like process creation,
+ * information extraction and maintaining the overall status.
+ *
+ * Note! When implementing new functionality / commands, do *not* use this approach anymore!
+ *       This class has to be kept to guarantee backwards-compatibility.
+ */
+class GuestProcessTool
+{
+public:
+    DECLARE_TRANSLATE_METHODS(GuestProcessTool)
+
+    GuestProcessTool(void);
+
+    virtual ~GuestProcessTool(void);
+
+public:
+
+    int init(GuestSession *pGuestSession, const GuestProcessStartupInfo &startupInfo, bool fAsync, int *pvrcGuest);
+
+    void uninit(void);
+
+    int getCurrentBlock(uint32_t uHandle, GuestProcessStreamBlock &strmBlock);
+
+    int getRc(void) const;
+
+    /** Returns the stdout output from the guest process tool. */
+    GuestProcessStream &getStdOut(void) { return mStdOut; }
+
+    /** Returns the stderr output from the guest process tool. */
+    GuestProcessStream &getStdErr(void) { return mStdErr; }
+
+    int wait(uint32_t fToolWaitFlags, int *pvrcGuest);
+
+    int waitEx(uint32_t fToolWaitFlags, GuestProcessStreamBlock *pStreamBlock, int *pvrcGuest);
+
+    bool isRunning(void);
+
+    bool isTerminatedOk(void);
+
+    int getTerminationStatus(int32_t *piExitCode = NULL);
+
+    int terminate(uint32_t uTimeoutMS, int *pvrcGuest);
+
+public:
+
+    /** Wrapped @name Static run methods.
+     * @{ */
+    static int run(GuestSession *pGuestSession, const GuestProcessStartupInfo &startupInfo, int *pvrcGuest);
+
+    static int runErrorInfo(GuestSession *pGuestSession, const GuestProcessStartupInfo &startupInfo, GuestProcessToolErrorInfo &errorInfo);
+
+    static int runEx(GuestSession *pGuestSession, const GuestProcessStartupInfo &startupInfo,
+                     GuestCtrlStreamObjects *pStrmOutObjects, uint32_t cStrmOutObjects, int *pvrcGuest);
+
+    static int runExErrorInfo(GuestSession *pGuestSession, const GuestProcessStartupInfo &startupInfo,
+                              GuestCtrlStreamObjects *pStrmOutObjects, uint32_t cStrmOutObjects, GuestProcessToolErrorInfo &errorInfo);
+    /** @}  */
+
+    /** Wrapped @name Static exit code conversion methods.
+     * @{ */
+    static int exitCodeToRc(const GuestProcessStartupInfo &startupInfo, int32_t iExitCode);
+
+    static int exitCodeToRc(const char *pszTool, int32_t iExitCode);
+    /** @}  */
+
+    /** Wrapped @name Static guest error conversion methods.
+     * @{ */
+    static Utf8Str guestErrorToString(const char *pszTool, const GuestErrorInfo& guestErrorInfo);
+    /** @}  */
+
+protected:
+
+    /** Pointer to session this toolbox object is bound to. */
+    ComObjPtr<GuestSession>     pSession;
+    /** Pointer to process object this toolbox object is bound to. */
+    ComObjPtr<GuestProcess>     pProcess;
+    /** The toolbox' startup info. */
+    GuestProcessStartupInfo     mStartupInfo;
+    /** Stream object for handling the toolbox' stdout data. */
+    GuestProcessStream          mStdOut;
+    /** Stream object for handling the toolbox' stderr data. */
+    GuestProcessStream          mStdErr;
+};
+
+#endif /* !MAIN_INCLUDED_GuestProcessImpl_h */
+
diff --git a/src/VBox/Main/include/GuestSessionImpl.h b/src/VBox/Main/include/GuestSessionImpl.h
new file mode 100644
index 00000000..a5dcb3be
--- /dev/null
+++ b/src/VBox/Main/include/GuestSessionImpl.h
@@ -0,0 +1,460 @@
+/* $Id: GuestSessionImpl.h $ */
+/** @file
+ * VirtualBox Main - Guest session handling.
+ */
+
+/*
+ * Copyright (C) 2012-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
+ */
+
+#ifndef MAIN_INCLUDED_GuestSessionImpl_h
+#define MAIN_INCLUDED_GuestSessionImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "GuestSessionWrap.h"
+#include "EventImpl.h"
+
+#include "GuestCtrlImplPrivate.h"
+#include "GuestProcessImpl.h"
+#include "GuestDirectoryImpl.h"
+#include "GuestFileImpl.h"
+#include "GuestFsObjInfoImpl.h"
+#include "GuestSessionImplTasks.h"
+
+#include <iprt/asm.h> /** @todo r=bird: Needed for ASMBitSet() in GuestSession::Data constructor.  Removed when
+                       *        that is moved into the class implementation file as it should be. */
+#include <deque>
+
+class GuestSessionTaskInternalStart; /* Needed for i_startSessionThreadTask(). */
+
+/**
+ * Guest session implementation.
+ */
+class ATL_NO_VTABLE GuestSession
+    : public GuestSessionWrap
+    , public GuestBase
+{
+public:
+    /** @name COM and internal init/term/mapping cruft.
+     * @{ */
+    DECLARE_COMMON_CLASS_METHODS(GuestSession)
+
+    int     init(Guest *pGuest, const GuestSessionStartupInfo &ssInfo, const GuestCredentials &guestCreds);
+    void    uninit(void);
+    HRESULT FinalConstruct(void);
+    void    FinalRelease(void);
+    /** @}  */
+
+private:
+
+    /** Wrapped @name IGuestSession properties.
+     * @{ */
+    HRESULT getUser(com::Utf8Str &aUser);
+    HRESULT getDomain(com::Utf8Str &aDomain);
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT getId(ULONG *aId);
+    HRESULT getTimeout(ULONG *aTimeout);
+    HRESULT setTimeout(ULONG aTimeout);
+    HRESULT getProtocolVersion(ULONG *aProtocolVersion);
+    HRESULT getStatus(GuestSessionStatus_T *aStatus);
+    HRESULT getEnvironmentChanges(std::vector<com::Utf8Str> &aEnvironmentChanges);
+    HRESULT setEnvironmentChanges(const std::vector<com::Utf8Str> &aEnvironmentChanges);
+    HRESULT getEnvironmentBase(std::vector<com::Utf8Str> &aEnvironmentBase);
+    HRESULT getProcesses(std::vector<ComPtr<IGuestProcess> > &aProcesses);
+    HRESULT getPathStyle(PathStyle_T *aPathStyle);
+    HRESULT getCurrentDirectory(com::Utf8Str &aCurrentDirectory);
+    HRESULT setCurrentDirectory(const com::Utf8Str &aCurrentDirectory);
+    HRESULT getUserDocuments(com::Utf8Str &aUserDocuments);
+    HRESULT getUserHome(com::Utf8Str &aUserHome);
+    HRESULT getDirectories(std::vector<ComPtr<IGuestDirectory> > &aDirectories);
+    HRESULT getFiles(std::vector<ComPtr<IGuestFile> > &aFiles);
+    HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
+    /** @}  */
+
+    /** Wrapped @name IGuestSession methods.
+     * @{ */
+    HRESULT close();
+
+    HRESULT copyFromGuest(const std::vector<com::Utf8Str> &aSources,
+                          const std::vector<com::Utf8Str> &aFilters,
+                          const std::vector<com::Utf8Str> &aFlags,
+                          const com::Utf8Str &aDestination,
+                          ComPtr<IProgress> &aProgress);
+    HRESULT copyToGuest(const std::vector<com::Utf8Str> &aSources,
+                        const std::vector<com::Utf8Str> &aFilters,
+                        const std::vector<com::Utf8Str> &aFlags,
+                        const com::Utf8Str &aDestination,
+                        ComPtr<IProgress> &aProgress);
+
+    HRESULT directoryCopy(const com::Utf8Str &aSource,
+                          const com::Utf8Str &aDestination,
+                          const std::vector<DirectoryCopyFlag_T> &aFlags,
+                          ComPtr<IProgress> &aProgress);
+    HRESULT directoryCopyFromGuest(const com::Utf8Str &aSource,
+                                   const com::Utf8Str &aDestination,
+                                   const std::vector<DirectoryCopyFlag_T> &aFlags,
+                                   ComPtr<IProgress> &aProgress);
+    HRESULT directoryCopyToGuest(const com::Utf8Str &aSource,
+                                 const com::Utf8Str &aDestination,
+                                 const std::vector<DirectoryCopyFlag_T> &aFlags,
+                                 ComPtr<IProgress> &aProgress);
+    HRESULT directoryCreate(const com::Utf8Str &aPath,
+                            ULONG aMode,
+                            const std::vector<DirectoryCreateFlag_T> &aFlags);
+    HRESULT directoryCreateTemp(const com::Utf8Str &aTemplateName,
+                                ULONG aMode,
+                                const com::Utf8Str &aPath,
+                                BOOL aSecure,
+                                com::Utf8Str &aDirectory);
+    HRESULT directoryExists(const com::Utf8Str &aPath,
+                            BOOL aFollowSymlinks,
+                            BOOL *aExists);
+    HRESULT directoryOpen(const com::Utf8Str &aPath,
+                          const com::Utf8Str &aFilter,
+                          const std::vector<DirectoryOpenFlag_T> &aFlags,
+                          ComPtr<IGuestDirectory> &aDirectory);
+    HRESULT directoryRemove(const com::Utf8Str &aPath);
+    HRESULT directoryRemoveRecursive(const com::Utf8Str &aPath,
+                                     const std::vector<DirectoryRemoveRecFlag_T> &aFlags,
+                                     ComPtr<IProgress> &aProgress);
+    HRESULT environmentScheduleSet(const com::Utf8Str &aName,
+                                   const com::Utf8Str &aValue);
+    HRESULT environmentScheduleUnset(const com::Utf8Str &aName);
+    HRESULT environmentGetBaseVariable(const com::Utf8Str &aName,
+                                       com::Utf8Str &aValue);
+    HRESULT environmentDoesBaseVariableExist(const com::Utf8Str &aName,
+                                             BOOL *aExists);
+
+    HRESULT fileCopy(const com::Utf8Str &aSource,
+                     const com::Utf8Str &aDestination,
+                     const std::vector<FileCopyFlag_T> &aFlags,
+                     ComPtr<IProgress> &aProgress);
+    HRESULT fileCopyToGuest(const com::Utf8Str &aSource,
+                            const com::Utf8Str &aDestination,
+                            const std::vector<FileCopyFlag_T> &aFlags,
+                            ComPtr<IProgress> &aProgress);
+    HRESULT fileCopyFromGuest(const com::Utf8Str &aSource,
+                              const com::Utf8Str &aDestination,
+                              const std::vector<FileCopyFlag_T> &aFlags,
+                              ComPtr<IProgress> &aProgress);
+    HRESULT fileCreateTemp(const com::Utf8Str &aTemplateName,
+                           ULONG aMode,
+                           const com::Utf8Str &aPath,
+                           BOOL aSecure,
+                           ComPtr<IGuestFile> &aFile);
+    HRESULT fileExists(const com::Utf8Str &aPath,
+                       BOOL aFollowSymlinks,
+                       BOOL *aExists);
+    HRESULT fileOpen(const com::Utf8Str &aPath,
+                     FileAccessMode_T aAccessMode,
+                     FileOpenAction_T aOpenAction,
+                     ULONG aCreationMode,
+                     ComPtr<IGuestFile> &aFile);
+    HRESULT fileOpenEx(const com::Utf8Str &aPath,
+                       FileAccessMode_T aAccessMode,
+                       FileOpenAction_T aOpenAction,
+                       FileSharingMode_T aSharingMode,
+                       ULONG aCreationMode,
+                       const std::vector<FileOpenExFlag_T> &aFlags,
+                       ComPtr<IGuestFile> &aFile);
+    HRESULT fileQuerySize(const com::Utf8Str &aPath,
+                          BOOL aFollowSymlinks,
+                          LONG64 *aSize);
+    HRESULT fsQueryFreeSpace(const com::Utf8Str &aPath, LONG64 *aFreeSpace);
+    HRESULT fsQueryInfo(const com::Utf8Str &aPath, ComPtr<IGuestFsInfo> &aInfo);
+    HRESULT fsObjExists(const com::Utf8Str &aPath,
+                        BOOL aFollowSymlinks,
+                        BOOL *pfExists);
+    HRESULT fsObjQueryInfo(const com::Utf8Str &aPath,
+                           BOOL aFollowSymlinks,
+                           ComPtr<IGuestFsObjInfo> &aInfo);
+    HRESULT fsObjRemove(const com::Utf8Str &aPath);
+    HRESULT fsObjRemoveArray(const std::vector<com::Utf8Str> &aPaths,
+                             ComPtr<IProgress> &aProgress);
+    HRESULT fsObjRename(const com::Utf8Str &aOldPath,
+                        const com::Utf8Str &aNewPath,
+                        const std::vector<FsObjRenameFlag_T> &aFlags);
+    HRESULT fsObjMove(const com::Utf8Str &aSource,
+                      const com::Utf8Str &aDestination,
+                      const std::vector<FsObjMoveFlag_T> &aFlags,
+                      ComPtr<IProgress> &aProgress);
+    HRESULT fsObjMoveArray(const std::vector<com::Utf8Str> &aSource,
+                           const com::Utf8Str &aDestination,
+                           const std::vector<FsObjMoveFlag_T> &aFlags,
+                           ComPtr<IProgress> &aProgress);
+    HRESULT fsObjCopyArray(const std::vector<com::Utf8Str> &aSource,
+                           const com::Utf8Str &aDestination,
+                           const std::vector<FileCopyFlag_T> &aFlags,
+                           ComPtr<IProgress> &aProgress);
+    HRESULT fsObjSetACL(const com::Utf8Str &aPath,
+                        BOOL aFollowSymlinks,
+                        const com::Utf8Str &aAcl,
+                        ULONG aMode);
+    HRESULT processCreate(const com::Utf8Str &aCommand,
+                          const std::vector<com::Utf8Str> &aArguments,
+                          const std::vector<com::Utf8Str> &aEnvironment,
+                          const std::vector<ProcessCreateFlag_T> &aFlags,
+                          ULONG aTimeoutMS,
+                          ComPtr<IGuestProcess> &aGuestProcess);
+    HRESULT processCreateEx(const com::Utf8Str &aCommand,
+                            const std::vector<com::Utf8Str> &aArguments,
+                            const std::vector<com::Utf8Str> &aEnvironment,
+                            const std::vector<ProcessCreateFlag_T> &aFlags,
+                            ULONG aTimeoutMS,
+                            ProcessPriority_T aPriority,
+                            const std::vector<LONG> &aAffinity,
+                            ComPtr<IGuestProcess> &aGuestProcess);
+    HRESULT processGet(ULONG aPid,
+                       ComPtr<IGuestProcess> &aGuestProcess);
+    HRESULT symlinkCreate(const com::Utf8Str &aSource,
+                          const com::Utf8Str &aTarget,
+                          SymlinkType_T aType);
+    HRESULT symlinkExists(const com::Utf8Str &aSymlink,
+                          BOOL *aExists);
+    HRESULT symlinkRead(const com::Utf8Str &aSymlink,
+                        const std::vector<SymlinkReadFlag_T> &aFlags,
+                        com::Utf8Str &aTarget);
+    HRESULT waitFor(ULONG aWaitFor,
+                    ULONG aTimeoutMS,
+                    GuestSessionWaitResult_T *aReason);
+    HRESULT waitForArray(const std::vector<GuestSessionWaitForFlag_T> &aWaitFor,
+                         ULONG aTimeoutMS,
+                         GuestSessionWaitResult_T *aReason);
+    /** @}  */
+
+    /** Map of guest directories. The key specifies the internal directory ID. */
+    typedef std::map <uint32_t, ComObjPtr<GuestDirectory> > SessionDirectories;
+    /** Map of guest files. The key specifies the internal file ID. */
+    typedef std::map <uint32_t, ComObjPtr<GuestFile> > SessionFiles;
+    /** Map of guest processes. The key specifies the internal process number.
+     *  To retrieve the process' guest PID use the Id() method of the IProcess interface. */
+    typedef std::map <uint32_t, ComObjPtr<GuestProcess> > SessionProcesses;
+
+    /** Guest session object type enumeration. */
+    enum SESSIONOBJECTTYPE
+    {
+        /** Invalid session object type. */
+        SESSIONOBJECTTYPE_INVALID    = 0,
+        /** Session object. */
+        SESSIONOBJECTTYPE_SESSION    = 1,
+        /** Directory object. */
+        SESSIONOBJECTTYPE_DIRECTORY  = 2,
+        /** File object. */
+        SESSIONOBJECTTYPE_FILE       = 3,
+        /** Process object. */
+        SESSIONOBJECTTYPE_PROCESS    = 4
+    };
+
+    struct SessionObject
+    {
+        /** Creation timestamp (in ms).
+         * @note not used by anyone at the moment.  */
+        uint64_t          msBirth;
+        /** The object type. */
+        SESSIONOBJECTTYPE enmType;
+        /** Weak pointer to the object itself.
+         * Is NULL for SESSIONOBJECTTYPE_SESSION because GuestSession doesn't
+         * inherit from GuestObject. */
+        GuestObject      *pObject;
+    };
+
+    /** Map containing all objects bound to a guest session.
+     *  The key specifies the (global) context ID. */
+    typedef std::map<uint32_t, SessionObject> SessionObjects;
+
+public:
+    /** @name Public internal methods.
+     * @todo r=bird: Most of these are public for no real reason...
+     * @{ */
+    HRESULT                 i_copyFromGuest(const GuestSessionFsSourceSet &SourceSet, const com::Utf8Str &strDestination,
+                                            ComPtr<IProgress> &pProgress);
+    HRESULT                 i_copyToGuest(const GuestSessionFsSourceSet &SourceSet, const com::Utf8Str &strDestination,
+                                          ComPtr<IProgress> &pProgress);
+    int                     i_closeSession(uint32_t uFlags, uint32_t uTimeoutMS, int *pvrcGuest);
+    HRESULT                 i_directoryCopyFlagFromStr(const com::Utf8Str &strFlags, bool fStrict, DirectoryCopyFlag_T *pfFlags);
+    bool                    i_directoryExists(const Utf8Str &strPath);
+    inline bool             i_directoryExists(uint32_t uDirID, ComObjPtr<GuestDirectory> *pDir);
+    int                     i_directoryUnregister(GuestDirectory *pDirectory);
+    int                     i_directoryRemove(const Utf8Str &strPath, uint32_t fFlags, int *pvrcGuest);
+    int                     i_directoryCreate(const Utf8Str &strPath, uint32_t uMode, uint32_t uFlags, int *pvrcGuest);
+    int                     i_directoryOpen(const GuestDirectoryOpenInfo &openInfo,
+                                            ComObjPtr<GuestDirectory> &pDirectory, int *pvrcGuest);
+    int                     i_directoryQueryInfo(const Utf8Str &strPath, bool fFollowSymlinks, GuestFsObjData &objData, int *pvrcGuest);
+    int                     i_dispatchToObject(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
+    int                     i_dispatchToThis(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
+    HRESULT                 i_fileCopyFlagFromStr(const com::Utf8Str &strFlags, bool fStrict, FileCopyFlag_T *pfFlags);
+    inline bool             i_fileExists(uint32_t uFileID, ComObjPtr<GuestFile> *pFile);
+    int                     i_fileUnregister(GuestFile *pFile);
+    int                     i_fileRemove(const Utf8Str &strPath, int *pvrcGuest);
+    int                     i_fileOpenEx(const com::Utf8Str &aPath, FileAccessMode_T aAccessMode, FileOpenAction_T aOpenAction,
+                                         FileSharingMode_T aSharingMode, ULONG aCreationMode,
+                                         const std::vector<FileOpenExFlag_T> &aFlags,
+                                         ComObjPtr<GuestFile> &pFile, int *pvrcGuest);
+    int                     i_fileOpen(const GuestFileOpenInfo &openInfo, ComObjPtr<GuestFile> &pFile, int *pvrcGuest);
+    int                     i_fileQueryInfo(const Utf8Str &strPath, bool fFollowSymlinks, GuestFsObjData &objData, int *pvrcGuest);
+    int                     i_fileQuerySize(const Utf8Str &strPath, bool fFollowSymlinks, int64_t *pllSize, int *pvrcGuest);
+    int                     i_fsCreateTemp(const Utf8Str &strTemplate, const Utf8Str &strPath, bool fDirectory,
+                                           Utf8Str &strName, uint32_t fMode, bool fSecure, int *pvrcGuest);
+    int                     i_fsQueryInfo(const Utf8Str &strPath, bool fFollowSymlinks, GuestFsObjData &objData, int *pvrcGuest);
+    const GuestCredentials &i_getCredentials(void);
+    EventSource            *i_getEventSource(void) { return mEventSource; }
+    Utf8Str                 i_getName(void);
+    ULONG                   i_getId(void) { return mData.mSession.mID; }
+    bool                    i_isStarted(void) const;
+    HRESULT                 i_isStartedExternal(void);
+    bool                    i_isTerminated(void) const;
+    int                     i_onRemove(void);
+    int                     i_onSessionStatusChange(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
+    PathStyle_T             i_getGuestPathStyle(void);
+    static PathStyle_T      i_getHostPathStyle(void);
+    int                     i_startSession(int *pvrcGuest);
+    int                     i_startSessionAsync(void);
+    Guest                  *i_getParent(void) { return mParent; }
+    uint32_t                i_getProtocolVersion(void) { return mData.mProtocolVersion; }
+    int                     i_objectRegister(GuestObject *pObject, SESSIONOBJECTTYPE enmType, uint32_t *pidObject);
+    int                     i_objectUnregister(uint32_t uObjectID);
+    int                     i_objectsUnregister(void);
+    int                     i_objectsNotifyAboutStatusChange(GuestSessionStatus_T enmSessionStatus);
+    int                     i_pathRename(const Utf8Str &strSource, const Utf8Str &strDest, uint32_t uFlags, int *pvrcGuest);
+    int                     i_pathUserDocuments(Utf8Str &strPath, int *pvrcGuest);
+    int                     i_pathUserHome(Utf8Str &strPath, int *pvrcGuest);
+    int                     i_processUnregister(GuestProcess *pProcess);
+    int                     i_processCreateEx(GuestProcessStartupInfo &procInfo, ComObjPtr<GuestProcess> &pProgress);
+    inline bool             i_processExists(uint32_t uProcessID, ComObjPtr<GuestProcess> *pProcess);
+    inline int              i_processGetByPID(ULONG uPID, ComObjPtr<GuestProcess> *pProcess);
+    int                     i_sendMessage(uint32_t uFunction, uint32_t uParms, PVBOXHGCMSVCPARM paParms,
+                                          uint64_t fDst = VBOX_GUESTCTRL_DST_SESSION);
+    int                     i_setSessionStatus(GuestSessionStatus_T sessionStatus, int vrcSession);
+    int                     i_signalWaiters(GuestSessionWaitResult_T enmWaitResult, int vrc /*= VINF_SUCCESS */);
+    int                     i_shutdown(uint32_t fFlags, int *pvrcGuest);
+    int                     i_determineProtocolVersion(void);
+    int                     i_waitFor(uint32_t fWaitFlags, ULONG uTimeoutMS, GuestSessionWaitResult_T &waitResult, int *pvrcGuest);
+    int                     i_waitForStatusChange(GuestWaitEvent *pEvent, uint32_t fWaitFlags, uint32_t uTimeoutMS,
+                                                  GuestSessionStatus_T *pSessionStatus, int *pvrcGuest);
+    /** @}  */
+
+public:
+
+    /** @name Static helper methods.
+     * @{ */
+    static Utf8Str          i_guestErrorToString(int guestRc);
+    static bool             i_isTerminated(GuestSessionStatus_T enmStatus);
+    static int              i_startSessionThreadTask(GuestSessionTaskInternalStart *pTask);
+    /** @}  */
+
+private:
+
+    /** Pointer to the parent (Guest). */
+    Guest                          *mParent;
+    /**
+     * The session's event source. This source is used for
+     * serving the internal listener as well as all other
+     * external listeners that may register to it.
+     *
+     * Note: This can safely be used without holding any locks.
+     * An AutoCaller suffices to prevent it being destroy while in use and
+     * internally there is a lock providing the necessary serialization.
+     */
+    const ComObjPtr<EventSource>    mEventSource;
+
+    /** @todo r=bird: One of the core points of the DATA sub-structures in Main is
+     * hinding implementation details and stuff that requires including iprt/asm.h.
+     * The way it's used here totally defeats that purpose.  You need to make it
+     * a pointer to a anynmous Data struct and define that structure in
+     * GuestSessionImpl.cpp and allocate it in the Init() function.
+     */
+    struct Data
+    {
+        /** The session credentials. */
+        GuestCredentials            mCredentials;
+        /** The session's startup info. */
+        GuestSessionStartupInfo     mSession;
+        /** The session's object ID.
+         *  Needed for registering wait events which are bound directly to this session. */
+        uint32_t                    mObjectID;
+        /** The session's current status. */
+        GuestSessionStatus_T        mStatus;
+        /** The set of environment changes for the session for use when
+         *  creating new guest processes. */
+        GuestEnvironmentChanges     mEnvironmentChanges;
+        /** Pointer to the immutable base environment for the session.
+         * @note This is not allocated until the guest reports it to the host. It is
+         *       also shared with child processes.
+         * @todo This is actually not yet implemented, see
+         *       GuestSession::i_onSessionStatusChange. */
+        GuestEnvironment const     *mpBaseEnvironment;
+        /** Directory objects bound to this session. */
+        SessionDirectories          mDirectories;
+        /** File objects bound to this session. */
+        SessionFiles                mFiles;
+        /** Process objects bound to this session. */
+        SessionProcesses            mProcesses;
+        /** Map of registered session objects (files, directories, ...). */
+        SessionObjects              mObjects;
+        /** Guest control protocol version to be used.
+         *  Guest Additions < VBox 4.3 have version 1,
+         *  any newer version will have version 2. */
+        uint32_t                    mProtocolVersion;
+        /** Session timeout (in ms). */
+        uint32_t                    mTimeout;
+        /** The last returned session VBox status status returned from the guest side. */
+        int                         mVrc;
+        /** Object ID allocation bitmap; clear bits are free, set bits are busy. */
+        uint64_t                    bmObjectIds[VBOX_GUESTCTRL_MAX_OBJECTS / sizeof(uint64_t) / 8];
+
+        Data(void)
+            : mpBaseEnvironment(NULL)
+        {
+            RT_ZERO(bmObjectIds);
+            ASMBitSet(&bmObjectIds, VBOX_GUESTCTRL_MAX_OBJECTS - 1);    /* Reserved for the session itself? */
+            ASMBitSet(&bmObjectIds, 0);                                 /* Let's reserve this too. */
+        }
+        Data(const Data &rThat)
+            : mCredentials(rThat.mCredentials)
+            , mSession(rThat.mSession)
+            , mStatus(rThat.mStatus)
+            , mEnvironmentChanges(rThat.mEnvironmentChanges)
+            , mpBaseEnvironment(NULL)
+            , mDirectories(rThat.mDirectories)
+            , mFiles(rThat.mFiles)
+            , mProcesses(rThat.mProcesses)
+            , mObjects(rThat.mObjects)
+            , mProtocolVersion(rThat.mProtocolVersion)
+            , mTimeout(rThat.mTimeout)
+            , mVrc(rThat.mVrc)
+        {
+            memcpy(&bmObjectIds, &rThat.bmObjectIds, sizeof(bmObjectIds));
+        }
+        ~Data(void)
+        {
+            if (mpBaseEnvironment)
+            {
+                mpBaseEnvironment->releaseConst();
+                mpBaseEnvironment = NULL;
+            }
+        }
+    } mData;
+};
+
+#endif /* !MAIN_INCLUDED_GuestSessionImpl_h */
+
diff --git a/src/VBox/Main/include/GuestSessionImplTasks.h b/src/VBox/Main/include/GuestSessionImplTasks.h
new file mode 100644
index 00000000..d32cd8b3
--- /dev/null
+++ b/src/VBox/Main/include/GuestSessionImplTasks.h
@@ -0,0 +1,436 @@
+/* $Id: GuestSessionImplTasks.h $ */
+/** @file
+ * VirtualBox Main - Guest session tasks header.
+ */
+
+/*
+ * Copyright (C) 2018-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
+ */
+
+#ifndef MAIN_INCLUDED_GuestSessionImplTasks_h
+#define MAIN_INCLUDED_GuestSessionImplTasks_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "GuestSessionWrap.h"
+#include "EventImpl.h"
+#include "ProgressImpl.h"
+
+#include "GuestCtrlImplPrivate.h"
+#include "GuestSessionImpl.h"
+#include "ThreadTask.h"
+
+#include <iprt/vfs.h>
+
+#include <vector>
+
+class Guest;
+class GuestSessionTask;
+class GuestSessionTaskInternalStart;
+
+
+/**
+ * Structure for keeping a file system source specification,
+ * along with options.
+ */
+struct GuestSessionFsSourceSpec
+{
+    GuestSessionFsSourceSpec()
+        : enmType(FsObjType_Unknown)
+        , enmPathStyle(PathStyle_Unknown)
+        , fDryRun(false) { RT_ZERO(Type); }
+
+    /** The (absolute) path to the source to use. */
+    Utf8Str     strSource;
+    /** Filter to use. Currently not implemented and thus ignored. */
+    Utf8Str     strFilter;
+    /** The root object type of this source (directory, file). */
+    FsObjType_T enmType;
+    /** The path style to use. */
+    PathStyle_T enmPathStyle;
+    /** Whether to do a dry run (e.g. not really touching anything) or not. */
+    bool        fDryRun;
+    /** Directory copy flags. */
+    DirectoryCopyFlag_T fDirCopyFlags;
+    /** File copy flags. */
+    FileCopyFlag_T      fFileCopyFlags;
+    /** Union to keep type-specific data. Must be a POD type (zero'ing). */
+    union
+    {
+        /** File-specific data. */
+        struct
+        {
+            /** Source file offset to start copying from. */
+            size_t              offStart;
+            /** Host file handle to use for reading from / writing to.
+             *  Optional and can be NULL if not used. */
+            PRTFILE             phFile;
+            /** Source size (in bytes) to copy. */
+            uint64_t            cbSize;
+        } File;
+    } Type;
+};
+
+/** A set of GuestSessionFsSourceSpec sources. */
+typedef std::vector<GuestSessionFsSourceSpec> GuestSessionFsSourceSet;
+
+/**
+ * Structure for keeping a file system entry.
+ */
+struct FsEntry
+{
+    /** The entrie's file mode. */
+    RTFMODE fMode;
+    /** The entrie's path, relative to the list's root path. */
+    Utf8Str strPath;
+};
+
+/** A vector of FsEntry entries. */
+typedef std::vector<FsEntry *> FsEntries;
+
+/**
+ * Class for storing and handling file system entries, neeed for doing
+ * internal file / directory operations to / from the guest.
+ */
+class FsList
+{
+public:
+
+    FsList(const GuestSessionTask &Task);
+    virtual ~FsList();
+
+public:
+
+    int Init(const Utf8Str &strSrcRootAbs, const Utf8Str &strDstRootAbs, const GuestSessionFsSourceSpec &SourceSpec);
+    void Destroy(void);
+
+#ifdef DEBUG
+    void DumpToLog(void);
+#endif
+
+    int AddEntryFromGuest(const Utf8Str &strFile, const GuestFsObjData &fsObjData);
+    int AddDirFromGuest(const Utf8Str &strPath, const Utf8Str &strSubDir = "");
+
+    int AddEntryFromHost(const Utf8Str &strFile, PCRTFSOBJINFO pcObjInfo);
+    int AddDirFromHost(const Utf8Str &strPath, const Utf8Str &strSubDir, char *pszPathReal, size_t cbPathReal, PRTDIRENTRYEX pDirEntry);
+
+public:
+
+    /** The guest session task object this list is working on. */
+    const GuestSessionTask  &mTask;
+    /** File system filter / options to use for this task. */
+    GuestSessionFsSourceSpec mSourceSpec;
+    /** The source' root path. Always in the source's path style!
+     *
+     *  For a single file list this is the full (absolute) path to a file,
+     *  for a directory list this is the source root directory. */
+    Utf8Str                 mSrcRootAbs;
+    /** The destinations's root path. Always in the destination's path style!
+     *
+     *  For a single file list this is the full (absolute) path to a file,
+     *  for a directory list this is the destination root directory. */
+    Utf8Str                 mDstRootAbs;
+    /** Total size (in bytes) of all list entries together. */
+    uint64_t                mcbTotalSize;
+    /** List of file system entries this list contains. */
+    FsEntries               mVecEntries;
+};
+
+/** A set of FsList lists. */
+typedef std::vector<FsList *> FsLists;
+
+/**
+ * Abstract base class for a lenghtly per-session operation which
+ * runs in a Main worker thread.
+ */
+class GuestSessionTask
+    : public ThreadTask
+{
+public:
+    DECLARE_TRANSLATE_METHODS(GuestSessionTask)
+
+    GuestSessionTask(GuestSession *pSession);
+
+    virtual ~GuestSessionTask(void);
+
+public:
+
+    /**
+     * Function which implements the actual task to perform.
+     *
+     * @returns VBox status code.
+     */
+    virtual int Run(void) = 0;
+
+    void handler()
+    {
+        int vrc = Run();
+        if (RT_FAILURE(vrc)) /* Could be VERR_INTERRUPTED if the user manually canceled the task. */
+        {
+            /* Make sure to let users know if there is a buggy task which failed but didn't set the progress object
+             * to a failed state, and if not canceled manually by the user. */
+            BOOL fCanceled;
+            if (SUCCEEDED(mProgress->COMGETTER(Canceled(&fCanceled))))
+            {
+                if (!fCanceled)
+                {
+                    BOOL fCompleted;
+                    if (SUCCEEDED(mProgress->COMGETTER(Completed(&fCompleted))))
+                    {
+                        if (!fCompleted)
+                            setProgressErrorMsg(E_UNEXPECTED,
+                                                Utf8StrFmt(tr("Task '%s' failed with %Rrc, but progress is still pending. Please report this bug!\n"),
+                                                           mDesc.c_str(), vrc));
+                    }
+                    else
+                        AssertReleaseMsgFailed(("Guest Control: Unable to retrieve progress completion status for task '%s' (task result is %Rrc)\n",
+                                                mDesc.c_str(), vrc));
+                }
+            }
+            else
+                AssertReleaseMsgFailed(("Guest Control: Unable to retrieve progress cancellation status for task '%s' (task result is %Rrc)\n",
+                                        mDesc.c_str(), vrc));
+        }
+    }
+
+    // unused: int RunAsync(const Utf8Str &strDesc, ComObjPtr<Progress> &pProgress);
+
+    virtual HRESULT Init(const Utf8Str &strTaskDesc)
+    {
+        setTaskDesc(strTaskDesc);
+        int vrc = createAndSetProgressObject(); /* Single operation by default. */
+        if (RT_SUCCESS(vrc))
+            return S_OK;
+        return E_FAIL;
+    }
+
+    /** Returns the task's progress object. */
+    const ComObjPtr<Progress>& GetProgressObject(void) const { return mProgress; }
+
+    /** Returns the task's guest session object. */
+    const ComObjPtr<GuestSession>& GetSession(void) const { return mSession; }
+
+protected:
+
+    /** @name Directory handling primitives.
+     * @{ */
+    int directoryCreateOnGuest(const com::Utf8Str &strPath,
+                               uint32_t fMode, DirectoryCreateFlag_T enmDirectoryCreateFlags,
+                               bool fFollowSymlinks, bool fCanExist);
+    int directoryCreateOnHost(const com::Utf8Str &strPath, uint32_t fMode, uint32_t fCreate, bool fCanExist);
+    /** @}  */
+
+    /** @name File handling primitives.
+     * @{ */
+    int fileClose(const ComObjPtr<GuestFile> &file);
+    int fileCopyFromGuestInner(const Utf8Str &strSrcFile, ComObjPtr<GuestFile> &srcFile,
+                               const Utf8Str &strDstFile, PRTFILE phDstFile,
+                               FileCopyFlag_T fFileCopyFlags, uint64_t offCopy, uint64_t cbSize);
+    int fileCopyFromGuest(const Utf8Str &strSource, const Utf8Str &strDest, FileCopyFlag_T fFileCopyFlags);
+    int fileCopyToGuestInner(const Utf8Str &strSrcFile, RTVFSFILE hSrcFile,
+                             const Utf8Str &strDstFile, ComObjPtr<GuestFile> &dstFile,
+                             FileCopyFlag_T fFileCopyFlags, uint64_t offCopy, uint64_t cbSize);
+
+    int fileCopyToGuest(const Utf8Str &strSource, const Utf8Str &strDest, FileCopyFlag_T fFileCopyFlags);
+    /** @}  */
+
+    /** @name Guest property handling primitives.
+     * @{ */
+    int getGuestProperty(const ComObjPtr<Guest> &pGuest, const Utf8Str &strPath, Utf8Str &strValue);
+    /** @}  */
+
+    int setProgress(ULONG uPercent);
+    int setProgressSuccess(void);
+    HRESULT setProgressErrorMsg(HRESULT hrc, const Utf8Str &strMsg);
+    HRESULT setProgressErrorMsg(HRESULT hrc, const Utf8Str &strMsg, const GuestErrorInfo &guestErrorInfo);
+
+    inline void setTaskDesc(const Utf8Str &strTaskDesc) throw()
+    {
+        mDesc = strTaskDesc;
+    }
+
+    int createAndSetProgressObject(ULONG cOperations  = 1);
+
+protected:
+
+    Utf8Str                 mDesc;
+    /** The guest session object this task is working on. */
+    ComObjPtr<GuestSession> mSession;
+    /** Progress object for getting updated when running
+     *  asynchronously. Optional. */
+    ComObjPtr<Progress>     mProgress;
+    /** The guest's path style as char representation (depending on the guest OS type set). */
+    Utf8Str                 mstrGuestPathStyle;
+};
+
+/**
+ * Task for opening a guest session.
+ */
+class GuestSessionTaskOpen : public GuestSessionTask
+{
+public:
+
+    GuestSessionTaskOpen(GuestSession *pSession,
+                    uint32_t uFlags,
+                    uint32_t uTimeoutMS);
+    virtual ~GuestSessionTaskOpen(void);
+    int Run(void);
+
+protected:
+
+    /** Session creation flags. */
+    uint32_t mFlags;
+    /** Session creation timeout (in ms). */
+    uint32_t mTimeoutMS;
+};
+
+class GuestSessionCopyTask : public GuestSessionTask
+{
+public:
+    DECLARE_TRANSLATE_METHODS(GuestSessionCopyTask)
+
+    GuestSessionCopyTask(GuestSession *pSession);
+    virtual ~GuestSessionCopyTask();
+
+protected:
+
+    /** Source set. */
+    GuestSessionFsSourceSet mSources;
+    /** Destination to copy to. */
+    Utf8Str                 mDest;
+    /** Vector of file system lists to handle.
+     *  This either can be from the guest or the host side. */
+    FsLists                 mVecLists;
+};
+
+/**
+ * Guest session task for copying files / directories from guest to the host.
+ */
+class GuestSessionTaskCopyFrom : public GuestSessionCopyTask
+{
+public:
+    DECLARE_TRANSLATE_METHODS(GuestSessionTaskCopyFrom)
+
+    GuestSessionTaskCopyFrom(GuestSession *pSession, GuestSessionFsSourceSet const &vecSrc, const Utf8Str &strDest);
+    virtual ~GuestSessionTaskCopyFrom(void);
+
+    HRESULT Init(const Utf8Str &strTaskDesc);
+    int Run(void);
+};
+
+/**
+ * Task for copying directories from host to the guest.
+ */
+class GuestSessionTaskCopyTo : public GuestSessionCopyTask
+{
+public:
+    DECLARE_TRANSLATE_METHODS(GuestSessionTaskCopyTo)
+
+    GuestSessionTaskCopyTo(GuestSession *pSession, GuestSessionFsSourceSet const &vecSrc, const Utf8Str &strDest);
+    virtual ~GuestSessionTaskCopyTo(void);
+
+    HRESULT Init(const Utf8Str &strTaskDesc);
+    int Run(void);
+};
+
+/**
+ * Guest session task for automatically updating the Guest Additions on the guest.
+ */
+class GuestSessionTaskUpdateAdditions : public GuestSessionTask
+{
+public:
+    DECLARE_TRANSLATE_METHODS(GuestSessionTaskUpdateAdditions)
+
+    GuestSessionTaskUpdateAdditions(GuestSession *pSession, const Utf8Str &strSource,
+                                    const ProcessArguments &aArguments, uint32_t fFlags);
+    virtual ~GuestSessionTaskUpdateAdditions(void);
+    int Run(void);
+
+protected:
+
+    /**
+     * Suported OS types for automatic updating.
+     */
+    enum eOSType
+    {
+        eOSType_Unknown = 0,
+        eOSType_Windows = 1,
+        eOSType_Linux   = 2,
+        eOSType_Solaris = 3
+    };
+
+    /**
+     * Structure representing a file to
+     * get off the .ISO, copied to the guest.
+     */
+    struct ISOFile
+    {
+        ISOFile(const Utf8Str &aSource,
+                const Utf8Str &aDest,
+                uint32_t       aFlags = 0)
+            : strSource(aSource),
+              strDest(aDest),
+              fFlags(aFlags) { }
+
+        ISOFile(const Utf8Str                 &aSource,
+                const Utf8Str                 &aDest,
+                uint32_t                       aFlags,
+                const GuestProcessStartupInfo &aStartupInfo)
+            : strSource(aSource),
+              strDest(aDest),
+              fFlags(aFlags),
+              mProcInfo(aStartupInfo)
+        {
+            mProcInfo.mExecutable = strDest;
+            if (mProcInfo.mName.isEmpty())
+                mProcInfo.mName = strDest;
+        }
+
+        /** Source file on .ISO. */
+        Utf8Str                 strSource;
+        /** Destination file on the guest. */
+        Utf8Str                 strDest;
+        /** ISO file flags (see ISOFILE_FLAG_ defines). */
+        uint32_t                fFlags;
+        /** Optional arguments if this file needs to be
+         *  executed. */
+        GuestProcessStartupInfo mProcInfo;
+    };
+
+    int addProcessArguments(ProcessArguments &aArgumentsDest, const ProcessArguments &aArgumentsSource);
+    int copyFileToGuest(GuestSession *pSession, RTVFS hVfsIso, Utf8Str const &strFileSource, const Utf8Str &strFileDest, bool fOptional);
+    int runFileOnGuest(GuestSession *pSession, GuestProcessStartupInfo &procInfo, bool fSilent = false);
+
+    int checkGuestAdditionsStatus(GuestSession *pSession, eOSType osType);
+    int waitForGuestSession(ComObjPtr<Guest> pGuest, eOSType osType);
+
+    /** Files to handle. */
+    std::vector<ISOFile>        mFiles;
+    /** The (optionally) specified Guest Additions .ISO on the host
+     *  which will be used for the updating process. */
+    Utf8Str                     mSource;
+    /** (Optional) installer command line arguments. */
+    ProcessArguments            mArguments;
+    /** Update flags. */
+    uint32_t                    mFlags;
+};
+#endif /* !MAIN_INCLUDED_GuestSessionImplTasks_h */
diff --git a/src/VBox/Main/include/HGCM.h b/src/VBox/Main/include/HGCM.h
new file mode 100644
index 00000000..47b0ccf2
--- /dev/null
+++ b/src/VBox/Main/include/HGCM.h
@@ -0,0 +1,69 @@
+/* $Id: HGCM.h $ */
+/** @file
+ * HGCM - Host-Guest Communication Manager.
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_HGCM_h
+#define MAIN_INCLUDED_HGCM_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/vmm/pdmifs.h>
+
+#include <VBox/hgcmsvc.h>
+
+/* Handle of a HGCM service extension. */
+struct _HGCMSVCEXTHANDLEDATA;
+typedef struct _HGCMSVCEXTHANDLEDATA *HGCMSVCEXTHANDLE;
+
+RT_C_DECLS_BEGIN
+int HGCMHostInit(void);
+int HGCMHostShutdown(bool fUvmIsInvalid = false);
+
+int HGCMHostReset(bool fForShutdown);
+
+int HGCMHostLoad(const char *pszServiceLibrary, const char *pszServiceName,
+                 PUVM pUVM, PCVMMR3VTABLE pVMM, PPDMIHGCMPORT pHgcmPort);
+
+int HGCMHostRegisterServiceExtension(HGCMSVCEXTHANDLE *pHandle, const char *pszServiceName, PFNHGCMSVCEXT pfnExtension, void *pvExtension);
+void HGCMHostUnregisterServiceExtension(HGCMSVCEXTHANDLE handle);
+
+int HGCMGuestConnect(PPDMIHGCMPORT pHGCMPort, PVBOXHGCMCMD pCmdPtr, const char *pszServiceName, uint32_t *pClientID);
+int HGCMGuestDisconnect(PPDMIHGCMPORT pHGCMPort, PVBOXHGCMCMD pCmdPtr, uint32_t clientID);
+int HGCMGuestCall(PPDMIHGCMPORT pHGCMPort, PVBOXHGCMCMD pCmdPtr, uint32_t clientID, uint32_t function, uint32_t cParms,
+                  VBOXHGCMSVCPARM *paParms, uint64_t tsArrival);
+void HGCMGuestCancelled(PPDMIHGCMPORT pHGCMPort, PVBOXHGCMCMD pCmdPtr, uint32_t idClient);
+
+int HGCMHostCall(const char *pszServiceName, uint32_t function, uint32_t cParms, VBOXHGCMSVCPARM aParms[]);
+int HGCMBroadcastEvent(HGCMNOTIFYEVENT enmEvent);
+
+int HGCMHostSaveState(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM);
+int HGCMHostLoadState(PSSMHANDLE pSSM, PCVMMR3VTABLE pVMM, uint32_t uVersion);
+
+RT_C_DECLS_END
+
+#endif /* !MAIN_INCLUDED_HGCM_h */
+
diff --git a/src/VBox/Main/include/HGCMObjects.h b/src/VBox/Main/include/HGCMObjects.h
new file mode 100644
index 00000000..a651d3c3
--- /dev/null
+++ b/src/VBox/Main/include/HGCMObjects.h
@@ -0,0 +1,138 @@
+/* $Id: HGCMObjects.h $ */
+/** @file
+ * HGCMObjects - Host-Guest Communication Manager objects header.
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_HGCMObjects_h
+#define MAIN_INCLUDED_HGCMObjects_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/assert.h>
+#include <iprt/avl.h>
+#include <iprt/critsect.h>
+#include <iprt/asm.h>
+
+class HGCMObject;
+
+typedef struct ObjectAVLCore
+{
+    AVLU32NODECORE AvlCore;
+    HGCMObject *pSelf;
+} ObjectAVLCore;
+
+typedef enum
+{
+    HGCMOBJ_CLIENT,
+    HGCMOBJ_THREAD,
+    HGCMOBJ_MSG,
+    HGCMOBJ_SizeHack   = 0x7fffffff
+} HGCMOBJ_TYPE;
+
+
+/**
+ * A referenced object.
+ */
+class HGCMReferencedObject
+{
+    private:
+        int32_t volatile m_cRefs;
+        HGCMOBJ_TYPE     m_enmObjType;
+
+    protected:
+        virtual ~HGCMReferencedObject()
+        {}
+
+    public:
+        HGCMReferencedObject(HGCMOBJ_TYPE enmObjType)
+            : m_cRefs(0)   /** @todo change to 1! */
+            , m_enmObjType(enmObjType)
+        {}
+
+        void Reference()
+        {
+            int32_t cRefs = ASMAtomicIncS32(&m_cRefs);
+            NOREF(cRefs);
+            Log(("Reference(%p/%d): cRefs = %d\n", this, m_enmObjType, cRefs));
+        }
+
+        void Dereference()
+        {
+            int32_t cRefs = ASMAtomicDecS32(&m_cRefs);
+            Log(("Dereference(%p/%d): cRefs = %d \n", this, m_enmObjType, cRefs));
+            AssertRelease(cRefs >= 0);
+
+            if (cRefs)
+            { /* likely */ }
+            else
+                delete this;
+        }
+
+        HGCMOBJ_TYPE Type()
+        {
+            return m_enmObjType;
+        }
+};
+
+
+class HGCMObject : public HGCMReferencedObject
+{
+    private:
+        friend uint32_t hgcmObjMake(HGCMObject *pObject, uint32_t u32HandleIn);
+
+        ObjectAVLCore   m_core;
+
+    protected:
+        virtual ~HGCMObject()
+        {}
+
+    public:
+        HGCMObject(HGCMOBJ_TYPE enmObjType)
+            : HGCMReferencedObject(enmObjType)
+        {}
+
+        uint32_t Handle()
+        {
+            return (uint32_t)m_core.AvlCore.Key;
+        }
+};
+
+int         hgcmObjInit();
+void        hgcmObjUninit();
+
+uint32_t    hgcmObjGenerateHandle(HGCMObject *pObject);
+uint32_t    hgcmObjAssignHandle(HGCMObject *pObject, uint32_t u32Handle);
+
+void        hgcmObjDeleteHandle(uint32_t handle);
+
+HGCMObject *hgcmObjReference(uint32_t handle, HGCMOBJ_TYPE enmObjType);
+void        hgcmObjDereference(HGCMObject *pObject);
+
+uint32_t    hgcmObjQueryHandleCount();
+void        hgcmObjSetHandleCount(uint32_t u32HandleCount);
+
+
+#endif /* !MAIN_INCLUDED_HGCMObjects_h */
diff --git a/src/VBox/Main/include/HGCMThread.h b/src/VBox/Main/include/HGCMThread.h
new file mode 100644
index 00000000..cbb96538
--- /dev/null
+++ b/src/VBox/Main/include/HGCMThread.h
@@ -0,0 +1,238 @@
+/* $Id: HGCMThread.h $ */
+/** @file
+ * HGCMThread - Host-Guest Communication Manager worker threads header.
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_HGCMThread_h
+#define MAIN_INCLUDED_HGCMThread_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/types.h>
+
+#include "HGCMObjects.h"
+
+/* Forward declaration of the worker thread class. */
+class HGCMThread;
+
+/** A handle for HGCM message. */
+typedef uint32_t HGCMMSGHANDLE;
+
+/* Forward declaration of message core class. */
+class HGCMMsgCore;
+
+/** @todo comment */
+
+typedef HGCMMsgCore *FNHGCMNEWMSGALLOC(uint32_t u32MsgId);
+typedef FNHGCMNEWMSGALLOC *PFNHGCMNEWMSGALLOC;
+
+/** Function that is called after message processing by worker thread,
+ *  or if an error occurred during message handling after successfully
+ *  posting (hgcmMsgPost) the message to worker thread.
+ *
+ * @param result    Return code either from the service which actually processed the message
+ *                  or from HGCM.
+ * @param pMsgCore  Pointer to just processed message.
+ *
+ * @return Restricted set of VBox status codes when guest call message:
+ * @retval VINF_SUCCESS on success
+ * @retval VERR_CANCELLED if the request was cancelled.
+ * @retval VERR_ALREADY_RESET if the VM is resetting.
+ * @retval VERR_NOT_AVAILABLE if HGCM has been disconnected from the VMMDev
+ *         (shouldn't happen).
+ */
+typedef DECLCALLBACKTYPE(int, FNHGCMMSGCALLBACK,(int32_t result, HGCMMsgCore *pMsgCore));
+/** Pointer to a message completeion callback function. */
+typedef FNHGCMMSGCALLBACK *PFNHGCMMSGCALLBACK;
+
+
+/** HGCM core message. */
+class HGCMMsgCore : public HGCMReferencedObject
+{
+    private:
+        friend class HGCMThread;
+
+        /** Version of message header. */
+        uint32_t m_u32Version;
+
+        /** Message number/identifier. */
+        uint32_t m_u32Msg;
+
+        /** Thread the message belongs to, referenced by the message. */
+        HGCMThread *m_pThread;
+
+        /** Callback function pointer. */
+        PFNHGCMMSGCALLBACK m_pfnCallback;
+
+        /** Next element in a message queue. */
+        HGCMMsgCore *m_pNext;
+        /** Previous element in a message queue.
+         *  @todo seems not necessary. */
+        HGCMMsgCore *m_pPrev;
+
+        /** Various internal flags. */
+        uint32_t m_fu32Flags;
+
+        /** Result code for a Send */
+        int32_t m_vrcSend;
+
+    protected:
+        void InitializeCore(uint32_t u32MsgId, HGCMThread *pThread);
+
+        virtual ~HGCMMsgCore();
+
+    public:
+        HGCMMsgCore() : HGCMReferencedObject(HGCMOBJ_MSG) {};
+
+        uint32_t MsgId(void) { return m_u32Msg; };
+
+        HGCMThread *Thread(void) { return m_pThread; };
+
+        /** Initialize message after it was allocated. */
+        virtual void Initialize(void) {};
+
+        /** Uninitialize message. */
+        virtual void Uninitialize(void) {};
+};
+
+
+/** HGCM worker thread function.
+ *
+ *  @param pThread       The HGCM thread instance.
+ *  @param pvUser        User specified thread parameter.
+ */
+typedef DECLCALLBACKTYPE(void, FNHGCMTHREAD,(HGCMThread *pThread, void *pvUser));
+typedef FNHGCMTHREAD *PFNHGCMTHREAD;
+
+
+/**
+ * Thread API.
+ * Based on thread handles. Internals of a thread are not exposed to users.
+ */
+
+/** Initialize threads.
+ *
+ * @return VBox status code.
+ */
+int hgcmThreadInit(void);
+void hgcmThreadUninit(void);
+
+
+/** Create a HGCM worker thread.
+ *
+ * @param ppThread          Where to return the pointer to the worker thread.
+ * @param pszThreadName     Name of the thread, needed by runtime.
+ * @param pfnThread         The worker thread function.
+ * @param pvUser            A pointer passed to worker thread.
+ * @param pszStatsSubDir    The "sub-directory" under "/HGCM/" where thread
+ *                          statistics should be registered.  The caller,
+ *                          HGCMService, will deregister them.  NULL if no stats.
+ * @param pUVM              The user mode VM handle to register statistics with.
+ *                          NULL if no stats.
+ * @param pVMM              The VMM vtable for statistics registration. NULL if
+ *                          no stats.
+ *
+ * @return VBox status code.
+ */
+int hgcmThreadCreate(HGCMThread **ppThread, const char *pszThreadName, PFNHGCMTHREAD pfnThread, void *pvUser,
+                     const char *pszStatsSubDir, PUVM pUVM, PCVMMR3VTABLE pVMM);
+
+/** Wait for termination of a HGCM worker thread.
+ *
+ * @param pThread       The HGCM thread.  The passed in reference is always
+ *                      consumed.
+ *
+ * @return VBox status code.
+ */
+int hgcmThreadWait(HGCMThread *pThread);
+
+/** Allocate a message to be posted to HGCM worker thread.
+ *
+ * @param pThread       The HGCM worker thread.
+ * @param ppHandle      Where to store the pointer to the new message.
+ * @param u32MsgId      Message identifier.
+ * @param pfnNewMessage New message allocation callback.
+ *
+ * @return VBox status code.
+ */
+int hgcmMsgAlloc(HGCMThread *pThread, HGCMMsgCore **ppHandle, uint32_t u32MsgId, PFNHGCMNEWMSGALLOC pfnNewMessage);
+
+/** Post a message to HGCM worker thread.
+ *
+ * @param pMsg          The message.  Reference will be consumed!
+ * @param pfnCallback   Message completion callback.
+ *
+ * @return VBox status code.
+ * @retval VINF_HGCM_ASYNC_EXECUTE on success.
+ *
+ * @thread any
+ */
+int hgcmMsgPost(HGCMMsgCore *pMsg, PFNHGCMMSGCALLBACK pfnCallback);
+
+/** Send a message to HGCM worker thread.
+ *
+ *  The function will return after message is processed by thread.
+ *
+ * @param pMsg          The message.  Reference will be consumed!
+ *
+ * @return VBox status code.
+ *
+ * @thread any
+ */
+int hgcmMsgSend(HGCMMsgCore *pMsg);
+
+
+/* Wait for and get a message.
+ *
+ * @param pThread       The HGCM worker thread.
+ * @param ppMsg         Where to store returned message pointer.
+ *
+ * @return VBox status code.
+ *
+ * @thread worker thread
+ */
+int hgcmMsgGet(HGCMThread *pThread, HGCMMsgCore **ppMsg);
+
+
+/** Worker thread has processed a message previously obtained with hgcmMsgGet.
+ *
+ * @param pMsg          Processed message pointer.
+ * @param result        Result code, VBox status code.
+ *
+ * @return Restricted set of VBox status codes when guest call message:
+ * @retval VINF_SUCCESS on success
+ * @retval VERR_CANCELLED if the request was cancelled.
+ * @retval VERR_ALREADY_RESET if the VM is resetting.
+ * @retval VERR_NOT_AVAILABLE if HGCM has been disconnected from the VMMDev
+ *         (shouldn't happen).
+ *
+ * @thread worker thread
+ */
+int hgcmMsgComplete(HGCMMsgCore *pMsg, int32_t result);
+
+
+#endif /* !MAIN_INCLUDED_HGCMThread_h */
+
diff --git a/src/VBox/Main/include/HashedPw.h b/src/VBox/Main/include/HashedPw.h
new file mode 100644
index 00000000..19a82c22
--- /dev/null
+++ b/src/VBox/Main/include/HashedPw.h
@@ -0,0 +1,40 @@
+/* $Id: HashedPw.h $ */
+/** @file
+ * Main - Password Hashing
+ */
+
+/*
+ * Copyright (C) 2012-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
+ */
+
+#ifndef MAIN_INCLUDED_HashedPw_h
+#define MAIN_INCLUDED_HashedPw_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/cpp/ministring.h>
+
+bool    VBoxIsPasswordHashed(RTCString const *a_pstrPassword);
+void    VBoxHashPassword(RTCString *a_pstrPassword);
+
+#endif /* !MAIN_INCLUDED_HashedPw_h */
+
diff --git a/src/VBox/Main/include/HostAudioDeviceImpl.h b/src/VBox/Main/include/HostAudioDeviceImpl.h
new file mode 100644
index 00000000..c3a8895b
--- /dev/null
+++ b/src/VBox/Main/include/HostAudioDeviceImpl.h
@@ -0,0 +1,58 @@
+/* $Id: HostAudioDeviceImpl.h $ */
+
+/** @file
+ * VirtualBox COM class implementation - Host audio device implementation.
+ */
+
+/*
+ * Copyright (C) 2022-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
+ */
+
+#ifndef MAIN_INCLUDED_HostAudioDeviceImpl_h
+#define MAIN_INCLUDED_HostAudioDeviceImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "HostAudioDeviceWrap.h"
+
+class ATL_NO_VTABLE HostAudioDevice :
+    public HostAudioDeviceWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(HostAudioDevice)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init();
+    void uninit();
+
+private:
+
+    // wrapped IHostAudioDevice properties
+
+};
+
+#endif /* !MAIN_INCLUDED_HostAudioDeviceImpl_h */
+
diff --git a/src/VBox/Main/include/HostDriveImpl.h b/src/VBox/Main/include/HostDriveImpl.h
new file mode 100644
index 00000000..37a55677
--- /dev/null
+++ b/src/VBox/Main/include/HostDriveImpl.h
@@ -0,0 +1,86 @@
+/* $Id: HostDriveImpl.h $ */
+/** @file
+ * VirtualBox Main - IHostDrive implementation, VBoxSVC.
+ */
+
+/*
+ * Copyright (C) 2013-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
+ */
+
+#ifndef MAIN_INCLUDED_HostDriveImpl_h
+#define MAIN_INCLUDED_HostDriveImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "HostDriveWrap.h"
+
+class ATL_NO_VTABLE HostDrive
+    : public HostDriveWrap
+{
+public:
+    DECLARE_COMMON_CLASS_METHODS(HostDrive)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    /** @name Public initializer/uninitializer for internal purposes only.
+     * @{ */
+    HRESULT initFromPathAndModel(const com::Utf8Str &drivePath, const com::Utf8Str &driveModel);
+    void uninit();
+    /** @} */
+
+    com::Utf8Str i_getDrivePath() { return m.drivePath; }
+
+private:
+    /** @name wrapped IHostDrive properties
+     * @{ */
+    virtual HRESULT getPartitioningType(PartitioningType_T *aPartitioningType) RT_OVERRIDE;
+    virtual HRESULT getDrivePath(com::Utf8Str &aDrivePath) RT_OVERRIDE;
+    virtual HRESULT getUuid(com::Guid &aUuid) RT_OVERRIDE;
+    virtual HRESULT getSectorSize(ULONG *aSectorSize) RT_OVERRIDE;
+    virtual HRESULT getSize(LONG64 *aSize) RT_OVERRIDE;
+    virtual HRESULT getModel(com::Utf8Str &aModel) RT_OVERRIDE;
+    virtual HRESULT getPartitions(std::vector<ComPtr<IHostDrivePartition> > &aPartitions) RT_OVERRIDE;
+    /** @} */
+
+    /** Data. */
+    struct Data
+    {
+        Data() : cbSector(0), cbDisk(0)
+        {
+        }
+
+        PartitioningType_T partitioningType;
+        com::Utf8Str drivePath;
+        com::Guid uuid;
+        uint32_t cbSector;
+        uint64_t cbDisk;
+        com::Utf8Str model;
+        std::vector<ComPtr<IHostDrivePartition> > partitions;
+    };
+
+    Data m;
+};
+
+#endif /* !MAIN_INCLUDED_HostDriveImpl_h */
+
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/HostDrivePartitionImpl.h b/src/VBox/Main/include/HostDrivePartitionImpl.h
new file mode 100644
index 00000000..6c33690f
--- /dev/null
+++ b/src/VBox/Main/include/HostDrivePartitionImpl.h
@@ -0,0 +1,126 @@
+/* $Id: HostDrivePartitionImpl.h $ */
+/** @file
+ * VirtualBox Main - IHostDrivePartition implementation, VBoxSVC.
+ */
+
+/*
+ * Copyright (C) 2013-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
+ */
+
+#ifndef MAIN_INCLUDED_HostDrivePartitionImpl_h
+#define MAIN_INCLUDED_HostDrivePartitionImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "HostDrivePartitionWrap.h"
+
+#include <iprt/dvm.h>
+
+class ATL_NO_VTABLE HostDrivePartition
+    : public HostDrivePartitionWrap
+{
+public:
+    DECLARE_COMMON_CLASS_METHODS(HostDrivePartition)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    /** @name Public initializer/uninitializer for internal purposes only.
+     * @{ */
+    HRESULT initFromDvmVol(RTDVMVOLUME hVol);
+    void uninit();
+    /** @} */
+
+private:
+    /** @name wrapped IHostDrivePartition properties
+     * @{  */
+    /* Common: */
+    virtual HRESULT getNumber(ULONG *aNumber) RT_OVERRIDE               { *aNumber        = m.number;       return S_OK; }
+    virtual HRESULT getSize(LONG64 *aSize) RT_OVERRIDE                  { *aSize          = m.cbVol;        return S_OK; }
+    virtual HRESULT getStart(LONG64 *aStart) RT_OVERRIDE                { *aStart         = m.offStart;     return S_OK; }
+    virtual HRESULT getType(PartitionType_T *aType) RT_OVERRIDE         { *aType          = m.enmType;      return S_OK; }
+    virtual HRESULT getActive(BOOL *aActive) RT_OVERRIDE                { *aActive        = m.active;       return S_OK; }
+    /* MBR: */
+    virtual HRESULT getTypeMBR(ULONG *aTypeMBR) RT_OVERRIDE             { *aTypeMBR       = m.bMBRType;     return S_OK; }
+    virtual HRESULT getStartCylinder(ULONG *aStartCylinder) RT_OVERRIDE { *aStartCylinder = m.firstCylinder; return S_OK; }
+    virtual HRESULT getStartHead(ULONG *aStartHead) RT_OVERRIDE         { *aStartHead     = m.firstHead;    return S_OK; }
+    virtual HRESULT getStartSector(ULONG *aStartSector) RT_OVERRIDE     { *aStartSector   = m.firstSector;  return S_OK; }
+    virtual HRESULT getEndCylinder(ULONG *aEndCylinder) RT_OVERRIDE     { *aEndCylinder   = m.lastCylinder; return S_OK; }
+    virtual HRESULT getEndHead(ULONG *aEndHead) RT_OVERRIDE             { *aEndHead       = m.lastHead;     return S_OK; }
+    virtual HRESULT getEndSector(ULONG *aEndSector) RT_OVERRIDE         { *aEndSector     = m.lastSector;   return S_OK; }
+    /* GPT: */
+    virtual HRESULT getTypeUuid(com::Guid &aTypeUuid) RT_OVERRIDE       { aTypeUuid       = m.typeUuid;     return S_OK; }
+    virtual HRESULT getUuid(com::Guid &aUuid) RT_OVERRIDE               { aUuid           = m.uuid;         return S_OK; }
+    virtual HRESULT getName(com::Utf8Str &aName) RT_OVERRIDE            { return aName.assignEx(m.name); };
+    /** @} */
+
+    /** Data. */
+    struct Data
+    {
+        Data()
+            : number(0)
+            , cbVol(0)
+            , offStart(0)
+            , enmType(PartitionType_Unknown)
+            , active(FALSE)
+            , bMBRType(0)
+            , firstCylinder(0)
+            , firstHead(0)
+            , firstSector(0)
+            , lastCylinder(0)
+            , lastHead(0)
+            , lastSector(0)
+            , typeUuid()
+            , uuid()
+            , name()
+        {
+        }
+
+        ULONG number;
+        LONG64 cbVol;
+        LONG64 offStart;
+        PartitionType_T enmType;
+        BOOL active;
+        /** @name MBR specifics
+         * @{ */
+        uint8_t bMBRType;
+        uint16_t firstCylinder;
+        uint8_t firstHead;
+        uint8_t firstSector;
+        uint16_t lastCylinder;
+        uint8_t lastHead;
+        uint8_t lastSector;
+        /** @} */
+        /** @name GPT specifics
+         * @{ */
+        com::Guid typeUuid;
+        com::Guid uuid;
+        com::Utf8Str name;
+        /** @} */
+    };
+
+    Data m;
+};
+
+#endif /* !MAIN_INCLUDED_HostDrivePartitionImpl_h */
+
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/HostHardwareLinux.h b/src/VBox/Main/include/HostHardwareLinux.h
new file mode 100644
index 00000000..b9206bc6
--- /dev/null
+++ b/src/VBox/Main/include/HostHardwareLinux.h
@@ -0,0 +1,209 @@
+/* $Id: HostHardwareLinux.h $ */
+/** @file
+ * VirtualBox Main - Classes for handling hardware detection under Linux.
+ *
+ * Please feel free to expand these to work for other systems (Solaris!) or to
+ * add new ones for other systems.
+ */
+
+/*
+ * Copyright (C) 2008-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
+ */
+
+#ifndef MAIN_INCLUDED_HostHardwareLinux_h
+#define MAIN_INCLUDED_HostHardwareLinux_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/err.h>
+#include <iprt/cpp/ministring.h>
+#include <vector>
+#include <vector.h>
+
+/**
+ * Class for probing and returning information about host DVD and floppy
+ * drives.  To use this class, create an instance, call one of the update
+ * methods to do the actual probing and use the iterator methods to get the
+ * result of the probe.
+ */
+class VBoxMainDriveInfo
+{
+public:
+    /** Structure describing a host drive */
+    struct DriveInfo
+    {
+        /** The device node of the drive. */
+        RTCString mDevice;
+        /** A unique identifier for the device, if available.  This should be
+         * kept consistent across different probing methods of a given
+         * platform if at all possible. */
+        RTCString mUdi;
+        /** A textual description of the drive. */
+        RTCString mDescription;
+
+        /** Constructors */
+        DriveInfo(const RTCString &aDevice,
+                  const RTCString &aUdi = "",
+                  const RTCString &aDescription = "")
+            : mDevice(aDevice),
+              mUdi(aUdi),
+              mDescription(aDescription)
+        { }
+    };
+
+    /** List (resp vector) holding drive information */
+    typedef std::vector<DriveInfo> DriveInfoList;
+
+    /**
+     * Search for host floppy drives and rebuild the list, which remains empty
+     * until the first time this method is called.
+     * @returns iprt status code
+     */
+    int updateFloppies() RT_NOEXCEPT;
+
+    /**
+     * Search for host DVD drives and rebuild the list, which remains empty
+     * until the first time this method is called.
+     * @returns iprt status code
+     */
+    int updateDVDs() RT_NOEXCEPT;
+
+    /**
+     * Search for fixed disks (HDDs) and rebuild the list, which remains empty until
+     * the first time this method is called.
+     * @returns iprt status code
+     */
+    int updateFixedDrives() RT_NOEXCEPT;
+
+    /** Get the first element in the list of floppy drives. */
+    DriveInfoList::const_iterator FloppyBegin()
+    {
+        return mFloppyList.begin();
+    }
+
+    /** Get the last element in the list of floppy drives. */
+    DriveInfoList::const_iterator FloppyEnd()
+    {
+        return mFloppyList.end();
+    }
+
+    /** Get the first element in the list of DVD drives. */
+    DriveInfoList::const_iterator DVDBegin()
+    {
+        return mDVDList.begin();
+    }
+
+    /** Get the last element in the list of DVD drives. */
+    DriveInfoList::const_iterator DVDEnd()
+    {
+        return mDVDList.end();
+    }
+
+    /** Get the first element in the list of fixed drives. */
+    DriveInfoList::const_iterator FixedDriveBegin()
+    {
+        return mFixedDriveList.begin();
+    }
+
+    /** Get the last element in the list of fixed drives. */
+    DriveInfoList::const_iterator FixedDriveEnd()
+    {
+        return mFixedDriveList.end();
+    }
+private:
+    /** The list of currently available floppy drives */
+    DriveInfoList mFloppyList;
+    /** The list of currently available DVD drives */
+    DriveInfoList mDVDList;
+    /** The list of currently available fixed drives */
+    DriveInfoList mFixedDriveList;
+};
+
+/** Convenience typedef. */
+typedef VBoxMainDriveInfo::DriveInfoList DriveInfoList;
+/** Convenience typedef. */
+typedef VBoxMainDriveInfo::DriveInfo DriveInfo;
+
+/** Implementation of the hotplug waiter class below */
+class VBoxMainHotplugWaiterImpl
+{
+public:
+    VBoxMainHotplugWaiterImpl(void) {}
+    virtual ~VBoxMainHotplugWaiterImpl(void) {}
+    /** @copydoc VBoxMainHotplugWaiter::Wait */
+    virtual int Wait(RTMSINTERVAL cMillies) = 0;
+    /** @copydoc VBoxMainHotplugWaiter::Interrupt */
+    virtual void Interrupt(void) = 0;
+    /** @copydoc VBoxMainHotplugWaiter::getStatus */
+    virtual int getStatus(void) = 0;
+};
+
+/**
+ * Class for waiting for a hotplug event.  To use this class, create an
+ * instance and call the @a Wait() method, which blocks until an event or a
+ * user-triggered interruption occurs.  Call @a Interrupt() to interrupt the
+ * wait before an event occurs.
+ */
+class VBoxMainHotplugWaiter
+{
+    /** Class implementation. */
+    VBoxMainHotplugWaiterImpl *mImpl;
+public:
+    /** Constructor.  Responsible for selecting the implementation. */
+    VBoxMainHotplugWaiter(const char *pcszDevicesRoot);
+    /** Destructor. */
+    ~VBoxMainHotplugWaiter (void)
+    {
+        delete mImpl;
+    }
+    /**
+     * Wait for a hotplug event.
+     *
+     * @returns  VINF_SUCCESS if an event occurred or if Interrupt() was called.
+     * @returns  VERR_TRY_AGAIN if the wait failed but this might (!) be a
+     *           temporary failure.
+     * @returns  VERR_NOT_SUPPORTED if the wait failed and will definitely not
+     *           succeed if retried.
+     * @returns  Possibly other iprt status codes otherwise.
+     * @param    cMillies   How long to wait for at most.
+     */
+    int Wait (RTMSINTERVAL cMillies)
+    {
+        return mImpl->Wait(cMillies);
+    }
+    /**
+     * Interrupts an active wait.  In the current implementation, the wait
+     * may not return until up to two seconds after calling this method.
+     */
+    void Interrupt (void)
+    {
+        mImpl->Interrupt();
+    }
+
+    int getStatus(void)
+    {
+        return mImpl ? mImpl->getStatus() : VERR_NO_MEMORY;
+    }
+};
+
+#endif /* !MAIN_INCLUDED_HostHardwareLinux_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/HostImpl.h b/src/VBox/Main/include/HostImpl.h
new file mode 100644
index 00000000..a3fbbe8c
--- /dev/null
+++ b/src/VBox/Main/include/HostImpl.h
@@ -0,0 +1,227 @@
+/* $Id: HostImpl.h $ */
+/** @file
+ * Implementation of IHost.
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_HostImpl_h
+#define MAIN_INCLUDED_HostImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "HostWrap.h"
+
+class HostUSBDeviceFilter;
+class USBProxyService;
+class SessionMachine;
+class Progress;
+class PerformanceCollector;
+class HostDrive;
+class HostDrivePartition;
+
+namespace settings
+{
+    struct Host;
+}
+
+#include <list>
+
+class ATL_NO_VTABLE Host :
+    public HostWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(Host)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(VirtualBox *aParent);
+    void uninit();
+
+    // public methods only for internal purposes
+
+    /**
+     * Override of the default locking class to be used for validating lock
+     * order with the standard member lock handle.
+     */
+    virtual VBoxLockingClass getLockingClass() const
+    {
+        return LOCKCLASS_HOSTOBJECT;
+    }
+
+    HRESULT i_loadSettings(const settings::Host &data);
+    HRESULT i_saveSettings(settings::Host &data);
+
+    void    i_updateProcessorFeatures();
+
+    HRESULT i_getDrives(DeviceType_T mediumType, bool fRefresh, MediaList *&pll, AutoWriteLock &treeLock);
+    HRESULT i_findHostDriveById(DeviceType_T mediumType, const Guid &uuid, bool fRefresh, ComObjPtr<Medium> &pMedium);
+    HRESULT i_findHostDriveByName(DeviceType_T mediumType, const Utf8Str &strLocationFull, bool fRefresh, ComObjPtr<Medium> &pMedium);
+
+#ifdef VBOX_WITH_USB
+    typedef std::list< ComObjPtr<HostUSBDeviceFilter> > USBDeviceFilterList;
+
+    /** Must be called from under this object's lock. */
+    USBProxyService* i_usbProxyService();
+
+    HRESULT i_addChild(HostUSBDeviceFilter *pChild);
+    HRESULT i_removeChild(HostUSBDeviceFilter *pChild);
+    VirtualBox* i_parent();
+
+    HRESULT i_onUSBDeviceFilterChange(HostUSBDeviceFilter *aFilter, BOOL aActiveChanged = FALSE);
+    void i_getUSBFilters(USBDeviceFilterList *aGlobalFiltes);
+    HRESULT i_checkUSBProxyService();
+#endif /* !VBOX_WITH_USB */
+
+    static void i_generateMACAddress(Utf8Str &mac);
+
+#ifdef RT_OS_WINDOWS
+    HRESULT i_updatePersistentConfigForHostOnlyAdapters(void);
+    HRESULT i_removePersistentConfig(const Bstr &bstrGuid);
+#endif /* RT_OS_WINDOWS */
+
+
+private:
+
+    // wrapped IHost properties
+    HRESULT getDVDDrives(std::vector<ComPtr<IMedium> > &aDVDDrives);
+    HRESULT getFloppyDrives(std::vector<ComPtr<IMedium> > &aFloppyDrives);
+    HRESULT getAudioDevices(std::vector<ComPtr<IHostAudioDevice> > &aAudioDevices);
+    HRESULT getUSBDevices(std::vector<ComPtr<IHostUSBDevice> > &aUSBDevices);
+    HRESULT getUSBDeviceFilters(std::vector<ComPtr<IHostUSBDeviceFilter> > &aUSBDeviceFilters);
+    HRESULT getNetworkInterfaces(std::vector<ComPtr<IHostNetworkInterface> > &aNetworkInterfaces);
+    HRESULT getNameServers(std::vector<com::Utf8Str> &aNameServers);
+    HRESULT getDomainName(com::Utf8Str &aDomainName);
+    HRESULT getSearchStrings(std::vector<com::Utf8Str> &aSearchStrings);
+    HRESULT getProcessorCount(ULONG *aProcessorCount);
+    HRESULT getProcessorOnlineCount(ULONG *aProcessorOnlineCount);
+    HRESULT getProcessorCoreCount(ULONG *aProcessorCoreCount);
+    HRESULT getProcessorOnlineCoreCount(ULONG *aProcessorOnlineCoreCount);
+    HRESULT getHostDrives(std::vector<ComPtr<IHostDrive> > &aHostDrives);
+    HRESULT getMemorySize(ULONG *aMemorySize);
+    HRESULT getMemoryAvailable(ULONG *aMemoryAvailable);
+    HRESULT getOperatingSystem(com::Utf8Str &aOperatingSystem);
+    HRESULT getOSVersion(com::Utf8Str &aOSVersion);
+    HRESULT getUTCTime(LONG64 *aUTCTime);
+    HRESULT getAcceleration3DAvailable(BOOL *aAcceleration3DAvailable);
+    HRESULT getVideoInputDevices(std::vector<ComPtr<IHostVideoInputDevice> > &aVideoInputDevices);
+    HRESULT getUpdateHost(ComPtr<IUpdateAgent> &aUpdate);
+    HRESULT getUpdateExtPack(ComPtr<IUpdateAgent> &aUpdate);
+    HRESULT getUpdateGuestAdditions(ComPtr<IUpdateAgent> &aUpdate);
+    HRESULT getUpdateResponse(BOOL *aUpdateNeeded);
+    HRESULT getUpdateVersion(com::Utf8Str &aUpdateVersion);
+    HRESULT getUpdateURL(com::Utf8Str &aUpdateURL);
+    HRESULT getUpdateCheckNeeded(BOOL *aUpdateCheckNeeded);
+
+    // wrapped IHost methods
+    HRESULT getProcessorSpeed(ULONG aCpuId,
+                              ULONG *aSpeed);
+    HRESULT getProcessorFeature(ProcessorFeature_T aFeature,
+                                BOOL *aSupported);
+    HRESULT getProcessorDescription(ULONG aCpuId,
+                                    com::Utf8Str &aDescription);
+    HRESULT getProcessorCPUIDLeaf(ULONG aCpuId,
+                                  ULONG aLeaf,
+                                  ULONG aSubLeaf,
+                                  ULONG *aValEax,
+                                  ULONG *aValEbx,
+                                  ULONG *aValEcx,
+                                  ULONG *aValEdx);
+    HRESULT createHostOnlyNetworkInterface(ComPtr<IHostNetworkInterface> &aHostInterface,
+                                           ComPtr<IProgress> &aProgress);
+    HRESULT removeHostOnlyNetworkInterface(const com::Guid &aId,
+                                           ComPtr<IProgress> &aProgress);
+    HRESULT createUSBDeviceFilter(const com::Utf8Str &aName,
+                                  ComPtr<IHostUSBDeviceFilter> &aFilter);
+    HRESULT insertUSBDeviceFilter(ULONG aPosition,
+                                  const ComPtr<IHostUSBDeviceFilter> &aFilter);
+    HRESULT removeUSBDeviceFilter(ULONG aPosition);
+    HRESULT findHostDVDDrive(const com::Utf8Str &aName,
+                             ComPtr<IMedium> &aDrive);
+    HRESULT findHostFloppyDrive(const com::Utf8Str &aName,
+                                ComPtr<IMedium> &aDrive);
+    HRESULT findHostNetworkInterfaceByName(const com::Utf8Str &aName,
+                                           ComPtr<IHostNetworkInterface> &aNetworkInterface);
+    HRESULT findHostNetworkInterfaceById(const com::Guid &aId,
+                                         ComPtr<IHostNetworkInterface> &aNetworkInterface);
+    HRESULT findHostNetworkInterfacesOfType(HostNetworkInterfaceType_T aType,
+                                            std::vector<ComPtr<IHostNetworkInterface> > &aNetworkInterfaces);
+    HRESULT findUSBDeviceById(const com::Guid &aId,
+                              ComPtr<IHostUSBDevice> &aDevice);
+    HRESULT findUSBDeviceByAddress(const com::Utf8Str &aName,
+                                   ComPtr<IHostUSBDevice> &aDevice);
+    HRESULT generateMACAddress(com::Utf8Str &aAddress);
+
+    HRESULT addUSBDeviceSource(const com::Utf8Str &aBackend, const com::Utf8Str &aId, const com::Utf8Str &aAddress,
+                               const std::vector<com::Utf8Str> &aPropertyNames, const std::vector<com::Utf8Str> &aPropertyValues);
+
+    HRESULT removeUSBDeviceSource(const com::Utf8Str &aId);
+
+    // Internal Methods.
+
+    HRESULT i_buildDVDDrivesList(MediaList &list);
+    HRESULT i_buildFloppyDrivesList(MediaList &list);
+    HRESULT i_findHostDriveByNameOrId(DeviceType_T mediumType, const Utf8Str &strNameOrId, ComObjPtr<Medium> &pMedium);
+
+#if defined(RT_OS_SOLARIS) && defined(VBOX_USE_LIBHAL)
+    bool i_getDVDInfoFromHal(std::list< ComObjPtr<Medium> > &list);
+    bool i_getFloppyInfoFromHal(std::list< ComObjPtr<Medium> > &list);
+    HRESULT i_getFixedDrivesFromHal(std::list<std::pair<com::Utf8Str, com::Utf8Str> > &list) RT_NOEXCEPT;
+#endif
+
+#if defined(RT_OS_SOLARIS)
+    void i_getDVDInfoFromDevTree(std::list< ComObjPtr<Medium> > &list);
+    void i_parseMountTable(char *mountTable, std::list< ComObjPtr<Medium> > &list);
+    bool i_validateDevice(const char *deviceNode, bool isCDROM);
+    HRESULT i_getFixedDrivesFromDevTree(std::list<std::pair<com::Utf8Str, com::Utf8Str> > &list) RT_NOEXCEPT;
+#endif
+
+    HRESULT i_updateNetIfList();
+
+#ifndef RT_OS_WINDOWS
+    HRESULT i_parseResolvConf();
+#else
+    HRESULT i_fetchNameResolvingInformation();
+#endif
+
+#ifdef VBOX_WITH_RESOURCE_USAGE_API
+    void i_registerMetrics(PerformanceCollector *aCollector);
+    void i_registerDiskMetrics(PerformanceCollector *aCollector);
+    void i_unregisterMetrics(PerformanceCollector *aCollector);
+#endif /* VBOX_WITH_RESOURCE_USAGE_API */
+
+#ifdef RT_OS_WINDOWS
+    HRESULT i_getFixedDrivesFromGlobalNamespace(std::list<std::pair<com::Utf8Str, com::Utf8Str> > &aDriveList) RT_NOEXCEPT;
+#endif
+    HRESULT i_getDrivesPathsList(std::list<std::pair<com::Utf8Str, com::Utf8Str> > &aDriveList) RT_NOEXCEPT;
+
+    struct Data;        // opaque data structure, defined in HostImpl.cpp
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_HostImpl_h */
+
diff --git a/src/VBox/Main/include/HostNetworkInterfaceImpl.h b/src/VBox/Main/include/HostNetworkInterfaceImpl.h
new file mode 100644
index 00000000..c41aac87
--- /dev/null
+++ b/src/VBox/Main/include/HostNetworkInterfaceImpl.h
@@ -0,0 +1,145 @@
+/* $Id: HostNetworkInterfaceImpl.h $ */
+
+/** @file
+ *
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_HostNetworkInterfaceImpl_h
+#define MAIN_INCLUDED_HostNetworkInterfaceImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "HostNetworkInterfaceWrap.h"
+
+#ifdef VBOX_WITH_HOSTNETIF_API
+struct NETIFINFO;
+#endif
+
+class PerformanceCollector;
+
+class ATL_NO_VTABLE HostNetworkInterface :
+    public HostNetworkInterfaceWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(HostNetworkInterface)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Utf8Str aInterfaceName, Utf8Str aShortName, Guid aGuid, HostNetworkInterfaceType_T ifType);
+#ifdef VBOX_WITH_HOSTNETIF_API
+    HRESULT init(Utf8Str aInterfaceName, HostNetworkInterfaceType_T ifType, struct NETIFINFO *pIfs);
+    HRESULT updateConfig();
+#endif
+
+    HRESULT i_setVirtualBox(VirtualBox *pVirtualBox);
+#ifdef RT_OS_WINDOWS
+    HRESULT i_updatePersistentConfig();
+#endif /* RT_OS_WINDOWS */
+
+#ifdef VBOX_WITH_RESOURCE_USAGE_API
+    void i_registerMetrics(PerformanceCollector *aCollector, ComPtr<IUnknown> objptr);
+    void i_unregisterMetrics(PerformanceCollector *aCollector, ComPtr<IUnknown> objptr);
+#endif
+
+private:
+
+    // Wrapped IHostNetworkInterface properties
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT getShortName(com::Utf8Str &aShortName);
+    HRESULT getId(com::Guid &aGuiId);
+    HRESULT getDHCPEnabled(BOOL *aDHCPEnabled);
+    HRESULT getIPAddress(com::Utf8Str &aIPAddress);
+    HRESULT getNetworkMask(com::Utf8Str &aNetworkMask);
+    HRESULT getIPV6Supported(BOOL *aIPV6Supported);
+    HRESULT getIPV6Address(com::Utf8Str &aIPV6Address);
+    HRESULT getIPV6NetworkMaskPrefixLength(ULONG *aIPV6NetworkMaskPrefixLength);
+    HRESULT getHardwareAddress(com::Utf8Str &aHardwareAddress);
+    HRESULT getMediumType(HostNetworkInterfaceMediumType_T *aType);
+    HRESULT getStatus(HostNetworkInterfaceStatus_T *aStatus);
+    HRESULT getInterfaceType(HostNetworkInterfaceType_T *aType);
+    HRESULT getNetworkName(com::Utf8Str &aNetworkName);
+    HRESULT getWireless(BOOL *aWireless);
+
+    // Wrapped IHostNetworkInterface methods
+    HRESULT enableStaticIPConfig(const com::Utf8Str &aIPAddress,
+                                 const com::Utf8Str &aNetworkMask);
+    HRESULT enableStaticIPConfigV6(const com::Utf8Str &aIPV6Address,
+                                   ULONG aIPV6NetworkMaskPrefixLength);
+    HRESULT enableDynamicIPConfig();
+    HRESULT dHCPRediscover();
+
+    Utf8Str i_composeNetworkName(const Utf8Str szShortName);
+
+#if defined(RT_OS_WINDOWS)
+    HRESULT eraseAdapterConfigParameter(const char *szParamName);
+    HRESULT saveAdapterConfigParameter(const char *szParamName, const Utf8Str& strValue);
+    HRESULT saveAdapterConfigIPv4Dhcp();
+    HRESULT saveAdapterConfigIPv4(ULONG addr, ULONG mask);
+    HRESULT saveAdapterConfigIPv6(const Utf8Str& addr, ULONG prefix);
+    HRESULT saveAdapterConfig();
+    bool    isInConfigFile();
+#endif /* defined(RT_OS_WINDOWS) */
+
+    const Utf8Str mInterfaceName;
+    const Guid mGuid;
+    const Utf8Str mNetworkName;
+    const Utf8Str mShortName;
+    HostNetworkInterfaceType_T mIfType;
+
+    VirtualBox * const  mVirtualBox;
+
+    struct Data
+    {
+        Data() : IPAddress(0), networkMask(0), dhcpEnabled(FALSE),
+            mediumType(HostNetworkInterfaceMediumType_Unknown),
+            status(HostNetworkInterfaceStatus_Down), wireless(FALSE){}
+
+        ULONG IPAddress;
+        ULONG networkMask;
+        Utf8Str IPV6Address;
+        ULONG IPV6NetworkMaskPrefixLength;
+        ULONG realIPAddress;
+        ULONG realNetworkMask;
+        Utf8Str realIPV6Address;
+        ULONG realIPV6PrefixLength;
+        BOOL dhcpEnabled;
+        Utf8Str hardwareAddress;
+        HostNetworkInterfaceMediumType_T mediumType;
+        HostNetworkInterfaceStatus_T status;
+        ULONG speedMbits;
+        BOOL wireless;
+    } m;
+
+};
+
+typedef std::list<ComObjPtr<HostNetworkInterface> > HostNetworkInterfaceList;
+
+#endif /* !MAIN_INCLUDED_HostNetworkInterfaceImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/HostOnlyNetworkImpl.h b/src/VBox/Main/include/HostOnlyNetworkImpl.h
new file mode 100644
index 00000000..ec3b75e8
--- /dev/null
+++ b/src/VBox/Main/include/HostOnlyNetworkImpl.h
@@ -0,0 +1,80 @@
+/* $Id: HostOnlyNetworkImpl.h $ */
+/** @file
+ * IHostOnlyNetwork implementation header, lives in VBoxSVC.
+ */
+
+/*
+ * Copyright (C) 2021-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
+ */
+
+#ifndef MAIN_INCLUDED_HostOnlyNetworkImpl_h
+#define MAIN_INCLUDED_HostOnlyNetworkImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "HostOnlyNetworkWrap.h"
+
+namespace settings
+{
+    struct HostOnlyNetwork;
+}
+
+class ATL_NO_VTABLE HostOnlyNetwork :
+    public HostOnlyNetworkWrap
+{
+public:
+
+    DECLARE_EMPTY_CTOR_DTOR(HostOnlyNetwork)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    HRESULT init(VirtualBox *aVirtualBox, com::Utf8Str aName);
+    HRESULT i_loadSettings(const settings::HostOnlyNetwork &data);
+    void uninit();
+    HRESULT i_saveSettings(settings::HostOnlyNetwork &data);
+
+    // Internal methods
+    // Utf8Str i_getNetworkName();
+    // Utf8Str i_getNetworkId();
+private:
+
+    // Wrapped IHostOnlyNetwork properties
+    HRESULT getNetworkName(com::Utf8Str &aNetworkName);
+    HRESULT setNetworkName(const com::Utf8Str &aNetworkName);
+    HRESULT getNetworkMask(com::Utf8Str &aNetworkMask);
+    HRESULT setNetworkMask(const com::Utf8Str &aNetworkMask);
+    HRESULT getEnabled(BOOL *aEnabled);
+    HRESULT setEnabled(BOOL aEnabled);
+    HRESULT getHostIP(com::Utf8Str &aHostIP);
+    HRESULT getLowerIP(com::Utf8Str &aLowerIP);
+    HRESULT setLowerIP(const com::Utf8Str &aLowerIP);
+    HRESULT getUpperIP(com::Utf8Str &aUpperIP);
+    HRESULT setUpperIP(const com::Utf8Str &aUpperIP);
+    HRESULT getId(com::Guid &aId);
+    HRESULT setId(const com::Guid &aId);
+
+    struct Data;
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_HostOnlyNetworkImpl_h */
diff --git a/src/VBox/Main/include/HostPower.h b/src/VBox/Main/include/HostPower.h
new file mode 100644
index 00000000..4f0f92dc
--- /dev/null
+++ b/src/VBox/Main/include/HostPower.h
@@ -0,0 +1,136 @@
+/* $Id: HostPower.h $ */
+/** @file
+ *
+ * VirtualBox interface to host's power notification service
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_HostPower_h
+#define MAIN_INCLUDED_HostPower_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#ifdef RT_OS_DARWIN /* first, so we can undef pVM in iprt/cdefs.h */
+# include <IOKit/pwr_mgt/IOPMLib.h>
+# include <Carbon/Carbon.h>
+#endif
+
+#include "VirtualBoxBase.h"
+
+#include <vector>
+
+#ifdef RT_OS_LINUX
+# include <VBox/dbus.h>
+#endif
+
+class HostPowerService
+{
+  public:
+    HostPowerService(VirtualBox *aVirtualBox);
+    virtual ~HostPowerService();
+    void notify(Reason_T aReason);
+
+  protected:
+    VirtualBox *mVirtualBox;
+    std::vector<ComPtr<IInternalSessionControl> > mSessionControls;
+};
+
+# if defined(RT_OS_WINDOWS) || defined(DOXYGEN_RUNNING)
+/**
+ * The Windows hosted Power Service.
+ */
+class HostPowerServiceWin : public HostPowerService
+{
+public:
+
+    HostPowerServiceWin(VirtualBox *aVirtualBox);
+    virtual ~HostPowerServiceWin();
+
+private:
+
+    static DECLCALLBACK(int) NotificationThread(RTTHREAD ThreadSelf, void *pInstance);
+    static LRESULT CALLBACK  WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
+
+    HWND        mHwnd;
+    RTTHREAD    mThread;
+};
+# endif
+# if defined(RT_OS_LINUX) || defined(DOXYGEN_RUNNING)
+/**
+ * The Linux hosted Power Service.
+ */
+class HostPowerServiceLinux : public HostPowerService
+{
+public:
+
+    HostPowerServiceLinux(VirtualBox *aVirtualBox);
+    virtual ~HostPowerServiceLinux();
+
+private:
+
+    static DECLCALLBACK(int) powerChangeNotificationThread(RTTHREAD ThreadSelf, void *pInstance);
+
+    /* Private member vars */
+    /** Our message thread. */
+    RTTHREAD mThread;
+    /** Our (private) connection to the DBus.  Closing this will cause the
+     * message thread to exit. */
+    DBusConnection *mpConnection;
+};
+
+# endif
+# if defined(RT_OS_DARWIN) || defined(DOXYGEN_RUNNING)
+/**
+ * The Darwin hosted Power Service.
+ */
+class HostPowerServiceDarwin : public HostPowerService
+{
+public:
+
+    HostPowerServiceDarwin(VirtualBox *aVirtualBox);
+    virtual ~HostPowerServiceDarwin();
+
+private:
+
+    static DECLCALLBACK(int) powerChangeNotificationThread(RTTHREAD ThreadSelf, void *pInstance);
+    static void powerChangeNotificationHandler(void *pvData, io_service_t service, natural_t messageType, void *pMessageArgument);
+    static void lowPowerHandler(void *pvData);
+
+    void checkBatteryCriticalLevel(bool *pfCriticalChanged = NULL);
+
+    /* Private member vars */
+    RTTHREAD mThread; /* Our message thread. */
+
+    io_connect_t mRootPort; /* A reference to the Root Power Domain IOService */
+    IONotificationPortRef mNotifyPort; /* Notification port allocated by IORegisterForSystemPower */
+    io_object_t mNotifierObject; /* Notifier object, used to deregister later */
+    CFRunLoopRef mRunLoop; /* A reference to the local thread run loop */
+
+    bool mCritical; /* Indicate if the battery was in the critical state last checked */
+};
+# endif
+
+#endif /* !MAIN_INCLUDED_HostPower_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/HostUSBDeviceImpl.h b/src/VBox/Main/include/HostUSBDeviceImpl.h
new file mode 100644
index 00000000..a37851da
--- /dev/null
+++ b/src/VBox/Main/include/HostUSBDeviceImpl.h
@@ -0,0 +1,327 @@
+/* $Id: HostUSBDeviceImpl.h $ */
+/** @file
+ * VirtualBox IHostUSBDevice COM interface implementation.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_HostUSBDeviceImpl_h
+#define MAIN_INCLUDED_HostUSBDeviceImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "VirtualBoxBase.h"
+#include "USBDeviceFilterImpl.h"
+#include <VBox/usb.h>
+#include "HostUSBDeviceWrap.h"
+
+class SessionMachine;
+class USBProxyBackend;
+
+/**
+ * The unified state machine of HostUSBDevice.
+ *
+ * This is a super set of USBDEVICESTATE / USBDeviceState_T that
+ * includes additional states for tracking state transitions.
+ *
+ * @remarks
+ *  The CapturingForVM and CapturingForProxy states have been merged
+ *  into Capturing with a destination state (AttachingToVM or HeldByProxy).
+ *
+ *  The DetachingFromVM state is a merge of DetachingFromVMToProxy and
+ *  DetachingFromVMToHost and uses the destination state (HeldByProxy
+ *  or ReleasingToHost) like Capturing.
+ *
+ *  The *AwaitingDetach and *AwaitingReattach substates (optionally used
+ *  in Capturing, AttachingToVM, DetachingFromVM and ReleasingToHost) are
+ *  implemented via a substate kHostUSBDeviceSubState.
+ */
+typedef enum
+{
+    /** The device is unsupported (HUB).
+     * Next Host: PhysDetached.
+     * Next VBox: No change permitted.
+     */
+    kHostUSBDeviceState_Unsupported = USBDEVICESTATE_UNSUPPORTED,
+    /** The device is used exclusivly by the host or is inaccessible for some other reason.
+     * Next Host: Capturable, Unused, PhysDetached.
+     *            Run filters.
+     * Next VBox: No change permitted.
+     */
+    kHostUSBDeviceState_UsedByHost = USBDEVICESTATE_USED_BY_HOST,
+    /** The device is used by the host but can be captured.
+     * Next Host: Unsupported, UsedByHost, Unused, PhysDetached.
+     *            Run filters if Unused (for wildcard filters).
+     * Next VBox: CapturingForVM, CapturingForProxy.
+     */
+    kHostUSBDeviceState_Capturable = USBDEVICESTATE_USED_BY_HOST_CAPTURABLE,
+    /** The device is not used by the host and can be captured.
+     * Next Host: UsedByHost, Capturable, PhysDetached
+     *            Don't run any filters (done on state entry).
+     * Next VBox: CapturingForVM, CapturingForProxy.
+     */
+    kHostUSBDeviceState_Unused = USBDEVICESTATE_UNUSED,
+    /** The device is held captive by the proxy.
+     * Next Host: PhysDetached
+     * Next VBox: ReleasingHeld, AttachingToVM
+     */
+    kHostUSBDeviceState_HeldByProxy = USBDEVICESTATE_HELD_BY_PROXY,
+    /** The device is in use by a VM.
+     * Next Host: PhysDetachingFromVM
+     * Next VBox: DetachingFromVM
+     */
+    kHostUSBDeviceState_UsedByVM = USBDEVICESTATE_USED_BY_GUEST,
+    /** The device has been detach from both the host and VMs.
+     * This is the final state. */
+    kHostUSBDeviceState_PhysDetached = 9,
+
+
+    /** The start of the transitional states. */
+    kHostUSBDeviceState_FirstTransitional,
+
+    /** The device is being seized from the host, either for HeldByProxy or for AttachToVM.
+     *
+     * On some hosts we will need to re-enumerate the in which case the sub-state
+     * is employed to track this progress. On others, this is synchronous or faked, and
+     * will will then leave the device in this state and poke the service thread to do
+     * the completion state change.
+     *
+     * Next Host: PhysDetached.
+     * Next VBox: HeldByProxy or AttachingToVM on success,
+     *            previous state (Unused or Capturable) or UsedByHost on failure.
+     */
+    kHostUSBDeviceState_Capturing = kHostUSBDeviceState_FirstTransitional,
+
+    /** The device is being released back to the host, following VM or Proxy usage.
+     * Most hosts needs to re-enumerate the device and will therefore employ the
+     * sub-state as during capturing. On the others we'll just leave it to the usb
+     * service thread to advance the device state.
+     *
+     * Next Host: Unused, UsedByHost, Capturable.
+     *            No filters.
+     * Next VBox: PhysDetached (timeout), HeldByProxy (failure).
+     */
+    kHostUSBDeviceState_ReleasingToHost,
+
+    /** The device is being attached to a VM.
+     *
+     * This requires IPC to the VM and we will not advance the state until
+     * that completes.
+     *
+     * Next Host: PhysDetachingFromVM.
+     * Next VBox: UsedByGuest, HeldByProxy (failure).
+     */
+    kHostUSBDeviceState_AttachingToVM,
+
+    /** The device is being detached from a VM and will be returned to the proxy or host.
+     *
+     * This involves IPC and may or may not also require re-enumeration of the
+     * device. Which means that it might transition directly into the ReleasingToHost state
+     * because the client (VM) will do the actual re-enumeration.
+     *
+     * Next Host: PhysDetachingFromVM (?) or just PhysDetached.
+     * Next VBox: ReleasingToHost, HeldByProxy.
+     */
+    kHostUSBDeviceState_DetachingFromVM,
+
+    /** The device has been physically removed while a VM used it.
+     *
+     * This is the device state while VBoxSVC is doing IPC to the client (VM) telling it
+     * to detach it.
+     *
+     * Next Host: None.
+     * Next VBox: PhysDetached
+     */
+    kHostUSBDeviceState_PhysDetachingFromVM,
+
+    /** Just an invalid state value for use as default for some methods. */
+    kHostUSBDeviceState_Invalid = 0x7fff
+} HostUSBDeviceState;
+
+
+/**
+ * Sub-state for dealing with device re-enumeration.
+ */
+typedef enum
+{
+    /** Not in any sub-state. */
+    kHostUSBDeviceSubState_Default = 0,
+    /** Awaiting a logical device detach following a device re-enumeration. */
+    kHostUSBDeviceSubState_AwaitingDetach,
+    /** Awaiting a logical device re-attach following a device re-enumeration. */
+    kHostUSBDeviceSubState_AwaitingReAttach
+} HostUSBDeviceSubState;
+
+
+/**
+ * Object class used to hold Host USB Device properties.
+ */
+class ATL_NO_VTABLE HostUSBDevice :
+    public HostUSBDeviceWrap
+{
+public:
+    DECLARE_COMMON_CLASS_METHODS(HostUSBDevice)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(PUSBDEVICE aUsb, USBProxyBackend *aUSBProxyBackend);
+    void uninit();
+
+    // public methods only for internal purposes
+
+    /** @note Must be called from under the object read lock. */
+    const Guid& i_getId() const { return mId; }
+
+    /** @note Must be called from under the object read lock. */
+    HostUSBDeviceState i_getUnistate() const { return mUniState; }
+
+    /** @note Must be called from under the object read lock. */
+    const char *i_getStateName() { return i_stateName (mUniState, mPendingUniState, mUniSubState); }
+
+    /** @note Must be called from under the object read lock. */
+    bool i_isCapturableOrHeld()
+    {
+        return mUniState == kHostUSBDeviceState_Unused
+            || mUniState == kHostUSBDeviceState_Capturable
+            || mUniState == kHostUSBDeviceState_HeldByProxy;
+    }
+
+    /** @note Must be called from under the object read lock. */
+    ComObjPtr<SessionMachine> &i_getMachine() { return mMachine; }
+
+    /** @note Must be called from under the object read lock. */
+    PCUSBDEVICE i_getUsbData() const { return mUsb; }
+
+    USBProxyBackend *i_getUsbProxyBackend() const { return mUSBProxyBackend; }
+
+    com::Utf8Str i_getName();
+
+    HRESULT i_requestCaptureForVM(SessionMachine *aMachine, bool aSetError,
+                                  const com::Utf8Str &aCaptureFilename, ULONG aMaskedIfs = 0);
+    HRESULT i_onDetachFromVM(SessionMachine *aMachine, bool aDone, bool *aRunFilters, bool aAbnormal = false);
+    HRESULT i_requestReleaseToHost();
+    HRESULT i_requestHold();
+    bool i_wasActuallyDetached();
+    void i_onPhysicalDetached();
+
+    bool i_isMatch(const USBDeviceFilter::BackupableUSBDeviceFilterData &aData);
+    int i_compare(PCUSBDEVICE aDev2);
+    static int i_compare(PCUSBDEVICE aDev1, PCUSBDEVICE aDev2, bool aIsAwaitingReAttach = false);
+
+    bool i_updateState(PCUSBDEVICE aDev, bool *aRunFilters, SessionMachine **aIgnoreMachine);
+    bool i_updateStateFake(PCUSBDEVICE aDev, bool *aRunFilters, SessionMachine **aIgnoreMachine);
+
+    static const char *i_stateName(HostUSBDeviceState aState,
+                                   HostUSBDeviceState aPendingState = kHostUSBDeviceState_Invalid,
+                                   HostUSBDeviceSubState aSubState = kHostUSBDeviceSubState_Default);
+
+    void *i_getBackendUserData() { return m_pvBackendUser; }
+    void i_setBackendUserData(void *pvBackendUser) { m_pvBackendUser = pvBackendUser; }
+
+protected:
+
+    HRESULT i_attachToVM(SessionMachine *aMachine, const com::Utf8Str &aCaptureFilename, ULONG aMaskedIfs = 0);
+    void i_detachFromVM(HostUSBDeviceState aFinalState);
+    void i_onPhysicalDetachedInternal();
+    bool i_hasAsyncOperationTimedOut() const;
+
+    bool i_setState (HostUSBDeviceState aNewState, HostUSBDeviceState aNewPendingState = kHostUSBDeviceState_Invalid,
+                     HostUSBDeviceSubState aNewSubState = kHostUSBDeviceSubState_Default);
+    bool i_startTransition (HostUSBDeviceState aNewState, HostUSBDeviceState aFinalState,
+                            HostUSBDeviceSubState aNewSubState = kHostUSBDeviceSubState_Default);
+    bool i_advanceTransition(bool aSkipReAttach = false);
+    bool i_failTransition(HostUSBDeviceState a_enmStateHint);
+    USBDeviceState_T i_canonicalState() const;
+
+private:
+
+    // wrapped IUSBDevice properties
+    HRESULT getId(com::Guid &aId);
+    HRESULT getVendorId(USHORT *aVendorId);
+    HRESULT getProductId(USHORT *aProductId);
+    HRESULT getRevision(USHORT *aRevision);
+    HRESULT getManufacturer(com::Utf8Str &aManufacturer);
+    HRESULT getProduct(com::Utf8Str &aProduct);
+    HRESULT getSerialNumber(com::Utf8Str &aSerialNumber);
+    HRESULT getAddress(com::Utf8Str &aAddress);
+    HRESULT getPort(USHORT *aPort);
+    HRESULT getPortPath(com::Utf8Str &aPortPath);
+    HRESULT getVersion(USHORT *aVersion);
+    HRESULT getPortVersion(USHORT *aPortVersion);
+    HRESULT getSpeed(USBConnectionSpeed_T *aSpeed);
+    HRESULT getRemote(BOOL *aRemote);
+    HRESULT getState(USBDeviceState_T *aState);
+    HRESULT getBackend(com::Utf8Str &aBackend);
+    HRESULT getDeviceInfo(std::vector<com::Utf8Str> &aInfo);
+
+
+    const Guid mId;
+
+    /** @name The state machine variables
+     * Only setState(), init() and uninit() will modify these members!
+     * @{ */
+    /** The RTTimeNanoTS() corresponding to the last state change.
+     *
+     * Old state machine: RTTimeNanoTS() of when mIsStatePending was set or mDetaching changed
+     * from kNotDetaching. For operations that cannot be canceled it's 0. */
+    uint64_t mLastStateChangeTS;
+    /** Current state. */
+    HostUSBDeviceState mUniState;
+    /** Sub-state for tracking re-enumeration. */
+    HostUSBDeviceSubState mUniSubState;
+    /** The final state of an pending transition.
+     * This is mainly a measure to reduce the number of HostUSBDeviceState values. */
+    HostUSBDeviceState mPendingUniState;
+    /** Previous state.
+     * This is used for bailing out when a transition like capture fails. */
+    HostUSBDeviceState mPrevUniState;
+    /** Indicator set by onDetachedPhys and check when advancing a transitional state. */
+    bool mIsPhysicallyDetached;
+    /** @} */
+
+    /** The machine the usb device is (being) attached to. */
+    ComObjPtr<SessionMachine> mMachine;
+    /** Pointer to the USB Proxy Backend instance. */
+    USBProxyBackend *mUSBProxyBackend;
+    /** Pointer to the USB Device structure owned by this device.
+     * Only used for host devices. */
+    PUSBDEVICE mUsb;
+    /** The interface mask to be used in the pending capture.
+     * This is a filter property. */
+    ULONG mMaskedIfs;
+    /** The name of this device. */
+    Utf8Str mNameObj;
+    /** The name of this device (for logging purposes).
+     * This points to the string in mNameObj. */
+    const char *mName;
+    /** The filename to capture the USB traffic to. */
+    com::Utf8Str mCaptureFilename;
+    /** Optional opaque user data assigned by the USB proxy backend owning the device. */
+    void        *m_pvBackendUser;
+};
+
+#endif /* !MAIN_INCLUDED_HostUSBDeviceImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/HostVideoInputDeviceImpl.h b/src/VBox/Main/include/HostVideoInputDeviceImpl.h
new file mode 100644
index 00000000..9a61a0bd
--- /dev/null
+++ b/src/VBox/Main/include/HostVideoInputDeviceImpl.h
@@ -0,0 +1,82 @@
+/* $Id: HostVideoInputDeviceImpl.h $ */
+/** @file
+ * A host video capture device description.
+ */
+
+/*
+ * Copyright (C) 2013-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
+ */
+
+#ifndef MAIN_INCLUDED_HostVideoInputDeviceImpl_h
+#define MAIN_INCLUDED_HostVideoInputDeviceImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "HostVideoInputDeviceWrap.h"
+
+#include <list>
+
+class HostVideoInputDevice;
+
+typedef std::list<ComObjPtr<HostVideoInputDevice> > HostVideoInputDeviceList;
+
+class ATL_NO_VTABLE HostVideoInputDevice :
+    public HostVideoInputDeviceWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(HostVideoInputDevice)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    /* Public initializer/uninitializer for internal purposes only. */
+    HRESULT init(const com::Utf8Str &name, const com::Utf8Str &path, const com::Utf8Str &alias);
+    void uninit();
+
+    static HRESULT queryHostDevices(VirtualBox *pVirtualBox, HostVideoInputDeviceList *pList);
+
+private:
+
+    // wrapped IHostVideoInputDevice properties
+    virtual HRESULT getName(com::Utf8Str &aName) { aName = m.name; return S_OK; }
+    virtual HRESULT getPath(com::Utf8Str &aPath) { aPath = m.path; return S_OK; }
+    virtual HRESULT getAlias(com::Utf8Str &aAlias) { aAlias = m.alias; return S_OK; }
+
+    /* Data. */
+    struct Data
+    {
+        Data()
+        {
+        }
+
+        com::Utf8Str name;
+        com::Utf8Str path;
+        com::Utf8Str alias;
+    };
+
+    Data m;
+};
+
+#endif /* !MAIN_INCLUDED_HostVideoInputDeviceImpl_h */
+
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/KeyboardImpl.h b/src/VBox/Main/include/KeyboardImpl.h
new file mode 100644
index 00000000..d8130a7d
--- /dev/null
+++ b/src/VBox/Main/include/KeyboardImpl.h
@@ -0,0 +1,110 @@
+/* $Id: KeyboardImpl.h $ */
+/** @file
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_KeyboardImpl_h
+#define MAIN_INCLUDED_KeyboardImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "KeyboardWrap.h"
+#include "EventImpl.h"
+
+#include <VBox/vmm/pdmdrv.h>
+
+/** Limit of simultaneously attached devices (just USB and/or PS/2). */
+enum { KEYBOARD_MAX_DEVICES = 2 };
+
+/** Simple keyboard event class. */
+class KeyboardEvent
+{
+public:
+    KeyboardEvent() : scan(-1) {}
+    KeyboardEvent(int _scan) : scan(_scan) {}
+    bool i_isValid()
+    {
+        return (scan & ~0x80) && !(scan & ~0xFF);
+    }
+    int scan;
+};
+class Console;
+
+class ATL_NO_VTABLE Keyboard :
+    public KeyboardWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(Keyboard)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Console *aParent);
+    void uninit();
+
+    static const PDMDRVREG  DrvReg;
+
+    Console *i_getParent() const
+    {
+        return mParent;
+    }
+
+private:
+
+    // Wrapped Keyboard properties
+    HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
+    HRESULT getKeyboardLEDs(std::vector<KeyboardLED_T> &aKeyboardLEDs);
+
+    // Wrapped Keyboard members
+    HRESULT putScancode(LONG aScancode);
+    HRESULT putScancodes(const std::vector<LONG> &aScancodes,
+                         ULONG *aCodesStored);
+    HRESULT putCAD();
+    HRESULT releaseKeys();
+    HRESULT putUsageCode(LONG aUsageCode, LONG aUsagePage, BOOL fKeyRelease);
+
+    static DECLCALLBACK(void)   i_keyboardLedStatusChange(PPDMIKEYBOARDCONNECTOR pInterface, PDMKEYBLEDS enmLeds);
+    static DECLCALLBACK(void)   i_keyboardSetActive(PPDMIKEYBOARDCONNECTOR pInterface, bool fActive);
+    static DECLCALLBACK(void *) i_drvQueryInterface(PPDMIBASE pInterface, const char *pszIID);
+    static DECLCALLBACK(int)    i_drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
+    static DECLCALLBACK(void)   i_drvDestruct(PPDMDRVINS pDrvIns);
+
+    void onKeyboardLedsChange(PDMKEYBLEDS enmLeds);
+
+    Console * const         mParent;
+    /** Pointer to the associated keyboard driver(s). */
+    struct DRVMAINKEYBOARD *mpDrv[KEYBOARD_MAX_DEVICES];
+
+    /* The current guest keyboard LED status. */
+    PDMKEYBLEDS menmLeds;
+
+    const ComObjPtr<EventSource> mEventSource;
+};
+
+#endif /* !MAIN_INCLUDED_KeyboardImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/LoggingNew.h b/src/VBox/Main/include/LoggingNew.h
new file mode 100644
index 00000000..c368e1a2
--- /dev/null
+++ b/src/VBox/Main/include/LoggingNew.h
@@ -0,0 +1,60 @@
+/* $Id: LoggingNew.h $ */
+/** @file
+ * VirtualBox COM - logging macros and function definitions, for new code.
+ */
+
+/*
+ * Copyright (C) 2017-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
+ */
+
+#ifndef MAIN_INCLUDED_LoggingNew_h
+#define MAIN_INCLUDED_LoggingNew_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#ifdef MAIN_INCLUDED_Logging_h
+# error "You must include LoggingNew.h as the first include!"
+#endif
+#define MAIN_INCLUDED_Logging_h /* Prevent Logging.h from being included. */
+
+#ifndef LOG_GROUP
+# error "You must define LOG_GROUP immediately before including LoggingNew.h!"
+#endif
+
+#ifdef LOG_GROUP_MAIN_OVERRIDE
+# error "Please, don't define LOG_GROUP_MAIN_OVERRIDE anymore!"
+#endif
+
+#include <VBox/log.h>
+
+
+#ifndef VBOXSVC_LOG_DEFAULT
+# define VBOXSVC_LOG_DEFAULT "all"
+#endif
+
+#ifndef VBOXSDS_LOG_DEFAULT
+# define VBOXSDS_LOG_DEFAULT "all"
+#endif
+
+#endif /* !MAIN_INCLUDED_LoggingNew_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
+
diff --git a/src/VBox/Main/include/MachineDebuggerImpl.h b/src/VBox/Main/include/MachineDebuggerImpl.h
new file mode 100644
index 00000000..68ca8740
--- /dev/null
+++ b/src/VBox/Main/include/MachineDebuggerImpl.h
@@ -0,0 +1,176 @@
+/* $Id: MachineDebuggerImpl.h $ */
+/** @file
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_MachineDebuggerImpl_h
+#define MAIN_INCLUDED_MachineDebuggerImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "MachineDebuggerWrap.h"
+#include <iprt/log.h>
+#include <VBox/vmm/em.h>
+
+class Console;
+class Progress;
+
+class ATL_NO_VTABLE MachineDebugger :
+    public MachineDebuggerWrap
+{
+
+public:
+
+    DECLARE_COMMON_CLASS_METHODS (MachineDebugger)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init (Console *aParent);
+    void uninit();
+
+    // "public-private methods"
+    void i_flushQueuedSettings();
+
+private:
+
+    // wrapped IMachineDeugger properties
+    HRESULT getSingleStep(BOOL *aSingleStep);
+    HRESULT setSingleStep(BOOL aSingleStep);
+    HRESULT getExecuteAllInIEM(BOOL *aExecuteAllInIEM);
+    HRESULT setExecuteAllInIEM(BOOL aExecuteAllInIEM);
+    HRESULT getLogEnabled(BOOL *aLogEnabled);
+    HRESULT setLogEnabled(BOOL aLogEnabled);
+    HRESULT getLogDbgFlags(com::Utf8Str &aLogDbgFlags);
+    HRESULT getLogDbgGroups(com::Utf8Str &aLogDbgGroups);
+    HRESULT getLogDbgDestinations(com::Utf8Str &aLogDbgDestinations);
+    HRESULT getLogRelFlags(com::Utf8Str &aLogRelFlags);
+    HRESULT getLogRelGroups(com::Utf8Str &aLogRelGroups);
+    HRESULT getLogRelDestinations(com::Utf8Str &aLogRelDestinations);
+    HRESULT getExecutionEngine(VMExecutionEngine_T *apenmEngine);
+    HRESULT getHWVirtExNestedPagingEnabled(BOOL *aHWVirtExNestedPagingEnabled);
+    HRESULT getHWVirtExVPIDEnabled(BOOL *aHWVirtExVPIDEnabled);
+    HRESULT getHWVirtExUXEnabled(BOOL *aHWVirtExUXEnabled);
+    HRESULT getOSName(com::Utf8Str &aOSName);
+    HRESULT getOSVersion(com::Utf8Str &aOSVersion);
+    HRESULT getPAEEnabled(BOOL *aPAEEnabled);
+    HRESULT getVirtualTimeRate(ULONG *aVirtualTimeRate);
+    HRESULT setVirtualTimeRate(ULONG aVirtualTimeRate);
+    HRESULT getUptime(LONG64 *aUptime);
+
+    // wrapped IMachineDeugger methods
+    HRESULT dumpGuestCore(const com::Utf8Str &aFilename,
+                          const com::Utf8Str &aCompression);
+    HRESULT dumpHostProcessCore(const com::Utf8Str &aFilename,
+                                const com::Utf8Str &aCompression);
+    HRESULT info(const com::Utf8Str &aName,
+                 const com::Utf8Str &aArgs,
+                 com::Utf8Str &aInfo);
+    HRESULT injectNMI();
+    HRESULT modifyLogGroups(const com::Utf8Str &aSettings);
+    HRESULT modifyLogFlags(const com::Utf8Str &aSettings);
+    HRESULT modifyLogDestinations(const com::Utf8Str &aSettings);
+    HRESULT readPhysicalMemory(LONG64 aAddress,
+                               ULONG aSize,
+                               std::vector<BYTE> &aBytes);
+    HRESULT writePhysicalMemory(LONG64 aAddress,
+                                ULONG aSize,
+                                const std::vector<BYTE> &aBytes);
+    HRESULT readVirtualMemory(ULONG aCpuId,
+                              LONG64 aAddress,
+                              ULONG aSize,
+                              std::vector<BYTE> &aBytes);
+    HRESULT writeVirtualMemory(ULONG aCpuId,
+                               LONG64 aAddress,
+                               ULONG aSize,
+                               const std::vector<BYTE> &aBytes);
+    HRESULT loadPlugIn(const com::Utf8Str &aName,
+                       com::Utf8Str &aPlugInName);
+    HRESULT unloadPlugIn(const com::Utf8Str &aName);
+    HRESULT detectOS(com::Utf8Str &aOs);
+    HRESULT queryOSKernelLog(ULONG aMaxMessages,
+                             com::Utf8Str &aDmesg);
+    HRESULT getRegister(ULONG aCpuId,
+                        const com::Utf8Str &aName,
+                        com::Utf8Str &aValue);
+    HRESULT getRegisters(ULONG aCpuId,
+                         std::vector<com::Utf8Str> &aNames,
+                         std::vector<com::Utf8Str> &aValues);
+    HRESULT setRegister(ULONG aCpuId,
+                        const com::Utf8Str &aName,
+                        const com::Utf8Str &aValue);
+    HRESULT setRegisters(ULONG aCpuId,
+                         const std::vector<com::Utf8Str> &aNames,
+                         const std::vector<com::Utf8Str> &aValues);
+    HRESULT dumpGuestStack(ULONG aCpuId,
+                           com::Utf8Str &aStack);
+    HRESULT resetStats(const com::Utf8Str &aPattern);
+    HRESULT dumpStats(const com::Utf8Str &aPattern);
+    HRESULT getStats(const com::Utf8Str &aPattern,
+                     BOOL aWithDescriptions,
+                     com::Utf8Str &aStats);
+    HRESULT getCPULoad(ULONG aCpuId, ULONG *aPctExecuting, ULONG *aPctHalted, ULONG *aPctOther, LONG64 *aMsInterval) RT_OVERRIDE;
+    HRESULT takeGuestSample(const com::Utf8Str &aFilename, ULONG aUsInterval, LONG64 aUsSampleTime, ComPtr<IProgress> &pProgress);
+    HRESULT getUVMAndVMMFunctionTable(LONG64 aMagicVersion, LONG64 *aVMMFunctionTable, LONG64 *aUVM);
+
+    // private methods
+    bool i_queueSettings() const;
+    HRESULT i_getEmExecPolicyProperty(EMEXECPOLICY enmPolicy, BOOL *pfEnforced);
+    HRESULT i_setEmExecPolicyProperty(EMEXECPOLICY enmPolicy, BOOL fEnforce);
+
+    /** RTLogGetFlags, RTLogGetGroupSettings and RTLogGetDestinations function. */
+    typedef DECLCALLBACKTYPE(int, FNLOGGETSTR,(PRTLOGGER, char *, size_t));
+    /** Function pointer.  */
+    typedef FNLOGGETSTR *PFNLOGGETSTR;
+    HRESULT i_logStringProps(PRTLOGGER pLogger, PFNLOGGETSTR pfnLogGetStr, const char *pszLogGetStr, Utf8Str *pstrSettings);
+
+    static DECLCALLBACK(int) i_dbgfProgressCallback(void *pvUser, unsigned uPercentage);
+
+    Console * const mParent;
+    /** @name Flags whether settings have been queued because they could not be sent
+     *        to the VM (not up yet, etc.)
+     * @{ */
+    uint8_t maiQueuedEmExecPolicyParams[EMEXECPOLICY_END];
+    int mSingleStepQueued;
+    int mLogEnabledQueued;
+    uint32_t mVirtualTimeRateQueued;
+    bool mFlushMode;
+    /** @}  */
+
+    /** @name Sample report related things.
+     * @{ */
+    /** Sample report handle. */
+    DBGFSAMPLEREPORT        m_hSampleReport;
+    /** Progress object for the currently taken guest sample. */
+    ComObjPtr<Progress>     m_Progress;
+    /** Filename to dump the report to. */
+    com::Utf8Str            m_strFilename;
+    /** @} */
+};
+
+#endif /* !MAIN_INCLUDED_MachineDebuggerImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/MachineImpl.h b/src/VBox/Main/include/MachineImpl.h
new file mode 100644
index 00000000..311a80bd
--- /dev/null
+++ b/src/VBox/Main/include/MachineImpl.h
@@ -0,0 +1,1691 @@
+/* $Id: MachineImpl.h $ */
+/** @file
+ * Implementation of IMachine in VBoxSVC - Header.
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_MachineImpl_h
+#define MAIN_INCLUDED_MachineImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "AuthLibrary.h"
+#include "VirtualBoxBase.h"
+#include "ProgressImpl.h"
+#include "VRDEServerImpl.h"
+#include "MediumAttachmentImpl.h"
+#include "PCIDeviceAttachmentImpl.h"
+#include "MediumLock.h"
+#include "NetworkAdapterImpl.h"
+#include "AudioSettingsImpl.h"
+#include "SerialPortImpl.h"
+#include "ParallelPortImpl.h"
+#include "BIOSSettingsImpl.h"
+#include "RecordingSettingsImpl.h"
+#include "GraphicsAdapterImpl.h"
+#include "StorageControllerImpl.h"          // required for MachineImpl.h to compile on Windows
+#include "USBControllerImpl.h"              // required for MachineImpl.h to compile on Windows
+#include "BandwidthControlImpl.h"
+#include "BandwidthGroupImpl.h"
+#include "TrustedPlatformModuleImpl.h"
+#include "NvramStoreImpl.h"
+#include "GuestDebugControlImpl.h"
+#ifdef VBOX_WITH_RESOURCE_USAGE_API
+# include "Performance.h"
+# include "PerformanceImpl.h"
+#endif
+#include "ThreadTask.h"
+
+// generated header
+#include "SchemaDefs.h"
+
+#include "VBox/com/ErrorInfo.h"
+
+#include <iprt/time.h>
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+# include <VBox/VBoxCryptoIf.h>
+# include <iprt/vfs.h>
+#endif
+
+#include <list>
+#include <vector>
+
+#include "MachineWrap.h"
+
+/** @todo r=klaus after moving the various Machine settings structs to
+ * MachineImpl.cpp it should be possible to eliminate this include. */
+#include <VBox/settings.h>
+
+// defines
+////////////////////////////////////////////////////////////////////////////////
+
+// helper declarations
+////////////////////////////////////////////////////////////////////////////////
+
+class Progress;
+class ProgressProxy;
+class Keyboard;
+class Mouse;
+class Display;
+class MachineDebugger;
+class USBController;
+class USBDeviceFilters;
+class Snapshot;
+class SharedFolder;
+class HostUSBDevice;
+class StorageController;
+class SessionMachine;
+#ifdef VBOX_WITH_UNATTENDED
+class Unattended;
+#endif
+
+// Machine class
+////////////////////////////////////////////////////////////////////////////////
+//
+class ATL_NO_VTABLE Machine :
+    public MachineWrap
+{
+
+public:
+
+    enum StateDependency
+    {
+        AnyStateDep = 0,
+        MutableStateDep,
+        MutableOrSavedStateDep,
+        MutableOrRunningStateDep,
+        MutableOrSavedOrRunningStateDep,
+    };
+
+    /**
+     * Internal machine data.
+     *
+     * Only one instance of this data exists per every machine -- it is shared
+     * by the Machine, SessionMachine and all SnapshotMachine instances
+     * associated with the given machine using the util::Shareable template
+     * through the mData variable.
+     *
+     * @note |const| members are persistent during lifetime so can be
+     * accessed without locking.
+     *
+     * @note There is no need to lock anything inside init() or uninit()
+     * methods, because they are always serialized (see AutoCaller).
+     */
+    struct Data
+    {
+        /**
+         * Data structure to hold information about sessions opened for the
+         * given machine.
+         */
+        struct Session
+        {
+            /** Type of lock which created this session */
+            LockType_T mLockType;
+
+            /** Control of the direct session opened by lockMachine() */
+            ComPtr<IInternalSessionControl> mDirectControl;
+
+            typedef std::list<ComPtr<IInternalSessionControl> > RemoteControlList;
+
+            /** list of controls of all opened remote sessions */
+            RemoteControlList mRemoteControls;
+
+            /** launchVMProcess() and OnSessionEnd() progress indicator */
+            ComObjPtr<ProgressProxy> mProgress;
+
+            /**
+             * PID of the session object that must be passed to openSession()
+             * to finalize the launchVMProcess() request (i.e., PID of the
+             * process created by launchVMProcess())
+             */
+            RTPROCESS mPID;
+
+            /** Current session state */
+            SessionState_T mState;
+
+            /** Session name string (of the primary session) */
+            Utf8Str mName;
+
+            /** Session machine object */
+            ComObjPtr<SessionMachine> mMachine;
+
+            /** Medium object lock collection. */
+            MediumLockListMap mLockedMedia;
+        };
+
+        Data();
+        ~Data();
+
+        const Guid          mUuid;
+        BOOL                mRegistered;
+
+        Utf8Str             m_strConfigFile;
+        Utf8Str             m_strConfigFileFull;
+
+        // machine settings XML file
+        settings::MachineConfigFile *pMachineConfigFile;
+        uint32_t            flModifications;
+        bool                m_fAllowStateModification;
+
+        BOOL                mAccessible;
+        com::ErrorInfo      mAccessError;
+
+        MachineState_T      mMachineState;
+        RTTIMESPEC          mLastStateChange;
+
+        /* Note: These are guarded by VirtualBoxBase::stateLockHandle() */
+        uint32_t            mMachineStateDeps;
+        RTSEMEVENTMULTI     mMachineStateDepsSem;
+        uint32_t            mMachineStateChangePending;
+
+        BOOL                mCurrentStateModified;
+        /** Guest properties have been modified and need saving since the
+         * machine was started, or there are transient properties which need
+         * deleting and the machine is being shut down. */
+        BOOL                mGuestPropertiesModified;
+
+        Session             mSession;
+
+        ComObjPtr<Snapshot> mFirstSnapshot;
+        ComObjPtr<Snapshot> mCurrentSnapshot;
+
+        // list of files to delete in Delete(); this list is filled by Unregister()
+        std::list<Utf8Str>  llFilesToDelete;
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+        /* Store for secret keys. */
+        SecretKeyStore      *mpKeyStore;
+        BOOL                fEncrypted;
+        /* KeyId of the password encrypting the DEK */
+        com::Utf8Str        mstrKeyId;
+        /* Store containing the DEK used for encrypting the VM */
+        com::Utf8Str        mstrKeyStore;
+        /* KeyId of the password encrypting the DEK for log files */
+        com::Utf8Str        mstrLogKeyId;
+        /* Store containing the DEK used for encrypting the VM's log files */
+        com::Utf8Str        mstrLogKeyStore;
+#endif
+    };
+
+    /**
+     *  Saved state data.
+     *
+     *  It's actually only the state file path string and its encryption
+     *  settings, but it needs to be separate from Data, because Machine
+     *  and SessionMachine instances share it, while SnapshotMachine does
+     *  not.
+     *
+     *  The data variable is |mSSData|.
+     */
+    struct SSData
+    {
+        Utf8Str strStateFilePath;
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+        /* KeyId of the password encrypting the DEK for saved state */
+        com::Utf8Str        strStateKeyId;
+        /* Store containing the DEK used for encrypting saved state */
+        com::Utf8Str        strStateKeyStore;
+#endif
+    };
+
+    /**
+     *  User changeable machine data.
+     *
+     *  This data is common for all machine snapshots, i.e. it is shared
+     *  by all SnapshotMachine instances associated with the given machine
+     *  using the util::Backupable template through the |mUserData| variable.
+     *
+     *  SessionMachine instances can alter this data and discard changes.
+     *
+     *  @note There is no need to lock anything inside init() or uninit()
+     *  methods, because they are always serialized (see AutoCaller).
+     */
+    struct UserData
+    {
+        settings::MachineUserData s;
+    };
+
+    /**
+     *  Hardware data.
+     *
+     *  This data is unique for a machine and for every machine snapshot.
+     *  Stored using the util::Backupable template in the |mHWData| variable.
+     *
+     *  SessionMachine instances can alter this data and discard changes.
+     *
+     *  @todo r=klaus move all "pointer" objects out of this struct, as they
+     *  need non-obvious handling when creating a new session or when taking
+     *  a snapshot. Better do this right straight away, not relying on the
+     *  template magic which doesn't work right in this case.
+     */
+    struct HWData
+    {
+        /**
+         * Data structure to hold information about a guest property.
+         */
+        struct GuestProperty {
+            /** Property value */
+            Utf8Str strValue;
+            /** Property timestamp */
+            LONG64 mTimestamp;
+            /** Property flags */
+            ULONG mFlags;
+        };
+
+        HWData();
+        ~HWData();
+
+        Bstr                mHWVersion;
+        Guid                mHardwareUUID;  /**< If Null, use mData.mUuid. */
+        ULONG               mMemorySize;
+        ULONG               mMemoryBalloonSize;
+        BOOL                mPageFusionEnabled;
+        settings::RecordingSettings mRecordSettings;
+        BOOL                mHWVirtExEnabled;
+        BOOL                mHWVirtExNestedPagingEnabled;
+        BOOL                mHWVirtExLargePagesEnabled;
+        BOOL                mHWVirtExVPIDEnabled;
+        BOOL                mHWVirtExUXEnabled;
+        BOOL                mHWVirtExForceEnabled;
+        BOOL                mHWVirtExUseNativeApi;
+        BOOL                mHWVirtExVirtVmsaveVmload;
+        BOOL                mPAEEnabled;
+        settings::Hardware::LongModeType mLongMode;
+        BOOL                mTripleFaultReset;
+        BOOL                mAPIC;
+        BOOL                mX2APIC;
+        BOOL                mIBPBOnVMExit;
+        BOOL                mIBPBOnVMEntry;
+        BOOL                mSpecCtrl;
+        BOOL                mSpecCtrlByHost;
+        BOOL                mL1DFlushOnSched;
+        BOOL                mL1DFlushOnVMEntry;
+        BOOL                mMDSClearOnSched;
+        BOOL                mMDSClearOnVMEntry;
+        BOOL                mNestedHWVirt;
+        ULONG               mCPUCount;
+        BOOL                mCPUHotPlugEnabled;
+        ULONG               mCpuExecutionCap;
+        uint32_t            mCpuIdPortabilityLevel;
+        Utf8Str             mCpuProfile;
+        BOOL                mHPETEnabled;
+
+        BOOL                mCPUAttached[SchemaDefs::MaxCPUCount];
+
+        std::list<settings::CpuIdLeaf> mCpuIdLeafList;
+
+        DeviceType_T        mBootOrder[SchemaDefs::MaxBootPosition];
+
+        typedef std::list<ComObjPtr<SharedFolder> > SharedFolderList;
+        SharedFolderList    mSharedFolders;
+
+        ClipboardMode_T     mClipboardMode;
+        BOOL                mClipboardFileTransfersEnabled;
+
+        DnDMode_T           mDnDMode;
+
+        typedef std::map<Utf8Str, GuestProperty> GuestPropertyMap;
+        GuestPropertyMap    mGuestProperties;
+
+        FirmwareType_T      mFirmwareType;
+        KeyboardHIDType_T   mKeyboardHIDType;
+        PointingHIDType_T   mPointingHIDType;
+        ChipsetType_T       mChipsetType;
+        IommuType_T         mIommuType;
+        ParavirtProvider_T  mParavirtProvider;
+        Utf8Str             mParavirtDebug;
+        BOOL                mEmulatedUSBCardReaderEnabled;
+
+        BOOL                mIOCacheEnabled;
+        ULONG               mIOCacheSize;
+
+        typedef std::list<ComObjPtr<PCIDeviceAttachment> > PCIDeviceAssignmentList;
+        PCIDeviceAssignmentList mPCIDeviceAssignments;
+
+        settings::Debugging mDebugging;
+        settings::Autostart mAutostart;
+
+        Utf8Str             mDefaultFrontend;
+    };
+
+    typedef std::list<ComObjPtr<MediumAttachment> > MediumAttachmentList;
+
+    DECLARE_COMMON_CLASS_METHODS(Machine)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only:
+
+    // initializer for creating a new, empty machine
+    HRESULT init(VirtualBox *aParent,
+                 const Utf8Str &strConfigFile,
+                 const Utf8Str &strName,
+                 const StringsList &llGroups,
+                 const Utf8Str &strOsTypeId,
+                 GuestOSType *aOsType,
+                 const Guid &aId,
+                 bool fForceOverwrite,
+                 bool fDirectoryIncludesUUID,
+                 const com::Utf8Str &aCipher,
+                 const com::Utf8Str &aPasswordId,
+                 const com::Utf8Str &aPassword);
+
+    // initializer for loading existing machine XML (either registered or not)
+    HRESULT initFromSettings(VirtualBox *aParent,
+                             const Utf8Str &strConfigFile,
+                             const Guid *aId,
+                             const com::Utf8Str &strPassword);
+
+    // initializer for machine config in memory (OVF import)
+    HRESULT init(VirtualBox *aParent,
+                 const Utf8Str &strName,
+                 const Utf8Str &strSettingsFilename,
+                 const settings::MachineConfigFile &config);
+
+    void uninit();
+
+#ifdef VBOX_WITH_RESOURCE_USAGE_API
+    // Needed from VirtualBox, for the delayed metrics cleanup.
+    void i_unregisterMetrics(PerformanceCollector *aCollector, Machine *aMachine);
+#endif /* VBOX_WITH_RESOURCE_USAGE_API */
+
+protected:
+    HRESULT initImpl(VirtualBox *aParent,
+                     const Utf8Str &strConfigFile);
+    HRESULT initDataAndChildObjects();
+    HRESULT i_registeredInit();
+    HRESULT i_tryCreateMachineConfigFile(bool fForceOverwrite);
+    void uninitDataAndChildObjects();
+
+public:
+
+
+    // public methods only for internal purposes
+
+    virtual bool i_isSnapshotMachine() const
+    {
+        return false;
+    }
+
+    virtual bool i_isSessionMachine() const
+    {
+        return false;
+    }
+
+    /**
+     * Override of the default locking class to be used for validating lock
+     * order with the standard member lock handle.
+     */
+    virtual VBoxLockingClass getLockingClass() const
+    {
+        return LOCKCLASS_MACHINEOBJECT;
+    }
+
+    /// @todo (dmik) add lock and make non-inlined after revising classes
+    //  that use it. Note: they should enter Machine lock to keep the returned
+    //  information valid!
+    bool i_isRegistered() { return !!mData->mRegistered; }
+
+    // unsafe inline public methods for internal purposes only (ensure there is
+    // a caller and a read lock before calling them!)
+
+    /**
+     * Returns the VirtualBox object this machine belongs to.
+     *
+     * @note This method doesn't check this object's readiness. Intended to be
+     * used by ready Machine children (whose readiness is bound to the parent's
+     * one) or after doing addCaller() manually.
+     */
+    VirtualBox* i_getVirtualBox() const { return mParent; }
+
+    /**
+     * Checks if this machine is accessible, without attempting to load the
+     * config file.
+     *
+     * @note This method doesn't check this object's readiness. Intended to be
+     * used by ready Machine children (whose readiness is bound to the parent's
+     * one) or after doing addCaller() manually.
+     */
+    bool i_isAccessible() const { return !!mData->mAccessible; }
+
+    /**
+     * Returns this machine ID.
+     *
+     * @note This method doesn't check this object's readiness. Intended to be
+     * used by ready Machine children (whose readiness is bound to the parent's
+     * one) or after adding a caller manually.
+     */
+    const Guid& i_getId() const { return mData->mUuid; }
+
+    /**
+     * Returns the snapshot ID this machine represents or an empty UUID if this
+     * instance is not SnapshotMachine.
+     *
+     * @note This method doesn't check this object's readiness. Intended to be
+     * used by ready Machine children (whose readiness is bound to the parent's
+     * one) or after adding a caller manually.
+     */
+    inline const Guid& i_getSnapshotId() const;
+
+    /**
+     * Returns this machine's full settings file path.
+     *
+     * @note This method doesn't lock this object or check its readiness.
+     * Intended to be used only after doing addCaller() manually and locking it
+     * for reading.
+     */
+    const Utf8Str& i_getSettingsFileFull() const { return mData->m_strConfigFileFull; }
+
+    /**
+     * Returns this machine name.
+     *
+     * @note This method doesn't lock this object or check its readiness.
+     * Intended to be used only after doing addCaller() manually and locking it
+     * for reading.
+     */
+    const Utf8Str& i_getName() const { return mUserData->s.strName; }
+
+    enum
+    {
+        IsModified_MachineData           = 0x000001,
+        IsModified_Storage               = 0x000002,
+        IsModified_NetworkAdapters       = 0x000008,
+        IsModified_SerialPorts           = 0x000010,
+        IsModified_ParallelPorts         = 0x000020,
+        IsModified_VRDEServer            = 0x000040,
+        IsModified_AudioSettings         = 0x000080,
+        IsModified_USB                   = 0x000100,
+        IsModified_BIOS                  = 0x000200,
+        IsModified_SharedFolders         = 0x000400,
+        IsModified_Snapshots             = 0x000800,
+        IsModified_BandwidthControl      = 0x001000,
+        IsModified_Recording             = 0x002000,
+        IsModified_GraphicsAdapter       = 0x004000,
+        IsModified_TrustedPlatformModule = 0x008000,
+        IsModified_NvramStore            = 0x010000,
+        IsModified_GuestDebugControl     = 0x020000,
+    };
+
+    /**
+     * Returns various information about this machine.
+     *
+     * @note This method doesn't lock this object or check its readiness.
+     * Intended to be used only after doing addCaller() manually and locking it
+     * for reading.
+     */
+    Utf8Str i_getOSTypeId() const { return mUserData->s.strOsType; }
+    ChipsetType_T i_getChipsetType() const { return mHWData->mChipsetType; }
+    FirmwareType_T i_getFirmwareType() const { return mHWData->mFirmwareType; }
+    ParavirtProvider_T i_getParavirtProvider() const { return mHWData->mParavirtProvider; }
+    Utf8Str i_getParavirtDebug() const { return mHWData->mParavirtDebug; }
+
+    void i_setModified(uint32_t fl, bool fAllowStateModification = true);
+    void i_setModifiedLock(uint32_t fl, bool fAllowStateModification = true);
+
+    MachineState_T i_getMachineState() const { return mData->mMachineState; }
+
+    bool i_isStateModificationAllowed() const { return mData->m_fAllowStateModification; }
+    void i_allowStateModification()           { mData->m_fAllowStateModification = true; }
+    void i_disallowStateModification()        { mData->m_fAllowStateModification = false; }
+
+    const StringsList &i_getGroups() const { return mUserData->s.llGroups; }
+
+    // callback handlers
+    virtual HRESULT i_onNetworkAdapterChange(INetworkAdapter * /* networkAdapter */, BOOL /* changeAdapter */) { return S_OK; }
+    virtual HRESULT i_onNATRedirectRuleChanged(ULONG /* slot */, BOOL /* fRemove */ , const Utf8Str & /* name */,
+                                               NATProtocol_T /* protocol */, const Utf8Str & /* host ip */, LONG /* host port */,
+                                               const Utf8Str & /* guest port */, LONG /* guest port */ ) { return S_OK; }
+    virtual HRESULT i_onAudioAdapterChange(IAudioAdapter * /* audioAdapter */) { return S_OK; }
+    virtual HRESULT i_onHostAudioDeviceChange(IHostAudioDevice *, BOOL /* new */, AudioDeviceState_T, IVirtualBoxErrorInfo *) { return S_OK; }
+    virtual HRESULT i_onSerialPortChange(ISerialPort * /* serialPort */) { return S_OK; }
+    virtual HRESULT i_onParallelPortChange(IParallelPort * /* parallelPort */) { return S_OK; }
+    virtual HRESULT i_onVRDEServerChange(BOOL /* aRestart */) { return S_OK; }
+    virtual HRESULT i_onUSBControllerChange() { return S_OK; }
+    virtual HRESULT i_onStorageControllerChange(const com::Guid & /* aMachineId */, const com::Utf8Str & /* aControllerName */) { return S_OK; }
+    virtual HRESULT i_onCPUChange(ULONG /* aCPU */, BOOL /* aRemove */) { return S_OK; }
+    virtual HRESULT i_onCPUExecutionCapChange(ULONG /* aExecutionCap */) { return S_OK; }
+    virtual HRESULT i_onMediumChange(IMediumAttachment * /* mediumAttachment */, BOOL /* force */) { return S_OK; }
+    virtual HRESULT i_onSharedFolderChange() { return S_OK; }
+    virtual HRESULT i_onVMProcessPriorityChange(VMProcPriority_T /* aPriority */) { return S_OK; }
+    virtual HRESULT i_onClipboardModeChange(ClipboardMode_T /* aClipboardMode */) { return S_OK; }
+    virtual HRESULT i_onClipboardFileTransferModeChange(BOOL /* aEnable */) { return S_OK; }
+    virtual HRESULT i_onDnDModeChange(DnDMode_T /* aDnDMode */) { return S_OK; }
+    virtual HRESULT i_onBandwidthGroupChange(IBandwidthGroup * /* aBandwidthGroup */) { return S_OK; }
+    virtual HRESULT i_onStorageDeviceChange(IMediumAttachment * /* mediumAttachment */, BOOL /* remove */,
+                                            BOOL /* silent */) { return S_OK; }
+    virtual HRESULT i_onRecordingChange(BOOL /* aEnable */) { return S_OK; }
+    virtual HRESULT i_onGuestDebugControlChange(IGuestDebugControl * /* guestDebugControl */) { return S_OK; }
+
+
+    HRESULT i_saveRegistryEntry(settings::MachineRegistryEntry &data);
+
+    int i_calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult);
+    void i_copyPathRelativeToMachine(const Utf8Str &strSource, Utf8Str &strTarget);
+
+    void i_getLogFolder(Utf8Str &aLogFolder);
+    Utf8Str i_getLogFilename(ULONG idx);
+    Utf8Str i_getHardeningLogFilename(void);
+    Utf8Str i_getDefaultNVRAMFilename();
+    Utf8Str i_getSnapshotNVRAMFilename();
+    SettingsVersion_T i_getSettingsVersion(void);
+
+    void i_composeSavedStateFilename(Utf8Str &strStateFilePath);
+
+    bool i_isUSBControllerPresent();
+
+    HRESULT i_launchVMProcess(IInternalSessionControl *aControl,
+                              const Utf8Str &strType,
+                              const std::vector<com::Utf8Str> &aEnvironmentChanges,
+                              ProgressProxy *aProgress);
+
+    HRESULT i_getDirectControl(ComPtr<IInternalSessionControl> *directControl)
+    {
+        *directControl = mData->mSession.mDirectControl;
+
+        HRESULT hrc;
+        if (!*directControl)
+            hrc = E_ACCESSDENIED;
+        else
+            hrc = S_OK;
+
+        return hrc;
+    }
+
+    bool i_isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
+                         ComPtr<IInternalSessionControl> *aControl = NULL,
+                         bool aRequireVM = false,
+                         bool aAllowClosing = false);
+    bool i_isSessionSpawning();
+
+    bool i_isSessionOpenOrClosing(ComObjPtr<SessionMachine> &aMachine,
+                                  ComPtr<IInternalSessionControl> *aControl = NULL)
+    { return i_isSessionOpen(aMachine, aControl, false /* aRequireVM */, true /* aAllowClosing */); }
+
+    bool i_isSessionOpenVM(ComObjPtr<SessionMachine> &aMachine,
+                           ComPtr<IInternalSessionControl> *aControl = NULL)
+    { return i_isSessionOpen(aMachine, aControl, true /* aRequireVM */, false /* aAllowClosing */); }
+
+    bool i_checkForSpawnFailure();
+
+    HRESULT i_prepareRegister();
+
+    HRESULT i_getSharedFolder(const Utf8Str &aName,
+                              ComObjPtr<SharedFolder> &aSharedFolder,
+                              bool aSetError = false)
+    {
+        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+        return i_findSharedFolder(aName, aSharedFolder, aSetError);
+    }
+
+    HRESULT i_addStateDependency(StateDependency aDepType = AnyStateDep,
+                                 MachineState_T *aState = NULL,
+                                 BOOL *aRegistered = NULL);
+    void i_releaseStateDependency();
+
+    HRESULT i_getStorageControllerByName(const Utf8Str &aName,
+                                         ComObjPtr<StorageController> &aStorageController,
+                                         bool aSetError = false);
+
+    HRESULT i_getMediumAttachmentsOfController(const Utf8Str &aName,
+                                               MediumAttachmentList &aAttachments);
+
+    HRESULT i_getUSBControllerByName(const Utf8Str &aName,
+                                     ComObjPtr<USBController> &aUSBController,
+                                     bool aSetError = false);
+
+    HRESULT i_getBandwidthGroup(const Utf8Str &strBandwidthGroup,
+                                ComObjPtr<BandwidthGroup> &pBandwidthGroup,
+                                bool fSetError = false)
+    {
+        return mBandwidthControl->i_getBandwidthGroupByName(strBandwidthGroup,
+                                                            pBandwidthGroup,
+                                                            fSetError);
+    }
+
+    static HRESULT i_setErrorStatic(HRESULT aResultCode, const char *pcszMsg, ...);
+
+protected:
+
+    class ClientToken;
+
+    HRESULT i_checkStateDependency(StateDependency aDepType);
+
+    Machine *i_getMachine();
+
+    void i_ensureNoStateDependencies(AutoWriteLock &alock);
+
+    virtual HRESULT i_setMachineState(MachineState_T aMachineState);
+
+    HRESULT i_findSharedFolder(const Utf8Str &aName,
+                               ComObjPtr<SharedFolder> &aSharedFolder,
+                               bool aSetError = false);
+
+    HRESULT i_loadSettings(bool aRegistered);
+    HRESULT i_loadMachineDataFromSettings(const settings::MachineConfigFile &config,
+                                          const Guid *puuidRegistry);
+    HRESULT i_loadSnapshot(const settings::Snapshot &data,
+                           const Guid &aCurSnapshotId);
+    HRESULT i_loadHardware(const Guid *puuidRegistry,
+                           const Guid *puuidSnapshot,
+                           const settings::Hardware &data,
+                           const settings::Debugging *pDbg,
+                           const settings::Autostart *pAutostart,
+                           const settings::RecordingSettings &recording);
+    HRESULT i_loadDebugging(const settings::Debugging *pDbg);
+    HRESULT i_loadAutostart(const settings::Autostart *pAutostart);
+    HRESULT i_loadStorageControllers(const settings::Storage &data,
+                                     const Guid *puuidRegistry,
+                                     const Guid *puuidSnapshot);
+    HRESULT i_loadStorageDevices(StorageController *aStorageController,
+                                 const settings::StorageController &data,
+                                 const Guid *puuidRegistry,
+                                 const Guid *puuidSnapshot);
+
+    HRESULT i_findSnapshotById(const Guid &aId,
+                               ComObjPtr<Snapshot> &aSnapshot,
+                               bool aSetError = false);
+    HRESULT i_findSnapshotByName(const Utf8Str &strName,
+                                 ComObjPtr<Snapshot> &aSnapshot,
+                                 bool aSetError = false);
+
+    ULONG   i_getUSBControllerCountByType(USBControllerType_T enmType);
+
+    enum
+    {
+        /* flags for #saveSettings() */
+        SaveS_ResetCurStateModified = 0x01,
+        SaveS_Force = 0x04,
+        SaveS_RemoveBackup = 0x08,
+        /* flags for #saveStateSettings() */
+        SaveSTS_CurStateModified = 0x20,
+        SaveSTS_StateFilePath = 0x40,
+        SaveSTS_StateTimeStamp = 0x80
+    };
+
+    HRESULT i_prepareSaveSettings(bool *pfNeedsGlobalSaveSettings,
+                                  bool *pfSettingsFileIsNew);
+    HRESULT i_saveSettings(bool *pfNeedsGlobalSaveSettings, AutoWriteLock &alock, int aFlags = 0);
+
+    void i_copyMachineDataToSettings(settings::MachineConfigFile &config);
+    HRESULT i_saveAllSnapshots(settings::MachineConfigFile &config);
+    HRESULT i_saveHardware(settings::Hardware &data, settings::Debugging *pDbg,
+                           settings::Autostart *pAutostart, settings::RecordingSettings &recording);
+    HRESULT i_saveStorageControllers(settings::Storage &data);
+    HRESULT i_saveStorageDevices(ComObjPtr<StorageController> aStorageController,
+                                 settings::StorageController &data);
+    HRESULT i_saveStateSettings(int aFlags);
+
+    void i_addMediumToRegistry(ComObjPtr<Medium> &pMedium);
+
+    HRESULT i_deleteFile(const Utf8Str &strFile, bool fIgnoreFailures = false, const Utf8Str &strWhat = "", int *prc = NULL);
+
+    HRESULT i_createImplicitDiffs(IProgress *aProgress,
+                                  ULONG aWeight,
+                                  bool aOnline);
+    HRESULT i_deleteImplicitDiffs(bool aOnline);
+
+    MediumAttachment* i_findAttachment(const MediumAttachmentList &ll,
+                                       const Utf8Str &aControllerName,
+                                       LONG aControllerPort,
+                                       LONG aDevice);
+    MediumAttachment* i_findAttachment(const MediumAttachmentList &ll,
+                                       ComObjPtr<Medium> pMedium);
+    MediumAttachment* i_findAttachment(const MediumAttachmentList &ll,
+                                       Guid &id);
+
+    HRESULT i_detachDevice(MediumAttachment *pAttach,
+                           AutoWriteLock &writeLock,
+                           Snapshot *pSnapshot);
+
+    HRESULT i_detachAllMedia(AutoWriteLock &writeLock,
+                             Snapshot *pSnapshot,
+                             CleanupMode_T cleanupMode,
+                             MediaList &llMedia);
+
+    void i_commitMedia(bool aOnline = false);
+    void i_rollbackMedia();
+
+    bool i_isInOwnDir(Utf8Str *aSettingsDir = NULL) const;
+
+    void i_rollback(bool aNotify);
+    void i_commit();
+    void i_copyFrom(Machine *aThat);
+    bool i_isControllerHotplugCapable(StorageControllerType_T enmCtrlType);
+
+    Utf8Str i_getExtraData(const Utf8Str &strKey);
+
+    com::Utf8Str i_controllerNameFromBusType(StorageBus_T aBusType);
+
+#ifdef VBOX_WITH_GUEST_PROPS
+    HRESULT i_getGuestPropertyFromService(const com::Utf8Str &aName, com::Utf8Str &aValue,
+                                          LONG64 *aTimestamp, com::Utf8Str &aFlags) const;
+    HRESULT i_setGuestPropertyToService(const com::Utf8Str &aName, const com::Utf8Str &aValue,
+                                        const com::Utf8Str &aFlags, bool fDelete);
+    HRESULT i_getGuestPropertyFromVM(const com::Utf8Str &aName, com::Utf8Str &aValue,
+                                     LONG64 *aTimestamp, com::Utf8Str &aFlags) const;
+    HRESULT i_setGuestPropertyToVM(const com::Utf8Str &aName, const com::Utf8Str &aValue,
+                                   const com::Utf8Str &aFlags, bool fDelete);
+    HRESULT i_enumerateGuestPropertiesInService(const com::Utf8Str &aPatterns,
+                                                std::vector<com::Utf8Str> &aNames,
+                                                std::vector<com::Utf8Str> &aValues,
+                                                std::vector<LONG64> &aTimestamps,
+                                                std::vector<com::Utf8Str> &aFlags);
+    HRESULT i_enumerateGuestPropertiesOnVM(const com::Utf8Str &aPatterns,
+                                           std::vector<com::Utf8Str> &aNames,
+                                           std::vector<com::Utf8Str> &aValues,
+                                           std::vector<LONG64> &aTimestamps,
+                                           std::vector<com::Utf8Str> &aFlags);
+
+#endif /* VBOX_WITH_GUEST_PROPS */
+
+#ifdef VBOX_WITH_RESOURCE_USAGE_API
+    void i_getDiskList(MediaList &list);
+    void i_registerMetrics(PerformanceCollector *aCollector, Machine *aMachine, RTPROCESS pid);
+
+    pm::CollectorGuest     *mCollectorGuest;
+#endif /* VBOX_WITH_RESOURCE_USAGE_API */
+
+    Machine * const         mPeer;
+
+    VirtualBox * const      mParent;
+
+    Shareable<Data>         mData;
+    Shareable<SSData>       mSSData;
+
+    Backupable<UserData>    mUserData;
+    Backupable<HWData>      mHWData;
+
+    /**
+     * Hard disk and other media data.
+     *
+     * The usage policy is the same as for mHWData, but a separate field
+     * is necessary because hard disk data requires different procedures when
+     * taking or deleting snapshots, etc.
+     *
+     * @todo r=klaus change this to a regular list and use the normal way to
+     * handle the settings when creating a session or taking a snapshot.
+     * Same thing applies to mStorageControllers and mUSBControllers.
+     */
+    Backupable<MediumAttachmentList> mMediumAttachments;
+
+    // the following fields need special backup/rollback/commit handling,
+    // so they cannot be a part of HWData
+
+    const ComObjPtr<VRDEServer>        mVRDEServer;
+    const ComObjPtr<SerialPort>        mSerialPorts[SchemaDefs::SerialPortCount];
+    const ComObjPtr<ParallelPort>      mParallelPorts[SchemaDefs::ParallelPortCount];
+    const ComObjPtr<AudioSettings>     mAudioSettings;
+    const ComObjPtr<USBDeviceFilters>  mUSBDeviceFilters;
+    const ComObjPtr<BIOSSettings>      mBIOSSettings;
+    const ComObjPtr<RecordingSettings> mRecordingSettings;
+    const ComObjPtr<GraphicsAdapter>   mGraphicsAdapter;
+    const ComObjPtr<BandwidthControl>  mBandwidthControl;
+    const ComObjPtr<GuestDebugControl> mGuestDebugControl;
+
+    const ComObjPtr<TrustedPlatformModule> mTrustedPlatformModule;
+    const ComObjPtr<NvramStore>            mNvramStore;
+
+    typedef std::vector<ComObjPtr<NetworkAdapter> > NetworkAdapterVector;
+    NetworkAdapterVector               mNetworkAdapters;
+
+    typedef std::list<ComObjPtr<StorageController> > StorageControllerList;
+    Backupable<StorageControllerList>  mStorageControllers;
+
+    typedef std::list<ComObjPtr<USBController> > USBControllerList;
+    Backupable<USBControllerList>      mUSBControllers;
+
+    uint64_t                           uRegistryNeedsSaving;
+
+    /**
+     * Abstract base class for all Machine or SessionMachine related
+     * asynchronous tasks. This is necessary since RTThreadCreate cannot call
+     * a (non-static) method as its thread function, so instead we have it call
+     * the static Machine::taskHandler, which then calls the handler() method
+     * in here (implemented by the subclasses).
+     */
+    class Task : public ThreadTask
+    {
+    public:
+        Task(Machine *m, Progress *p, const Utf8Str &t)
+            : ThreadTask(t),
+              m_pMachine(m),
+              m_machineCaller(m),
+              m_pProgress(p),
+              m_machineStateBackup(m->mData->mMachineState) // save the current machine state
+        {}
+        virtual ~Task(){}
+
+        void modifyBackedUpState(MachineState_T s)
+        {
+            *const_cast<MachineState_T *>(&m_machineStateBackup) = s;
+        }
+
+        ComObjPtr<Machine>              m_pMachine;
+        AutoCaller                      m_machineCaller;
+        ComObjPtr<Progress>             m_pProgress;
+        const MachineState_T            m_machineStateBackup;
+    };
+
+    class DeleteConfigTask;
+    void i_deleteConfigHandler(DeleteConfigTask &task);
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+    class ChangeEncryptionTask;
+    void i_changeEncryptionHandler(ChangeEncryptionTask &task);
+    HRESULT i_changeEncryptionForComponent(ChangeEncryptionTask &task, const com::Utf8Str strDirectory,
+                                           const com::Utf8Str strFilePattern, com::Utf8Str &strKeyStore,
+                                           com::Utf8Str &strKeyId, int iCipherMode);
+    int i_findFiles(std::list<com::Utf8Str> &lstFiles, const com::Utf8Str &strDir,
+                    const com::Utf8Str &strPattern);
+    int i_createIoStreamForFile(const char *pszFilename, PCVBOXCRYPTOIF pCryptoIf,
+                                const char *pszKeyStore, const char *pszPassword,
+                                uint64_t fOpen, PRTVFSIOSTREAM phVfsIos);
+#endif
+
+    friend class Appliance;
+    friend class RecordingSettings;
+    friend class RecordingScreenSettings;
+    friend class SessionMachine;
+    friend class SnapshotMachine;
+    friend class VirtualBox;
+
+    friend class MachineCloneVM;
+    friend class MachineMoveVM;
+private:
+    // wrapped IMachine properties
+    HRESULT getParent(ComPtr<IVirtualBox> &aParent);
+    HRESULT getIcon(std::vector<BYTE> &aIcon);
+    HRESULT setIcon(const std::vector<BYTE> &aIcon);
+    HRESULT getAccessible(BOOL *aAccessible);
+    HRESULT getAccessError(ComPtr<IVirtualBoxErrorInfo> &aAccessError);
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT setName(const com::Utf8Str &aName);
+    HRESULT getDescription(com::Utf8Str &aDescription);
+    HRESULT setDescription(const com::Utf8Str &aDescription);
+    HRESULT getId(com::Guid &aId);
+    HRESULT getGroups(std::vector<com::Utf8Str> &aGroups);
+    HRESULT setGroups(const std::vector<com::Utf8Str> &aGroups);
+    HRESULT getOSTypeId(com::Utf8Str &aOSTypeId);
+    HRESULT setOSTypeId(const com::Utf8Str &aOSTypeId);
+    HRESULT getHardwareVersion(com::Utf8Str &aHardwareVersion);
+    HRESULT setHardwareVersion(const com::Utf8Str &aHardwareVersion);
+    HRESULT getHardwareUUID(com::Guid &aHardwareUUID);
+    HRESULT setHardwareUUID(const com::Guid &aHardwareUUID);
+    HRESULT getCPUCount(ULONG *aCPUCount);
+    HRESULT setCPUCount(ULONG aCPUCount);
+    HRESULT getCPUHotPlugEnabled(BOOL *aCPUHotPlugEnabled);
+    HRESULT setCPUHotPlugEnabled(BOOL aCPUHotPlugEnabled);
+    HRESULT getCPUExecutionCap(ULONG *aCPUExecutionCap);
+    HRESULT setCPUExecutionCap(ULONG aCPUExecutionCap);
+    HRESULT getCPUIDPortabilityLevel(ULONG *aCPUIDPortabilityLevel);
+    HRESULT setCPUIDPortabilityLevel(ULONG aCPUIDPortabilityLevel);
+    HRESULT getCPUProfile(com::Utf8Str &aCPUProfile);
+    HRESULT setCPUProfile(const com::Utf8Str &aCPUProfile);
+    HRESULT getMemorySize(ULONG *aMemorySize);
+    HRESULT setMemorySize(ULONG aMemorySize);
+    HRESULT getMemoryBalloonSize(ULONG *aMemoryBalloonSize);
+    HRESULT setMemoryBalloonSize(ULONG aMemoryBalloonSize);
+    HRESULT getPageFusionEnabled(BOOL *aPageFusionEnabled);
+    HRESULT setPageFusionEnabled(BOOL aPageFusionEnabled);
+    HRESULT getGraphicsAdapter(ComPtr<IGraphicsAdapter> &aGraphicsAdapter);
+    HRESULT getBIOSSettings(ComPtr<IBIOSSettings> &aBIOSSettings);
+    HRESULT getTrustedPlatformModule(ComPtr<ITrustedPlatformModule> &aTrustedPlatformModule);
+    HRESULT getNonVolatileStore(ComPtr<INvramStore> &aNvramStore);
+    HRESULT getRecordingSettings(ComPtr<IRecordingSettings> &aRecordingSettings);
+    HRESULT getFirmwareType(FirmwareType_T *aFirmwareType);
+    HRESULT setFirmwareType(FirmwareType_T aFirmwareType);
+    HRESULT getPointingHIDType(PointingHIDType_T *aPointingHIDType);
+    HRESULT setPointingHIDType(PointingHIDType_T aPointingHIDType);
+    HRESULT getKeyboardHIDType(KeyboardHIDType_T *aKeyboardHIDType);
+    HRESULT setKeyboardHIDType(KeyboardHIDType_T aKeyboardHIDType);
+    HRESULT getHPETEnabled(BOOL *aHPETEnabled);
+    HRESULT setHPETEnabled(BOOL aHPETEnabled);
+    HRESULT getChipsetType(ChipsetType_T *aChipsetType);
+    HRESULT setChipsetType(ChipsetType_T aChipsetType);
+    HRESULT getIommuType(IommuType_T *aIommuType);
+    HRESULT setIommuType(IommuType_T aIommuType);
+    HRESULT getSnapshotFolder(com::Utf8Str &aSnapshotFolder);
+    HRESULT setSnapshotFolder(const com::Utf8Str &aSnapshotFolder);
+    HRESULT getVRDEServer(ComPtr<IVRDEServer> &aVRDEServer);
+    HRESULT getEmulatedUSBCardReaderEnabled(BOOL *aEmulatedUSBCardReaderEnabled);
+    HRESULT setEmulatedUSBCardReaderEnabled(BOOL aEmulatedUSBCardReaderEnabled);
+    HRESULT getMediumAttachments(std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments);
+    HRESULT getUSBControllers(std::vector<ComPtr<IUSBController> > &aUSBControllers);
+    HRESULT getUSBDeviceFilters(ComPtr<IUSBDeviceFilters> &aUSBDeviceFilters);
+    HRESULT getAudioSettings(ComPtr<IAudioSettings> &aAudioSettings);
+    HRESULT getStorageControllers(std::vector<ComPtr<IStorageController> > &aStorageControllers);
+    HRESULT getSettingsFilePath(com::Utf8Str &aSettingsFilePath);
+    HRESULT getSettingsAuxFilePath(com::Utf8Str &aSettingsAuxFilePath);
+    HRESULT getSettingsModified(BOOL *aSettingsModified);
+    HRESULT getSessionState(SessionState_T *aSessionState);
+    HRESULT getSessionType(SessionType_T *aSessionType);
+    HRESULT getSessionName(com::Utf8Str &aSessionType);
+    HRESULT getSessionPID(ULONG *aSessionPID);
+    HRESULT getState(MachineState_T *aState);
+    HRESULT getLastStateChange(LONG64 *aLastStateChange);
+    HRESULT getStateFilePath(com::Utf8Str &aStateFilePath);
+    HRESULT getLogFolder(com::Utf8Str &aLogFolder);
+    HRESULT getCurrentSnapshot(ComPtr<ISnapshot> &aCurrentSnapshot);
+    HRESULT getSnapshotCount(ULONG *aSnapshotCount);
+    HRESULT getCurrentStateModified(BOOL *aCurrentStateModified);
+    HRESULT getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders);
+    HRESULT getClipboardMode(ClipboardMode_T *aClipboardMode);
+    HRESULT setClipboardMode(ClipboardMode_T aClipboardMode);
+    HRESULT getClipboardFileTransfersEnabled(BOOL *aEnabled);
+    HRESULT setClipboardFileTransfersEnabled(BOOL aEnabled);
+    HRESULT getDnDMode(DnDMode_T *aDnDMode);
+    HRESULT setDnDMode(DnDMode_T aDnDMode);
+    HRESULT getTeleporterEnabled(BOOL *aTeleporterEnabled);
+    HRESULT setTeleporterEnabled(BOOL aTeleporterEnabled);
+    HRESULT getTeleporterPort(ULONG *aTeleporterPort);
+    HRESULT setTeleporterPort(ULONG aTeleporterPort);
+    HRESULT getTeleporterAddress(com::Utf8Str &aTeleporterAddress);
+    HRESULT setTeleporterAddress(const com::Utf8Str &aTeleporterAddress);
+    HRESULT getTeleporterPassword(com::Utf8Str &aTeleporterPassword);
+    HRESULT setTeleporterPassword(const com::Utf8Str &aTeleporterPassword);
+    HRESULT getParavirtProvider(ParavirtProvider_T *aParavirtProvider);
+    HRESULT setParavirtProvider(ParavirtProvider_T aParavirtProvider);
+    HRESULT getParavirtDebug(com::Utf8Str &aParavirtDebug);
+    HRESULT setParavirtDebug(const com::Utf8Str &aParavirtDebug);
+    HRESULT getRTCUseUTC(BOOL *aRTCUseUTC);
+    HRESULT setRTCUseUTC(BOOL aRTCUseUTC);
+    HRESULT getIOCacheEnabled(BOOL *aIOCacheEnabled);
+    HRESULT setIOCacheEnabled(BOOL aIOCacheEnabled);
+    HRESULT getIOCacheSize(ULONG *aIOCacheSize);
+    HRESULT setIOCacheSize(ULONG aIOCacheSize);
+    HRESULT getPCIDeviceAssignments(std::vector<ComPtr<IPCIDeviceAttachment> > &aPCIDeviceAssignments);
+    HRESULT getBandwidthControl(ComPtr<IBandwidthControl> &aBandwidthControl);
+    HRESULT getTracingEnabled(BOOL *aTracingEnabled);
+    HRESULT setTracingEnabled(BOOL aTracingEnabled);
+    HRESULT getTracingConfig(com::Utf8Str &aTracingConfig);
+    HRESULT setTracingConfig(const com::Utf8Str &aTracingConfig);
+    HRESULT getAllowTracingToAccessVM(BOOL *aAllowTracingToAccessVM);
+    HRESULT setAllowTracingToAccessVM(BOOL aAllowTracingToAccessVM);
+    HRESULT getAutostartEnabled(BOOL *aAutostartEnabled);
+    HRESULT setAutostartEnabled(BOOL aAutostartEnabled);
+    HRESULT getAutostartDelay(ULONG *aAutostartDelay);
+    HRESULT setAutostartDelay(ULONG aAutostartDelay);
+    HRESULT getAutostopType(AutostopType_T *aAutostopType);
+    HRESULT setAutostopType(AutostopType_T aAutostopType);
+    HRESULT getDefaultFrontend(com::Utf8Str &aDefaultFrontend);
+    HRESULT setDefaultFrontend(const com::Utf8Str &aDefaultFrontend);
+    HRESULT getUSBProxyAvailable(BOOL *aUSBProxyAvailable);
+    HRESULT getVMProcessPriority(VMProcPriority_T *aVMProcessPriority);
+    HRESULT setVMProcessPriority(VMProcPriority_T aVMProcessPriority);
+    HRESULT getStateKeyId(com::Utf8Str &aKeyId);
+    HRESULT getStateKeyStore(com::Utf8Str &aKeyStore);
+    HRESULT getLogKeyId(com::Utf8Str &aKeyId);
+    HRESULT getLogKeyStore(com::Utf8Str &aKeyStore);
+    HRESULT getGuestDebugControl(ComPtr<IGuestDebugControl> &aGuestDebugControl);
+
+    // wrapped IMachine methods
+    HRESULT lockMachine(const ComPtr<ISession> &aSession,
+                        LockType_T aLockType);
+    HRESULT launchVMProcess(const ComPtr<ISession> &aSession,
+                            const com::Utf8Str &aType,
+                            const std::vector<com::Utf8Str> &aEnvironmentChanges,
+                            ComPtr<IProgress> &aProgress);
+    HRESULT setBootOrder(ULONG aPosition,
+                         DeviceType_T aDevice);
+    HRESULT getBootOrder(ULONG aPosition,
+                         DeviceType_T *aDevice);
+    HRESULT attachDevice(const com::Utf8Str &aName,
+                         LONG aControllerPort,
+                         LONG aDevice,
+                         DeviceType_T aType,
+                         const ComPtr<IMedium> &aMedium);
+    HRESULT attachDeviceWithoutMedium(const com::Utf8Str &aName,
+                                      LONG aControllerPort,
+                                      LONG aDevice,
+                                      DeviceType_T aType);
+    HRESULT detachDevice(const com::Utf8Str &aName,
+                         LONG aControllerPort,
+                         LONG aDevice);
+    HRESULT passthroughDevice(const com::Utf8Str &aName,
+                              LONG aControllerPort,
+                              LONG aDevice,
+                              BOOL aPassthrough);
+    HRESULT temporaryEjectDevice(const com::Utf8Str &aName,
+                                 LONG aControllerPort,
+                                 LONG aDevice,
+                                 BOOL aTemporaryEject);
+    HRESULT nonRotationalDevice(const com::Utf8Str &aName,
+                                LONG aControllerPort,
+                                LONG aDevice,
+                                BOOL aNonRotational);
+    HRESULT setAutoDiscardForDevice(const com::Utf8Str &aName,
+                                    LONG aControllerPort,
+                                    LONG aDevice,
+                                    BOOL aDiscard);
+    HRESULT setHotPluggableForDevice(const com::Utf8Str &aName,
+                                     LONG aControllerPort,
+                                     LONG aDevice,
+                                     BOOL aHotPluggable);
+    HRESULT setBandwidthGroupForDevice(const com::Utf8Str &aName,
+                                       LONG aControllerPort,
+                                       LONG aDevice,
+                                       const ComPtr<IBandwidthGroup> &aBandwidthGroup);
+    HRESULT setNoBandwidthGroupForDevice(const com::Utf8Str &aName,
+                                         LONG aControllerPort,
+                                         LONG aDevice);
+    HRESULT unmountMedium(const com::Utf8Str &aName,
+                          LONG aControllerPort,
+                          LONG aDevice,
+                          BOOL aForce);
+    HRESULT mountMedium(const com::Utf8Str &aName,
+                        LONG aControllerPort,
+                        LONG aDevice,
+                        const ComPtr<IMedium> &aMedium,
+                        BOOL aForce);
+    HRESULT getMedium(const com::Utf8Str &aName,
+                      LONG aControllerPort,
+                      LONG aDevice,
+                      ComPtr<IMedium> &aMedium);
+    HRESULT getMediumAttachmentsOfController(const com::Utf8Str &aName,
+                                             std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments);
+    HRESULT getMediumAttachment(const com::Utf8Str &aName,
+                                LONG aControllerPort,
+                                LONG aDevice,
+                                ComPtr<IMediumAttachment> &aAttachment);
+    HRESULT attachHostPCIDevice(LONG aHostAddress,
+                                LONG aDesiredGuestAddress,
+                                BOOL aTryToUnbind);
+    HRESULT detachHostPCIDevice(LONG aHostAddress);
+    HRESULT getNetworkAdapter(ULONG aSlot,
+                              ComPtr<INetworkAdapter> &aAdapter);
+    HRESULT addStorageController(const com::Utf8Str &aName,
+                                 StorageBus_T aConnectionType,
+                                 ComPtr<IStorageController> &aController);
+    HRESULT getStorageControllerByName(const com::Utf8Str &aName,
+                                       ComPtr<IStorageController> &aStorageController);
+    HRESULT getStorageControllerByInstance(StorageBus_T aConnectionType,
+                                           ULONG aInstance,
+                                           ComPtr<IStorageController> &aStorageController);
+    HRESULT removeStorageController(const com::Utf8Str &aName);
+    HRESULT setStorageControllerBootable(const com::Utf8Str &aName,
+                                         BOOL aBootable);
+    HRESULT addUSBController(const com::Utf8Str &aName,
+                             USBControllerType_T aType,
+                             ComPtr<IUSBController> &aController);
+    HRESULT removeUSBController(const com::Utf8Str &aName);
+    HRESULT getUSBControllerByName(const com::Utf8Str &aName,
+                                   ComPtr<IUSBController> &aController);
+    HRESULT getUSBControllerCountByType(USBControllerType_T aType,
+                                        ULONG *aControllers);
+    HRESULT getSerialPort(ULONG aSlot,
+                          ComPtr<ISerialPort> &aPort);
+    HRESULT getParallelPort(ULONG aSlot,
+                            ComPtr<IParallelPort> &aPort);
+    HRESULT getExtraDataKeys(std::vector<com::Utf8Str> &aKeys);
+    HRESULT getExtraData(const com::Utf8Str &aKey,
+                         com::Utf8Str &aValue);
+    HRESULT setExtraData(const com::Utf8Str &aKey,
+                         const com::Utf8Str &aValue);
+    HRESULT getCPUProperty(CPUPropertyType_T aProperty,
+                           BOOL *aValue);
+    HRESULT setCPUProperty(CPUPropertyType_T aProperty,
+                           BOOL aValue);
+    HRESULT getCPUIDLeafByOrdinal(ULONG aOrdinal,
+                                  ULONG *aIdx,
+                                  ULONG *aSubIdx,
+                                  ULONG *aValEax,
+                                  ULONG *aValEbx,
+                                  ULONG *aValEcx,
+                                  ULONG *aValEdx);
+    HRESULT getCPUIDLeaf(ULONG aIdx, ULONG aSubIdx,
+                         ULONG *aValEax,
+                         ULONG *aValEbx,
+                         ULONG *aValEcx,
+                         ULONG *aValEdx);
+    HRESULT setCPUIDLeaf(ULONG aIdx, ULONG aSubIdx,
+                         ULONG aValEax,
+                         ULONG aValEbx,
+                         ULONG aValEcx,
+                         ULONG aValEdx);
+    HRESULT removeCPUIDLeaf(ULONG aIdx, ULONG aSubIdx);
+    HRESULT removeAllCPUIDLeaves();
+    HRESULT getHWVirtExProperty(HWVirtExPropertyType_T aProperty,
+                                BOOL *aValue);
+    HRESULT setHWVirtExProperty(HWVirtExPropertyType_T aProperty,
+                                BOOL aValue);
+    HRESULT setSettingsFilePath(const com::Utf8Str &aSettingsFilePath,
+                                ComPtr<IProgress> &aProgress);
+    HRESULT saveSettings();
+    HRESULT discardSettings();
+    HRESULT unregister(AutoCaller &aAutoCaller,
+                       CleanupMode_T aCleanupMode,
+                       std::vector<ComPtr<IMedium> > &aMedia);
+    HRESULT deleteConfig(const std::vector<ComPtr<IMedium> > &aMedia,
+                         ComPtr<IProgress> &aProgress);
+    HRESULT exportTo(const ComPtr<IAppliance> &aAppliance,
+                     const com::Utf8Str &aLocation,
+                     ComPtr<IVirtualSystemDescription> &aDescription);
+    HRESULT findSnapshot(const com::Utf8Str &aNameOrId,
+                         ComPtr<ISnapshot> &aSnapshot);
+    HRESULT createSharedFolder(const com::Utf8Str &aName,
+                               const com::Utf8Str &aHostPath,
+                               BOOL aWritable,
+                               BOOL aAutomount,
+                               const com::Utf8Str &aAutoMountPoint);
+    HRESULT removeSharedFolder(const com::Utf8Str &aName);
+    HRESULT canShowConsoleWindow(BOOL *aCanShow);
+    HRESULT showConsoleWindow(LONG64 *aWinId);
+    HRESULT getGuestProperty(const com::Utf8Str &aName,
+                             com::Utf8Str &aValue,
+                             LONG64 *aTimestamp,
+                             com::Utf8Str &aFlags);
+    HRESULT getGuestPropertyValue(const com::Utf8Str &aProperty,
+                                  com::Utf8Str &aValue);
+    HRESULT getGuestPropertyTimestamp(const com::Utf8Str &aProperty,
+                                      LONG64 *aValue);
+    HRESULT setGuestProperty(const com::Utf8Str &aProperty,
+                             const com::Utf8Str &aValue,
+                             const com::Utf8Str &aFlags);
+    HRESULT setGuestPropertyValue(const com::Utf8Str &aProperty,
+                                  const com::Utf8Str &aValue);
+    HRESULT deleteGuestProperty(const com::Utf8Str &aName);
+    HRESULT enumerateGuestProperties(const com::Utf8Str &aPatterns,
+                                     std::vector<com::Utf8Str> &aNames,
+                                     std::vector<com::Utf8Str> &aValues,
+                                     std::vector<LONG64> &aTimestamps,
+                                     std::vector<com::Utf8Str> &aFlags);
+    HRESULT querySavedGuestScreenInfo(ULONG aScreenId,
+                                      ULONG *aOriginX,
+                                      ULONG *aOriginY,
+                                      ULONG *aWidth,
+                                      ULONG *aHeight,
+                                      BOOL *aEnabled);
+    HRESULT readSavedThumbnailToArray(ULONG aScreenId,
+                                      BitmapFormat_T aBitmapFormat,
+                                      ULONG *aWidth,
+                                      ULONG *aHeight,
+                                      std::vector<BYTE> &aData);
+    HRESULT querySavedScreenshotInfo(ULONG aScreenId,
+                                     ULONG *aWidth,
+                                     ULONG *aHeight,
+                                     std::vector<BitmapFormat_T> &aBitmapFormats);
+    HRESULT readSavedScreenshotToArray(ULONG aScreenId,
+                                       BitmapFormat_T aBitmapFormat,
+                                       ULONG *aWidth,
+                                       ULONG *aHeight,
+                                       std::vector<BYTE> &aData);
+
+    HRESULT hotPlugCPU(ULONG aCpu);
+    HRESULT hotUnplugCPU(ULONG aCpu);
+    HRESULT getCPUStatus(ULONG aCpu,
+                         BOOL *aAttached);
+    HRESULT getEffectiveParavirtProvider(ParavirtProvider_T *aParavirtProvider);
+    HRESULT queryLogFilename(ULONG aIdx,
+                             com::Utf8Str &aFilename);
+    HRESULT readLog(ULONG aIdx,
+                    LONG64 aOffset,
+                    LONG64 aSize,
+                    std::vector<BYTE> &aData);
+    HRESULT cloneTo(const ComPtr<IMachine> &aTarget,
+                    CloneMode_T aMode,
+                    const std::vector<CloneOptions_T> &aOptions,
+                    ComPtr<IProgress> &aProgress);
+    HRESULT moveTo(const com::Utf8Str &aTargetPath,
+                   const com::Utf8Str &aType,
+                   ComPtr<IProgress> &aProgress);
+    HRESULT saveState(ComPtr<IProgress> &aProgress);
+    HRESULT adoptSavedState(const com::Utf8Str &aSavedStateFile);
+    HRESULT discardSavedState(BOOL aFRemoveFile);
+    HRESULT takeSnapshot(const com::Utf8Str &aName,
+                         const com::Utf8Str &aDescription,
+                         BOOL aPause,
+                         com::Guid &aId,
+                         ComPtr<IProgress> &aProgress);
+    HRESULT deleteSnapshot(const com::Guid &aId,
+                           ComPtr<IProgress> &aProgress);
+    HRESULT deleteSnapshotAndAllChildren(const com::Guid &aId,
+                                         ComPtr<IProgress> &aProgress);
+    HRESULT deleteSnapshotRange(const com::Guid &aStartId,
+                                const com::Guid &aEndId,
+                                ComPtr<IProgress> &aProgress);
+    HRESULT restoreSnapshot(const ComPtr<ISnapshot> &aSnapshot,
+                            ComPtr<IProgress> &aProgress);
+    HRESULT applyDefaults(const com::Utf8Str &aFlags);
+    HRESULT changeEncryption(const com::Utf8Str &aCurrentPassword,
+                             const com::Utf8Str &aCipher,
+                             const com::Utf8Str &aNewPassword,
+                             const com::Utf8Str &aNewPasswordId,
+                             BOOL aForce,
+                             ComPtr<IProgress> &aProgress);
+    HRESULT getEncryptionSettings(com::Utf8Str &aCipher,
+                                  com::Utf8Str &aPasswordId);
+    HRESULT checkEncryptionPassword(const com::Utf8Str &aPassword);
+    HRESULT addEncryptionPassword(const com::Utf8Str &aId,
+                                  const com::Utf8Str &aPassword);
+    HRESULT addEncryptionPasswords(const std::vector<com::Utf8Str> &aIds,
+                                   const std::vector<com::Utf8Str> &aPasswords);
+    HRESULT removeEncryptionPassword(AutoCaller &autoCaller,
+                                     const com::Utf8Str &aId);
+    HRESULT clearAllEncryptionPasswords(AutoCaller &autoCaller);
+
+    // wrapped IInternalMachineControl properties
+
+    // wrapped IInternalMachineControl methods
+    HRESULT updateState(MachineState_T aState);
+    HRESULT beginPowerUp(const ComPtr<IProgress> &aProgress);
+    HRESULT endPowerUp(LONG aResult);
+    HRESULT beginPoweringDown(ComPtr<IProgress> &aProgress);
+    HRESULT endPoweringDown(LONG aResult,
+                            const com::Utf8Str &aErrMsg);
+    HRESULT runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
+                                BOOL *aMatched,
+                                ULONG *aMaskedInterfaces);
+    HRESULT captureUSBDevice(const com::Guid &aId,
+                             const com::Utf8Str &aCaptureFilename);
+    HRESULT detachUSBDevice(const com::Guid &aId,
+                            BOOL aDone);
+    HRESULT autoCaptureUSBDevices();
+    HRESULT detachAllUSBDevices(BOOL aDone);
+    HRESULT onSessionEnd(const ComPtr<ISession> &aSession,
+                         ComPtr<IProgress> &aProgress);
+    HRESULT finishOnlineMergeMedium();
+    HRESULT pullGuestProperties(std::vector<com::Utf8Str> &aNames,
+                                std::vector<com::Utf8Str> &aValues,
+                                std::vector<LONG64> &aTimestamps,
+                                std::vector<com::Utf8Str> &aFlags);
+    HRESULT pushGuestProperty(const com::Utf8Str &aName,
+                              const com::Utf8Str &aValue,
+                              LONG64 aTimestamp,
+                              const com::Utf8Str &aFlags,
+                              BOOL fWasDeleted);
+    HRESULT lockMedia();
+    HRESULT unlockMedia();
+    HRESULT ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
+                        ComPtr<IMediumAttachment> &aNewAttachment);
+    HRESULT reportVmStatistics(ULONG aValidStats,
+                               ULONG aCpuUser,
+                               ULONG aCpuKernel,
+                               ULONG aCpuIdle,
+                               ULONG aMemTotal,
+                               ULONG aMemFree,
+                               ULONG aMemBalloon,
+                               ULONG aMemShared,
+                               ULONG aMemCache,
+                               ULONG aPagedTotal,
+                               ULONG aMemAllocTotal,
+                               ULONG aMemFreeTotal,
+                               ULONG aMemBalloonTotal,
+                               ULONG aMemSharedTotal,
+                               ULONG aVmNetRx,
+                               ULONG aVmNetTx);
+    HRESULT authenticateExternal(const std::vector<com::Utf8Str> &aAuthParams,
+                                 com::Utf8Str &aResult);
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+    HRESULT i_setInaccessible(void);
+#endif
+};
+
+// SessionMachine class
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  @note Notes on locking objects of this class:
+ *  SessionMachine shares some data with the primary Machine instance (pointed
+ *  to by the |mPeer| member). In order to provide data consistency it also
+ *  shares its lock handle. This means that whenever you lock a SessionMachine
+ *  instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
+ *  instance is also locked in the same lock mode. Keep it in mind.
+ */
+class ATL_NO_VTABLE SessionMachine :
+    public Machine
+{
+public:
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SessionMachine, IMachine)
+
+    DECLARE_NOT_AGGREGATABLE(SessionMachine)
+
+    DECLARE_PROTECT_FINAL_CONSTRUCT()
+
+    BEGIN_COM_MAP(SessionMachine)
+        COM_INTERFACE_ENTRY(ISupportErrorInfo)
+        COM_INTERFACE_ENTRY(IMachine)
+        COM_INTERFACE_ENTRY2(IDispatch, IMachine)
+        COM_INTERFACE_ENTRY(IInternalMachineControl)
+        VBOX_TWEAK_INTERFACE_ENTRY(IMachine)
+    END_COM_MAP()
+
+    DECLARE_COMMON_CLASS_METHODS(SessionMachine)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    struct Uninit
+    {
+        enum Reason { Unexpected, Abnormal, Normal };
+    };
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Machine *aMachine);
+    void uninit() { uninit(Uninit::Unexpected); }
+    void uninit(Uninit::Reason aReason);
+
+
+    // util::Lockable interface
+    RWLockHandle *lockHandle() const;
+
+    // public methods only for internal purposes
+
+    virtual bool i_isSessionMachine() const
+    {
+        return true;
+    }
+
+#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
+    bool i_checkForDeath();
+
+    void i_getTokenId(Utf8Str &strTokenId);
+#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
+    IToken *i_getToken();
+#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
+    // getClientToken must be only used by callers who can guarantee that
+    // the object cannot be deleted in the mean time, i.e. have a caller/lock.
+    ClientToken *i_getClientToken();
+
+    HRESULT i_onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter);
+    HRESULT i_onNATRedirectRuleChanged(ULONG ulSlot, BOOL aNatRuleRemove, const Utf8Str &aRuleName,
+                                       NATProtocol_T aProto, const Utf8Str &aHostIp, LONG aHostPort,
+                                       const Utf8Str &aGuestIp, LONG aGuestPort) RT_OVERRIDE;
+    HRESULT i_onStorageControllerChange(const com::Guid &aMachineId, const com::Utf8Str &aControllerName);
+    HRESULT i_onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce);
+    HRESULT i_onVMProcessPriorityChange(VMProcPriority_T aPriority);
+    HRESULT i_onAudioAdapterChange(IAudioAdapter *audioAdapter);
+    HRESULT i_onHostAudioDeviceChange(IHostAudioDevice *aDevice, BOOL aNew, AudioDeviceState_T aState, IVirtualBoxErrorInfo *aErrInfo);
+    HRESULT i_onSerialPortChange(ISerialPort *serialPort);
+    HRESULT i_onParallelPortChange(IParallelPort *parallelPort);
+    HRESULT i_onCPUChange(ULONG aCPU, BOOL aRemove);
+    HRESULT i_onVRDEServerChange(BOOL aRestart);
+    HRESULT i_onRecordingChange(BOOL aEnable);
+    HRESULT i_onUSBControllerChange();
+    HRESULT i_onUSBDeviceAttach(IUSBDevice *aDevice,
+                                IVirtualBoxErrorInfo *aError,
+                                ULONG aMaskedIfs,
+                                const com::Utf8Str &aCaptureFilename);
+    HRESULT i_onUSBDeviceDetach(IN_BSTR aId,
+                                IVirtualBoxErrorInfo *aError);
+    HRESULT i_onSharedFolderChange();
+    HRESULT i_onClipboardModeChange(ClipboardMode_T aClipboardMode);
+    HRESULT i_onClipboardFileTransferModeChange(BOOL aEnable);
+    HRESULT i_onDnDModeChange(DnDMode_T aDnDMode);
+    HRESULT i_onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup);
+    HRESULT i_onStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent);
+    HRESULT i_onCPUExecutionCapChange(ULONG aCpuExecutionCap);
+    HRESULT i_onGuestDebugControlChange(IGuestDebugControl *guestDebugControl);
+
+    bool i_hasMatchingUSBFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs);
+
+    HRESULT i_lockMedia();
+    HRESULT i_unlockMedia();
+
+    HRESULT i_saveStateWithReason(Reason_T aReason, ComPtr<IProgress> &aProgress);
+
+private:
+
+    // wrapped IInternalMachineControl properties
+
+    // wrapped IInternalMachineControl methods
+    HRESULT setRemoveSavedStateFile(BOOL aRemove);
+    HRESULT updateState(MachineState_T aState);
+    HRESULT beginPowerUp(const ComPtr<IProgress> &aProgress);
+    HRESULT endPowerUp(LONG aResult);
+    HRESULT beginPoweringDown(ComPtr<IProgress> &aProgress);
+    HRESULT endPoweringDown(LONG aResult,
+                            const com::Utf8Str &aErrMsg);
+    HRESULT runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
+                                BOOL *aMatched,
+                                ULONG *aMaskedInterfaces);
+    HRESULT captureUSBDevice(const com::Guid &aId, const com::Utf8Str &aCaptureFilename);
+    HRESULT detachUSBDevice(const com::Guid &aId,
+                            BOOL aDone);
+    HRESULT autoCaptureUSBDevices();
+    HRESULT detachAllUSBDevices(BOOL aDone);
+    HRESULT onSessionEnd(const ComPtr<ISession> &aSession,
+                         ComPtr<IProgress> &aProgress);
+    HRESULT finishOnlineMergeMedium();
+    HRESULT pullGuestProperties(std::vector<com::Utf8Str> &aNames,
+                                std::vector<com::Utf8Str> &aValues,
+                                std::vector<LONG64> &aTimestamps,
+                                std::vector<com::Utf8Str> &aFlags);
+    HRESULT pushGuestProperty(const com::Utf8Str &aName,
+                              const com::Utf8Str &aValue,
+                              LONG64 aTimestamp,
+                              const com::Utf8Str &aFlags,
+                              BOOL fWasDeleted);
+    HRESULT lockMedia();
+    HRESULT unlockMedia();
+    HRESULT ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
+                        ComPtr<IMediumAttachment> &aNewAttachment);
+    HRESULT reportVmStatistics(ULONG aValidStats,
+                               ULONG aCpuUser,
+                               ULONG aCpuKernel,
+                               ULONG aCpuIdle,
+                               ULONG aMemTotal,
+                               ULONG aMemFree,
+                               ULONG aMemBalloon,
+                               ULONG aMemShared,
+                               ULONG aMemCache,
+                               ULONG aPagedTotal,
+                               ULONG aMemAllocTotal,
+                               ULONG aMemFreeTotal,
+                               ULONG aMemBalloonTotal,
+                               ULONG aMemSharedTotal,
+                               ULONG aVmNetRx,
+                               ULONG aVmNetTx);
+    HRESULT authenticateExternal(const std::vector<com::Utf8Str> &aAuthParams,
+                                 com::Utf8Str &aResult);
+
+
+    struct ConsoleTaskData
+    {
+        ConsoleTaskData()
+            : mLastState(MachineState_Null),
+              mDeleteSnapshotInfo(NULL)
+        { }
+
+        MachineState_T mLastState;
+        ComObjPtr<Progress> mProgress;
+
+        // used when deleting online snaphshot
+        void *mDeleteSnapshotInfo;
+    };
+
+    class SaveStateTask;
+    class SnapshotTask;
+    class TakeSnapshotTask;
+    class DeleteSnapshotTask;
+    class RestoreSnapshotTask;
+
+    void i_saveStateHandler(SaveStateTask &aTask);
+
+    // Override some functionality for SessionMachine, this is where the
+    // real action happens (the Machine methods are just dummies).
+    HRESULT saveState(ComPtr<IProgress> &aProgress);
+    HRESULT adoptSavedState(const com::Utf8Str &aSavedStateFile);
+    HRESULT discardSavedState(BOOL aFRemoveFile);
+    HRESULT takeSnapshot(const com::Utf8Str &aName,
+                         const com::Utf8Str &aDescription,
+                         BOOL aPause,
+                         com::Guid &aId,
+                         ComPtr<IProgress> &aProgress);
+    HRESULT deleteSnapshot(const com::Guid &aId,
+                           ComPtr<IProgress> &aProgress);
+    HRESULT deleteSnapshotAndAllChildren(const com::Guid &aId,
+                                         ComPtr<IProgress> &aProgress);
+    HRESULT deleteSnapshotRange(const com::Guid &aStartId,
+                                const com::Guid &aEndId,
+                                ComPtr<IProgress> &aProgress);
+    HRESULT restoreSnapshot(const ComPtr<ISnapshot> &aSnapshot,
+                            ComPtr<IProgress> &aProgress);
+
+    void i_releaseSavedStateFile(const Utf8Str &strSavedStateFile, Snapshot *pSnapshotToIgnore);
+
+    void i_takeSnapshotHandler(TakeSnapshotTask &aTask);
+    static void i_takeSnapshotProgressCancelCallback(void *pvUser);
+    HRESULT i_finishTakingSnapshot(TakeSnapshotTask &aTask, AutoWriteLock &alock, bool aSuccess);
+    HRESULT i_deleteSnapshot(const com::Guid &aStartId,
+                             const com::Guid &aEndId,
+                             BOOL aDeleteAllChildren,
+                             ComPtr<IProgress> &aProgress);
+    void i_deleteSnapshotHandler(DeleteSnapshotTask &aTask);
+    void i_restoreSnapshotHandler(RestoreSnapshotTask &aTask);
+
+    HRESULT i_prepareDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
+                                          const Guid &machineId,
+                                          const Guid &snapshotId,
+                                          bool fOnlineMergePossible,
+                                          MediumLockList *aVMMALockList,
+                                          ComObjPtr<Medium> &aSource,
+                                          ComObjPtr<Medium> &aTarget,
+                                          bool &fMergeForward,
+                                          ComObjPtr<Medium> &pParentForTarget,
+                                          MediumLockList * &aChildrenToReparent,
+                                          bool &fNeedOnlineMerge,
+                                          MediumLockList * &aMediumLockList,
+                                          ComPtr<IToken> &aHDLockToken);
+    void i_cancelDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
+                                      const ComObjPtr<Medium> &aSource,
+                                      MediumLockList *aChildrenToReparent,
+                                      bool fNeedsOnlineMerge,
+                                      MediumLockList *aMediumLockList,
+                                      const ComPtr<IToken> &aHDLockToken,
+                                      const Guid &aMediumId,
+                                      const Guid &aSnapshotId);
+    HRESULT i_onlineMergeMedium(const ComObjPtr<MediumAttachment> &aMediumAttachment,
+                                const ComObjPtr<Medium> &aSource,
+                                const ComObjPtr<Medium> &aTarget,
+                                bool fMergeForward,
+                                const ComObjPtr<Medium> &pParentForTarget,
+                                MediumLockList *aChildrenToReparent,
+                                MediumLockList *aMediumLockList,
+                                ComObjPtr<Progress> &aProgress,
+                                bool *pfNeedsMachineSaveSettings);
+
+    HRESULT i_setMachineState(MachineState_T aMachineState);
+    HRESULT i_updateMachineStateOnClient();
+
+    bool mRemoveSavedState;
+
+    ConsoleTaskData mConsoleTaskData;
+
+    /** client token for this machine */
+    ClientToken *mClientToken;
+
+    int miNATNetworksStarted;
+
+    AUTHLIBRARYCONTEXT mAuthLibCtx;
+};
+
+// SnapshotMachine class
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  @note Notes on locking objects of this class:
+ *  SnapshotMachine shares some data with the primary Machine instance (pointed
+ *  to by the |mPeer| member). In order to provide data consistency it also
+ *  shares its lock handle. This means that whenever you lock a SessionMachine
+ *  instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
+ *  instance is also locked in the same lock mode. Keep it in mind.
+ */
+class ATL_NO_VTABLE SnapshotMachine :
+    public Machine
+{
+public:
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SnapshotMachine, IMachine)
+
+    DECLARE_NOT_AGGREGATABLE(SnapshotMachine)
+
+    DECLARE_PROTECT_FINAL_CONSTRUCT()
+
+    BEGIN_COM_MAP(SnapshotMachine)
+        COM_INTERFACE_ENTRY(ISupportErrorInfo)
+        COM_INTERFACE_ENTRY(IMachine)
+        COM_INTERFACE_ENTRY2(IDispatch, IMachine)
+        VBOX_TWEAK_INTERFACE_ENTRY(IMachine)
+    END_COM_MAP()
+
+    DECLARE_COMMON_CLASS_METHODS(SnapshotMachine)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(SessionMachine *aSessionMachine,
+                 IN_GUID aSnapshotId,
+                 const Utf8Str &aStateFilePath);
+    HRESULT initFromSettings(Machine *aMachine,
+                             const settings::Hardware &hardware,
+                             const settings::Debugging *pDbg,
+                             const settings::Autostart *pAutostart,
+                             const settings::RecordingSettings &recording,
+                             IN_GUID aSnapshotId,
+                             const Utf8Str &aStateFilePath);
+    void uninit();
+
+    // util::Lockable interface
+    RWLockHandle *lockHandle() const;
+
+    // public methods only for internal purposes
+
+    virtual bool i_isSnapshotMachine() const
+    {
+        return true;
+    }
+
+    HRESULT i_onSnapshotChange(Snapshot *aSnapshot);
+
+    // unsafe inline public methods for internal purposes only (ensure there is
+    // a caller and a read lock before calling them!)
+
+    const Guid& i_getSnapshotId() const { return mSnapshotId; }
+
+private:
+
+    Guid mSnapshotId;
+    /** This field replaces mPeer for SessionMachine instances, as having
+     * a peer reference is plain meaningless and causes many subtle problems
+     * with saving settings and the like. */
+    Machine * const mMachine;
+
+    friend class Snapshot;
+};
+
+// third party methods that depend on SnapshotMachine definition
+
+inline const Guid &Machine::i_getSnapshotId() const
+{
+    return (i_isSnapshotMachine())
+                ? static_cast<const SnapshotMachine*>(this)->i_getSnapshotId()
+                : Guid::Empty;
+}
+
+
+#endif /* !MAIN_INCLUDED_MachineImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/MachineImplCloneVM.h b/src/VBox/Main/include/MachineImplCloneVM.h
new file mode 100644
index 00000000..9983911d
--- /dev/null
+++ b/src/VBox/Main/include/MachineImplCloneVM.h
@@ -0,0 +1,63 @@
+/* $Id: MachineImplCloneVM.h $ */
+/** @file
+ * Definition of MachineCloneVM
+ */
+
+/*
+ * Copyright (C) 2011-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
+ */
+
+#ifndef MAIN_INCLUDED_MachineImplCloneVM_h
+#define MAIN_INCLUDED_MachineImplCloneVM_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "MachineImpl.h"
+#include "ProgressImpl.h"
+
+/* Forward declaration of the d-pointer. */
+struct MachineCloneVMPrivate;
+
+class MachineCloneVM
+{
+public:
+    DECLARE_TRANSLATE_METHODS(MachineCloneVM)
+
+    MachineCloneVM(ComObjPtr<Machine> pSrcMachine, ComObjPtr<Machine> pTrgMachine, CloneMode_T mode, const RTCList<CloneOptions_T> &opts);
+    ~MachineCloneVM();
+
+    HRESULT start(IProgress **pProgress);
+
+protected:
+    HRESULT run();
+    void destroy();
+
+    /* d-pointer */
+    MachineCloneVM(MachineCloneVMPrivate &d);
+    MachineCloneVMPrivate *d_ptr;
+
+    friend struct MachineCloneVMPrivate;
+};
+
+#endif /* !MAIN_INCLUDED_MachineImplCloneVM_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
+
diff --git a/src/VBox/Main/include/MachineImplMoveVM.h b/src/VBox/Main/include/MachineImplMoveVM.h
new file mode 100644
index 00000000..f8e8eb8d
--- /dev/null
+++ b/src/VBox/Main/include/MachineImplMoveVM.h
@@ -0,0 +1,146 @@
+/* $Id: MachineImplMoveVM.h $ */
+/** @file
+ * Definition of MachineMoveVM
+ */
+
+/*
+ * Copyright (C) 2011-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
+ */
+
+#ifndef MAIN_INCLUDED_MachineImplMoveVM_h
+#define MAIN_INCLUDED_MachineImplMoveVM_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "MachineImpl.h"
+#include "ProgressImpl.h"
+#include "ThreadTask.h"
+
+/////////////////////////////////////////////////////////////////////////////
+
+enum VBoxFolder_t
+{
+    VBox_UnknownFolderType = 0,
+    VBox_OutsideVMfolder,
+    VBox_SettingFolder,
+    VBox_LogFolder,
+    VBox_StateFolder,
+    VBox_SnapshotFolder
+};
+
+typedef struct
+{
+    bool                    fSnapshot;
+    Utf8Str                 strBaseName;
+    ComPtr<IMedium>         pMedium;
+    uint32_t                uIdx;
+    ULONG                   uWeight;
+} MEDIUMTASKMOVE;
+
+typedef struct
+{
+    RTCList<MEDIUMTASKMOVE> chain;
+    DeviceType_T            devType;
+    bool                    fCreateDiffs;
+    bool                    fAttachLinked;
+} MEDIUMTASKCHAINMOVE;
+
+typedef struct
+{
+    Guid                    snapshotUuid;
+    Utf8Str                 strFile;
+    ULONG                   uWeight;
+} SNAPFILETASKMOVE;
+
+struct fileList_t;
+
+class MachineMoveVM : public ThreadTask
+{
+    std::vector<ComObjPtr<Machine> >        machineList;
+    RTCList<MEDIUMTASKCHAINMOVE>            m_llMedia;
+    RTCList<SNAPFILETASKMOVE>               m_llSaveStateFiles;
+    RTCList<SNAPFILETASKMOVE>               m_llNVRAMFiles;
+    std::map<Utf8Str, MEDIUMTASKMOVE>       m_finalMediaMap;
+    std::map<Utf8Str, SNAPFILETASKMOVE>     m_finalSaveStateFilesMap;
+    std::map<Utf8Str, SNAPFILETASKMOVE>     m_finalNVRAMFilesMap;
+    std::map<VBoxFolder_t, Utf8Str>         m_vmFolders;
+
+    ComObjPtr<Machine>  m_pMachine;
+    ComObjPtr<Progress> m_pProgress;
+    ComObjPtr<Progress> m_pRollBackProgress;
+    Utf8Str             m_targetPath;
+    Utf8Str             m_type;
+    HRESULT             m_result;
+
+public:
+    DECLARE_TRANSLATE_METHODS(MachineMoveVM)
+
+    MachineMoveVM(ComObjPtr<Machine> aMachine,
+                  const com::Utf8Str &aTargetPath,
+                  const com::Utf8Str &aType,
+                  ComObjPtr<Progress> &aProgress)
+        : ThreadTask("TaskMoveVM")
+        , m_pMachine(aMachine)
+        , m_pProgress(aProgress)
+        , m_targetPath(aTargetPath)
+        , m_type(aType.isEmpty() ? "basic" : aType)
+        , m_result(S_OK)
+    {
+    }
+
+    virtual ~MachineMoveVM()
+    {
+    }
+
+    HRESULT init();
+private:
+    static DECLCALLBACK(int) updateProgress(unsigned uPercent, void *pvUser);
+    static DECLCALLBACK(int) copyFileProgress(unsigned uPercentage, void *pvUser);
+    static void i_MoveVMThreadTask(MachineMoveVM *task);
+
+public:
+    void handler()
+    {
+        i_MoveVMThreadTask(this);
+    }
+
+private:
+    HRESULT createMachineList(const ComPtr<ISnapshot> &pSnapshot);
+    inline HRESULT queryBaseName(const ComPtr<IMedium> &pMedium, Utf8Str &strBaseName) const;
+    HRESULT queryMediaForAllStates();
+    void updateProgressStats(MEDIUMTASKCHAINMOVE &mtc, ULONG &uCount, ULONG &uTotalWeight) const;
+    HRESULT addSaveState(const ComObjPtr<Machine> &machine);
+    HRESULT addNVRAM(const ComObjPtr<Machine> &machine);
+    void printStateFile(settings::SnapshotsList &snl);
+    HRESULT getFilesList(const Utf8Str &strRootFolder, fileList_t &filesList);
+    HRESULT getFolderSize(const Utf8Str &strRootFolder, uint64_t &size);
+    HRESULT deleteFiles(const RTCList<Utf8Str> &listOfFiles);
+    void updatePathsToStateFiles(const Utf8Str &sourcePath, const Utf8Str &targetPath);
+    void updatePathsToNVRAMFiles(const Utf8Str &sourcePath, const Utf8Str &targetPath);
+    HRESULT moveAllDisks(const std::map<Utf8Str, MEDIUMTASKMOVE> &listOfDisks, const Utf8Str &strTargetFolder = Utf8Str::Empty);
+    HRESULT restoreAllDisks(const std::map<Utf8Str, MEDIUMTASKMOVE> &listOfDisks);
+    HRESULT isMediumTypeSupportedForMoving(const ComPtr<IMedium> &pMedium);
+};
+
+#endif /* !MAIN_INCLUDED_MachineImplMoveVM_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
+
diff --git a/src/VBox/Main/include/MachineLaunchVMCommonWorker.h b/src/VBox/Main/include/MachineLaunchVMCommonWorker.h
new file mode 100644
index 00000000..20b0a355
--- /dev/null
+++ b/src/VBox/Main/include/MachineLaunchVMCommonWorker.h
@@ -0,0 +1,49 @@
+/* $Id: MachineLaunchVMCommonWorker.h $ */
+/** @file
+ * VirtualBox Main - VM process launcher helper for VBoxSVC & VBoxSDS.
+ */
+
+/*
+ * Copyright (C) 2011-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
+ */
+
+#ifndef MAIN_INCLUDED_MachineLaunchVMCommonWorker_h
+#define MAIN_INCLUDED_MachineLaunchVMCommonWorker_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <vector>
+#include "VirtualBoxBase.h"
+
+int MachineLaunchVMCommonWorker(const Utf8Str &aNameOrId,
+                                const Utf8Str &aComment,
+                                const Utf8Str &aFrontend,
+                                const std::vector<com::Utf8Str> &aEnvironmentChanges,
+                                const Utf8Str &aExtraArg,
+                                const Utf8Str &aFilename,
+                                uint32_t      aFlags,
+                                void         *aExtraData,
+                                RTPROCESS     &aPid);
+
+#endif /* !MAIN_INCLUDED_MachineLaunchVMCommonWorker_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
+
diff --git a/src/VBox/Main/include/Makefile.kup b/src/VBox/Main/include/Makefile.kup
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/src/VBox/Main/include/Makefile.kup
diff --git a/src/VBox/Main/include/Matching.h b/src/VBox/Main/include/Matching.h
new file mode 100644
index 00000000..ba5540ee
--- /dev/null
+++ b/src/VBox/Main/include/Matching.h
@@ -0,0 +1,540 @@
+/* $Id: Matching.h $ */
+/** @file
+ * Declaration of template classes that provide simple API to
+ * do matching between values and value filters constructed from strings.
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_Matching_h
+#define MAIN_INCLUDED_Matching_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/com/string.h>
+
+#include <list>
+#include <limits>
+#include <algorithm>
+
+// min and max don't allow us to use numeric_limits::min() and max()
+#if defined (_MSC_VER)
+#undef min
+#undef max
+#endif
+
+namespace matching
+{
+
+using namespace std;
+using namespace com;
+
+class ParsedFilter_base
+{
+public:
+
+    ParsedFilter_base() : mValid (false), mNull (true), mErrorPosition (0) {};
+
+    /**
+     * Returns @c true if the filter is valid, @c false otherwise.
+     */
+    bool isValid() const { return mNull || mValid; }
+    bool isNull() const { return mNull; }
+
+    /**
+     *  Returns the error position from the beginning of the filter
+     *  string if #isValid() is false. Positions are zero-based.
+     */
+    size_t errorPosition() const { return mErrorPosition; }
+
+protected:
+
+    /**
+     *  Returns @c true if current isNull() and isValid() values make further
+     *  detailed matching meaningful, otherwise returns @c false.
+     *  Must be called as a first method of every isMatch() implementation,
+     *  so that isMatch() will immediately return @c false if isPreMatch() returns
+     *  false.
+     */
+    bool isPreMatch() const
+    {
+        if (isNull() || !isValid())
+            return false;
+        return true;
+    }
+
+    bool mValid : 1;
+    bool mNull : 1;
+    size_t mErrorPosition;
+};
+
+class ParsedIntervalFilter_base : public ParsedFilter_base
+{
+public:
+    virtual ~ParsedIntervalFilter_base() { /* Make VC++ 14.2 happy */ }
+
+protected:
+
+    enum Mode { Single, Start, End };
+
+    union Widest
+    {
+        int64_t ll;
+        uint64_t ull;
+    };
+
+    struct Limits
+    {
+        Widest min;
+        Widest max;
+    };
+
+    ParsedIntervalFilter_base() {}
+
+    /**
+     *  Called by #parse when a value token is encountered.
+     *  This method can modify mNull, mValid and mErrorPosition when
+     *  appropriate. Parsing stops if mValid is false after this method
+     *  returns (mErrorPosition most point to the error position in this case).
+     */
+    virtual void parseValue (const char *aFilter, size_t aStart, size_t aEnd,
+                             Mode aMode) = 0;
+
+    static void parse (const char *aFilter,
+                       ParsedIntervalFilter_base *that);
+
+    static size_t parseValue (const char *aFilter, size_t aStart, size_t aEnd,
+                              bool aIsSigned, const Limits &aLimits,
+                              Widest &val);
+};
+
+/**
+ *  Represents a parsed interval filter.
+ *  The string format is:
+ *      "int:(\<m\>|([\<m\>]-[\<n\>]))|(\<m\>|([\<m\>]-[\<n\>]))+"
+ *  where \<m\> and \<n\> are numbers in the decimal, hex (0xNNN) or octal
+ *  (0NNN) form, and \<m\> \< \<n\>. Spaces are allowed around \<m\> and \<n\>.
+ *
+ *  @tparam T    type of values to match. Must be a fundamental integer type.
+ */
+template <class T>
+class ParsedIntervalFilter : public ParsedIntervalFilter_base
+{
+    typedef ParsedIntervalFilter_base Base;
+    typedef numeric_limits <T> Lim;
+
+    typedef std::list <T> List;
+    typedef std::pair <T, T> Pair;
+    typedef std::list <Pair> PairList;
+
+public:
+
+    ParsedIntervalFilter() {}
+
+    ParsedIntervalFilter (const Bstr &aFilter) { Base::parse (Utf8Str (aFilter), this); }
+
+    ParsedIntervalFilter &operator= (const Bstr &aFilter)
+    {
+        mValues.clear();
+        mIntervals.clear();
+        Base::parse (Utf8Str (aFilter), this);
+        return *this;
+    }
+
+    bool isMatch (const T &aValue) const
+    {
+        if (!isPreMatch())
+            return false;
+
+        {
+            typename List::const_iterator it =
+                std::find (mValues.begin(), mValues.end(), aValue);
+            if (it != mValues.end())
+                return true;
+        }
+
+        for (typename PairList::const_iterator it = mIntervals.begin();
+             it != mIntervals.end(); ++ it)
+        {
+            if ((*it).first <= aValue &&
+                aValue <= (*it).second)
+                return true;
+        }
+
+        return false;
+    }
+
+protected:
+
+    struct Limits : public Base::Limits
+    {
+        Limits()
+        {
+            if (Lim::is_signed)
+            {
+                min.ll = (int64_t) Lim::min();
+                max.ll = (int64_t) Lim::max();
+            }
+            else
+            {
+                min.ull = (uint64_t) Lim::min();
+                max.ull = (uint64_t) Lim::max();
+            }
+        }
+
+        static T toValue (const Widest &aWidest)
+        {
+            if (Lim::is_signed)
+                return (T) aWidest.ll;
+            else
+                return (T) aWidest.ull;
+        }
+    };
+
+    virtual void parseValue (const char *aFilter, size_t aStart, size_t aEnd,
+                             Mode aMode)
+    {
+        AssertReturn (Lim::is_integer, (void) 0);
+        AssertReturn (
+            (Lim::is_signed && Lim::digits <= numeric_limits <int64_t>::digits) ||
+            (!Lim::is_signed && Lim::digits <= numeric_limits <uint64_t>::digits),
+            (void) 0);
+
+        Limits limits;
+        Widest val;
+        size_t parsed = aEnd;
+
+        if (aStart != aEnd)
+            parsed = Base::parseValue (aFilter, aStart, aEnd,
+                                       Lim::is_signed, limits, val);
+
+        if (parsed != aEnd)
+        {
+            mValid = false;
+            mErrorPosition = parsed;
+            return;
+        }
+
+        switch (aMode)
+        {
+            /// @todo (dmik): future optimizations:
+            //  1) join intervals when they overlap
+            //  2) ignore single values that are within any existing interval
+            case Base::Single:
+            {
+                if (aStart == aEnd)
+                {
+                    // an empty string (contains only spaces after "int:")
+                    mValid = false;
+                    mErrorPosition = aEnd;
+                    AssertReturn (!mValues.size() && !mIntervals.size(), (void) 0);
+                    break;
+                }
+                mValues.push_back (limits.toValue (val));
+                break;
+            }
+            case Base::Start:
+            {
+                // aStart == aEnd means smth. like "-[NNN]"
+                T m = aStart == aEnd ? limits.toValue (limits.min)
+                                     : limits.toValue (val);
+                mIntervals.push_back (Pair (m, m));
+                break;
+            }
+            case Base::End:
+            {
+                // aStart == aEnd means smth. like "[NNN]-"
+                T n = aStart == aEnd ? limits.toValue (limits.max)
+                                     : limits.toValue (val);
+                if (n < mIntervals.back().first)
+                {
+                    // error at the beginning of N
+                    mValid = false;
+                    mErrorPosition = aStart;
+                    break;
+                }
+                mIntervals.back().second = n;
+                break;
+            }
+        }
+    }
+
+    std::list <T> mValues;
+    std::list <std::pair <T, T> > mIntervals;
+};
+
+/**
+ *  Represents a boolean filter.
+ *  The string format is: "true|false|yes|no|1|0" or an empty string (any match).
+ */
+
+class ParsedBoolFilter : public ParsedFilter_base
+{
+public:
+
+    ParsedBoolFilter() : mValue (false), mValueAny (false) {}
+
+    ParsedBoolFilter (const Bstr &aFilter) { parse (aFilter); }
+
+    ParsedBoolFilter &operator= (const Bstr &aFilter)
+    {
+        parse (aFilter);
+        return *this;
+    }
+
+    bool isMatch (const bool aValue) const
+    {
+        if (!isPreMatch())
+            return false;
+
+        return mValueAny || mValue == aValue;
+    }
+
+    bool isMatch (const BOOL aValue) const
+    {
+        return isMatch (bool (aValue == TRUE));
+    }
+
+private:
+
+    void parse (const Bstr &aFilter);
+
+    bool mValue : 1;
+    bool mValueAny : 1;
+};
+
+class ParsedRegexpFilter_base : public ParsedFilter_base
+{
+protected:
+
+    ParsedRegexpFilter_base (bool aDefIgnoreCase = false,
+                             size_t aMinLen = 0, size_t aMaxLen = 0)
+        : mIgnoreCase (aDefIgnoreCase)
+        , mMinLen (aMinLen)
+        , mMaxLen (aMaxLen)
+        {}
+
+    ParsedRegexpFilter_base (const Bstr &aFilter, bool aDefIgnoreCase = false,
+                             size_t aMinLen = 0, size_t aMaxLen = 0)
+        : mIgnoreCase (aDefIgnoreCase)
+        , mMinLen (aMinLen)
+        , mMaxLen (aMaxLen)
+    {
+        parse (aFilter);
+    }
+
+    ParsedRegexpFilter_base &operator= (const Bstr &aFilter)
+    {
+        parse (aFilter);
+        return *this;
+    }
+
+    bool isMatch (const Bstr &aValue) const;
+
+private:
+
+    void parse (const Bstr &aFilter);
+
+    bool mIgnoreCase : 1;
+
+    size_t mMinLen;
+    size_t mMaxLen;
+
+    Bstr mSimple;
+};
+
+/**
+ *  Represents a parsed regexp filter.
+ *
+ *  The string format is: "rx:\<regexp\>" or "\<string\>"
+ *  where \<regexp\> is a valid regexp and \<string\> is the exact match.
+ *
+ *  @tparam Conv
+ *      class that must define a public static function
+ *      <tt>Bstr toBstr (T aValue)</tt>, where T is the
+ *      type of values that should be accepted by #isMatch().
+ *      This function is used to get the string representation of T
+ *      for regexp matching.
+ *  @tparam aIgnoreCase
+ *      true if the case insensitive comparison should be done by default
+ *      and false otherwise
+ *  @tparam aMinLen
+ *      minimum string length, or 0 if not limited.
+ *      Used only when the filter string represents the exact match.
+ *  @tparam aMaxLen
+ *      maximum string length, or 0 if not limited.
+ *      Used only when the filter string represents the exact match.
+ */
+template <class Conv, bool aIgnoreCase, size_t aMinLen = 0, size_t aMaxLen = 0>
+class ParsedRegexpFilter : public ParsedRegexpFilter_base
+{
+public:
+
+    enum { IgnoreCase = aIgnoreCase, MinLen = aMinLen, MaxLen = aMaxLen };
+
+    ParsedRegexpFilter() : ParsedRegexpFilter_base (IgnoreCase, MinLen, MaxLen) {}
+
+    ParsedRegexpFilter (const Bstr &aFilter)
+        : ParsedRegexpFilter_base (aFilter, IgnoreCase, MinLen, MaxLen) {}
+
+    ParsedRegexpFilter &operator= (const Bstr &aFilter)
+    {
+        ParsedRegexpFilter_base::operator= (aFilter);
+        return *this;
+    }
+
+    template <class T>
+    bool isMatch (const T &aValue) const
+    {
+        if (!this->isPreMatch())
+            return false;
+
+        return ParsedRegexpFilter_base::isMatch (Conv::toBstr (aValue));
+    }
+
+protected:
+};
+
+/**
+ *  Joins two filters into one.
+ *  Only one filter is active (i.e. used for matching or for error reporting)
+ *  at any given time. The active filter is chosen every time when a new
+ *  filter string is assigned to an instance of this class -- the filter
+ *  for which isNull() = false after parsing the string becomes the active
+ *  one (F1 is tried first).
+ *
+ *  Both filters must have <tt>bool isMatch(const T&)</tt> methods where T is
+ *  the same type as used in #isMatch().
+ *
+ *  @tparam F1  first filter class
+ *  @tparam F2  second filter class
+ */
+template <class F1, class F2>
+class TwoParsedFilters
+{
+public:
+
+    TwoParsedFilters() {}
+
+    TwoParsedFilters (const Bstr &aFilter)
+    {
+        mFilter1 = aFilter;
+        if (mFilter1.isNull())
+            mFilter2 = aFilter;
+    }
+
+    TwoParsedFilters &operator= (const Bstr &aFilter)
+    {
+        mFilter1 = aFilter;
+        if (mFilter1.isNull())
+            mFilter2 = aFilter;
+        else
+            mFilter2 = F2(); // reset to null
+        return *this;
+    }
+
+    template <class T>
+    bool isMatch (const T &aValue) const
+    {
+        return mFilter1.isMatch (aValue) || mFilter2.isMatch (aValue);
+    }
+
+    bool isValid() const { return isNull() || (mFilter1.isValid() && mFilter2.isValid()); }
+
+    bool isNull() const { return mFilter1.isNull() && mFilter2.isNull(); }
+
+    size_t errorPosition() const
+    {
+        return !mFilter1.isValid() ? mFilter1.errorPosition() :
+               !mFilter2.isValid() ? mFilter2.errorPosition() : 0;
+    }
+
+    const F1 &first() const { return mFilter1; }
+    const F2 &second() const { return mFilter2; }
+
+private:
+
+    F1 mFilter1;
+    F2 mFilter2;
+};
+
+/**
+ *  Inherits from the given parsed filter class and keeps the string used to
+ *  construct the filter as a member.
+ *
+ *  @tparam F   parsed filter class
+ */
+template <class F>
+class Matchable : public F
+{
+public:
+
+    Matchable() {}
+
+    /**
+     *  Creates a new parsed filter from the given filter string.
+     *  If the string format is invalid, #isValid() will return false.
+     */
+    Matchable (const Bstr &aString)
+        : F (aString), mString (aString) {}
+
+    Matchable (CBSTR aString)
+        : F (Bstr (aString)), mString (aString) {}
+
+    /**
+     *  Assigns a new filter string to this object and recreates the parser.
+     *  If the string format is invalid, #isValid() will return false.
+     */
+    Matchable &operator= (const Bstr &aString)
+    {
+        F::operator= (aString);
+        mString = aString;
+        return *this;
+    }
+
+    Matchable &operator= (CBSTR aString)
+    {
+        F::operator= (Bstr (aString));
+        mString = aString;
+        return *this;
+    }
+
+    /**
+     *  Returns the filter string allowing to use the instance where
+     *  Str can be used.
+     */
+    operator const Bstr&() const { return mString; }
+
+    /** Returns the filter string */
+    const Bstr& string() const { return mString; }
+
+private:
+
+    Bstr mString;
+};
+
+} /* namespace matching */
+
+#endif /* !MAIN_INCLUDED_Matching_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/MediumAttachmentImpl.h b/src/VBox/Main/include/MediumAttachmentImpl.h
new file mode 100644
index 00000000..b3568aa7
--- /dev/null
+++ b/src/VBox/Main/include/MediumAttachmentImpl.h
@@ -0,0 +1,146 @@
+/* $Id: MediumAttachmentImpl.h $ */
+/** @file
+ *
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_MediumAttachmentImpl_h
+#define MAIN_INCLUDED_MediumAttachmentImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "MediumAttachmentWrap.h"
+
+class ATL_NO_VTABLE MediumAttachment :
+    public MediumAttachmentWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(MediumAttachment)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Machine *aParent,
+                 Medium *aMedium,
+                 const Utf8Str &aControllerName,
+                 LONG aPort,
+                 LONG aDevice,
+                 DeviceType_T aType,
+                 bool aImplicit,
+                 bool aPassthrough,
+                 bool aTempEject,
+                 bool aNonRotational,
+                 bool aDiscard,
+                 bool aHotPluggable,
+                 const Utf8Str &strBandwidthGroup);
+    HRESULT initCopy(Machine *aParent, MediumAttachment *aThat);
+    void uninit();
+
+    // public internal methods
+    void i_rollback();
+    void i_commit();
+
+    // unsafe public methods for internal purposes only (ensure there is
+    // a caller and a read lock before calling them!)
+    bool i_isImplicit() const;
+    void i_setImplicit(bool aImplicit);
+
+    const ComObjPtr<Medium>& i_getMedium() const;
+    const Utf8Str &i_getControllerName() const;
+    LONG i_getPort() const;
+    LONG i_getDevice() const;
+    DeviceType_T i_getType() const;
+    bool i_getPassthrough() const;
+    bool i_getTempEject() const;
+    bool i_getNonRotational() const;
+    bool i_getDiscard() const;
+    Utf8Str& i_getBandwidthGroup() const;
+    bool i_getHotPluggable() const;
+
+    bool i_matches(const Utf8Str &aControllerName, LONG aPort, LONG aDevice);
+
+    /** Must be called from under this object's write lock. */
+    void i_updateName(const Utf8Str &aName);
+
+    /** Must be called from under this object's write lock. */
+    void i_updateMedium(const ComObjPtr<Medium> &aMedium);
+
+    /** Must be called from under this object's write lock. */
+    void i_updatePassthrough(bool aPassthrough);
+
+    /** Must be called from under this object's write lock. */
+    void i_updateTempEject(bool aTempEject);
+
+    /** Must be called from under this object's write lock. */
+    void i_updateNonRotational(bool aNonRotational);
+
+    /** Must be called from under this object's write lock. */
+    void i_updateDiscard(bool aDiscard);
+
+    /** Must be called from under this object's write lock. */
+    void i_updateEjected();
+
+    /** Must be called from under this object's write lock. */
+    void i_updateBandwidthGroup(const Utf8Str &aBandwidthGroup);
+
+    void i_updateParentMachine(Machine * const pMachine);
+
+    /** Must be called from under this object's write lock. */
+    void i_updateHotPluggable(bool aHotPluggable);
+
+    /** Construct a unique and somewhat descriptive name for logging. */
+    void i_updateLogName(void);
+
+    /** Get a unique and somewhat descriptive name for logging. */
+    const char *i_getLogName(void) const { return mLogName.c_str(); }
+
+private:
+
+    // Wrapped IMediumAttachment properties
+    HRESULT getMachine(ComPtr<IMachine> &aMachine);
+    HRESULT getMedium(ComPtr<IMedium> &aHardDisk);
+    HRESULT getController(com::Utf8Str &aController);
+    HRESULT getPort(LONG *aPort);
+    HRESULT getDevice(LONG *aDevice);
+    HRESULT getType(DeviceType_T *aType);
+    HRESULT getPassthrough(BOOL *aPassthrough);
+    HRESULT getTemporaryEject(BOOL *aTemporaryEject);
+    HRESULT getIsEjected(BOOL *aEjected);
+    HRESULT getDiscard(BOOL *aDiscard);
+    HRESULT getNonRotational(BOOL *aNonRotational);
+    HRESULT getBandwidthGroup(ComPtr<IBandwidthGroup> &aBandwidthGroup);
+    HRESULT getHotPluggable(BOOL *aHotPluggable);
+
+    struct Data;
+    Data *m;
+
+    Utf8Str mLogName;                   /**< For logging purposes */
+};
+
+#endif /* !MAIN_INCLUDED_MediumAttachmentImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/MediumFormatImpl.h b/src/VBox/Main/include/MediumFormatImpl.h
new file mode 100644
index 00000000..625583c4
--- /dev/null
+++ b/src/VBox/Main/include/MediumFormatImpl.h
@@ -0,0 +1,125 @@
+/* $Id: MediumFormatImpl.h $ */
+/** @file
+ * MediumFormat COM class implementation
+ */
+
+/*
+ * Copyright (C) 2008-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
+ */
+
+#ifndef MAIN_INCLUDED_MediumFormatImpl_h
+#define MAIN_INCLUDED_MediumFormatImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "MediumFormatWrap.h"
+
+
+struct VDBACKENDINFO;
+
+/**
+ * The MediumFormat class represents the backend used to store medium data
+ * (IMediumFormat interface).
+ *
+ * @note Instances of this class are permanently caller-referenced by Medium
+ * objects (through addCaller()) so that an attempt to uninitialize or delete
+ * them before all Medium objects are uninitialized will produce an endless
+ * wait!
+ */
+class ATL_NO_VTABLE MediumFormat :
+    public MediumFormatWrap
+{
+public:
+
+    struct Property
+    {
+        Utf8Str     strName;
+        Utf8Str     strDescription;
+        DataType_T  type;
+        ULONG       flags;
+        Utf8Str     strDefaultValue;
+    };
+
+    typedef std::vector<Property> PropertyArray;
+    typedef std::vector<com::Utf8Str> StrArray;
+
+    DECLARE_COMMON_CLASS_METHODS(MediumFormat)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(const VDBACKENDINFO *aVDInfo);
+    void uninit();
+
+    // public methods for internal purposes only
+    // (ensure there is a caller and a read lock before calling them!)
+
+    /** Const, no need to lock */
+    const Utf8Str &i_getId() const { return m.strId; }
+    /** Const, no need to lock */
+    const Utf8Str &i_getName() const { return m.strName; }
+    /** Const, no need to lock */
+    const StrArray &i_getFileExtensions() const { return m.maFileExtensions; }
+    /** Const, no need to lock */
+    MediumFormatCapabilities_T i_getCapabilities() const { return m.capabilities; }
+    /** Const, no need to lock */
+    const PropertyArray &i_getProperties() const { return m.maProperties; }
+
+private:
+
+    // wrapped IMediumFormat properties
+    HRESULT getId(com::Utf8Str &aId);
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT getCapabilities(std::vector<MediumFormatCapabilities_T> &aCapabilities);
+
+    // wrapped IMediumFormat methods
+    HRESULT describeFileExtensions(std::vector<com::Utf8Str> &aExtensions,
+                                   std::vector<DeviceType_T> &aTypes);
+    HRESULT describeProperties(std::vector<com::Utf8Str> &aNames,
+                               std::vector<com::Utf8Str> &aDescriptions,
+                               std::vector<DataType_T> &aTypes,
+                               std::vector<ULONG> &aFlags,
+                               std::vector<com::Utf8Str> &aDefaults);
+
+    // types
+    typedef std::vector<DeviceType_T> DeviceTypeArray;
+
+    // data
+    struct Data
+    {
+        Data() : capabilities((MediumFormatCapabilities_T)0) {}
+
+        const Utf8Str        strId;
+        const Utf8Str        strName;
+        const StrArray       maFileExtensions;
+        const DeviceTypeArray maDeviceTypes;
+        const MediumFormatCapabilities_T capabilities;
+        const PropertyArray  maProperties;
+    };
+
+    Data m;
+};
+
+#endif /* !MAIN_INCLUDED_MediumFormatImpl_h */
+
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/MediumIOImpl.h b/src/VBox/Main/include/MediumIOImpl.h
new file mode 100644
index 00000000..c6e13976
--- /dev/null
+++ b/src/VBox/Main/include/MediumIOImpl.h
@@ -0,0 +1,92 @@
+/* $Id: MediumIOImpl.h $ */
+/** @file
+ * VirtualBox COM class implementation - MediumIO.
+ */
+
+/*
+ * Copyright (C) 2018-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
+ */
+
+#ifndef MAIN_INCLUDED_MediumIOImpl_h
+#define MAIN_INCLUDED_MediumIOImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "MediumIOWrap.h"
+#include "VirtualBoxBase.h"
+#include "AutoCaller.h"
+
+class ATL_NO_VTABLE MediumIO :
+    public MediumIOWrap
+{
+public:
+    /** @name Dummy/standard constructors and destructors.
+     * @{ */
+    DECLARE_COMMON_CLASS_METHODS(MediumIO)
+    HRESULT FinalConstruct();
+    void    FinalRelease();
+    /** @} */
+
+    /** @name Initializer & uninitializer.
+     * @{ */
+    HRESULT initForMedium(Medium *pMedium, VirtualBox *pVirtualBox, bool fWritable,
+                          com::Utf8Str const &rStrKeyId, com::Utf8Str const &rStrPassword);
+    void    uninit();
+    /** @} */
+
+private:
+    /** @name Wrapped IMediumIO properties
+     * @{ */
+    HRESULT getMedium(ComPtr<IMedium> &a_rPtrMedium);
+    HRESULT getWritable(BOOL *a_fWritable);
+    HRESULT getExplorer(ComPtr<IVFSExplorer> &a_rPtrExplorer);
+    /** @} */
+
+    /** @name Wrapped IMediumIO methods
+     * @{ */
+    HRESULT read(LONG64 a_off, ULONG a_cbRead, std::vector<BYTE> &a_rData);
+    HRESULT write(LONG64 a_off, const std::vector<BYTE> &a_rData, ULONG *a_pcbWritten);
+    HRESULT formatFAT(BOOL a_fQuick);
+    HRESULT initializePartitionTable(PartitionTableType_T a_enmFormat, BOOL a_fWholeDiskInOneEntry);
+    HRESULT convertToStream(const com::Utf8Str &aFormat,
+                            const std::vector<MediumVariant_T> &aVariant,
+                            ULONG aBufferSize,
+                            ComPtr<IDataStream> &aStream,
+                            ComPtr<IProgress> &aProgress);
+    HRESULT close();
+    /** @} */
+
+    /** @name Internal workers.
+     *  @{ */
+    void    i_close();
+    /** @} */
+
+    struct Data;
+    Data *m;
+
+    class StreamTask;
+    friend class StreamTask;
+};
+
+#endif /* !MAIN_INCLUDED_MediumIOImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
+
diff --git a/src/VBox/Main/include/MediumImpl.h b/src/VBox/Main/include/MediumImpl.h
new file mode 100644
index 00000000..d0292141
--- /dev/null
+++ b/src/VBox/Main/include/MediumImpl.h
@@ -0,0 +1,474 @@
+/* $Id: MediumImpl.h $ */
+/** @file
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2008-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
+ */
+
+#ifndef MAIN_INCLUDED_MediumImpl_h
+#define MAIN_INCLUDED_MediumImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/vd.h>
+#include "MediumWrap.h"
+#include "VirtualBoxBase.h"
+#include "AutoCaller.h"
+#include "SecretKeyStore.h"
+class Progress;
+class MediumFormat;
+class MediumLockList;
+struct MediumCryptoFilterSettings;
+
+namespace settings
+{
+    struct Medium;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Medium component class for all media types.
+ */
+class ATL_NO_VTABLE Medium :
+    public MediumWrap
+{
+public:
+    DECLARE_COMMON_CLASS_METHODS(Medium)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    enum HDDOpenMode  { OpenReadWrite, OpenReadOnly };
+                // have to use a special enum for the overloaded init() below;
+                // can't use AccessMode_T from XIDL because that's mapped to an int
+                // and would be ambiguous
+
+    // public initializer/uninitializer for internal purposes only
+
+    // initializer to create empty medium (VirtualBox::CreateMedium())
+    HRESULT init(VirtualBox *aVirtualBox,
+                 const Utf8Str &aFormat,
+                 const Utf8Str &aLocation,
+                 const Guid &uuidMachineRegistry,
+                 const DeviceType_T aDeviceType);
+
+    // initializer for opening existing media
+    // (VirtualBox::OpenMedium(); Machine::AttachDevice())
+    HRESULT init(VirtualBox *aVirtualBox,
+                 const Utf8Str &aLocation,
+                 HDDOpenMode enOpenMode,
+                 bool fForceNewUuid,
+                 DeviceType_T aDeviceType);
+
+    // initializer used when loading settings
+    HRESULT initOne(Medium *aParent,
+                    DeviceType_T aDeviceType,
+                    const Guid &uuidMachineRegistry,
+                    const Utf8Str &strMachineFolder,
+                    const settings::Medium &data);
+    static HRESULT initFromSettings(VirtualBox *aVirtualBox,
+                                    DeviceType_T aDeviceType,
+                                    const Guid &uuidMachineRegistry,
+                                    const Utf8Str &strMachineFolder,
+                                    const settings::Medium &data,
+                                    AutoWriteLock &mediaTreeLock,
+                                    std::list<std::pair<Guid, DeviceType_T> > &uIdsForNotify);
+
+    // initializer for host floppy/DVD
+    HRESULT init(VirtualBox *aVirtualBox,
+                 DeviceType_T aDeviceType,
+                 const Utf8Str &aLocation,
+                 const Utf8Str &aDescription = Utf8Str::Empty);
+
+    void uninit();
+
+    void i_deparent();
+    void i_setParent(const ComObjPtr<Medium> &pParent);
+
+    // unsafe methods for internal purposes only (ensure there is
+    // a caller and a read lock before calling them!)
+    const ComObjPtr<Medium>& i_getParent() const;
+    const MediaList& i_getChildren() const;
+
+    const Guid& i_getId() const;
+    MediumState_T i_getState() const;
+    MediumVariant_T i_getVariant() const;
+    bool i_isHostDrive() const;
+    bool i_isClosing() const;
+    const Utf8Str& i_getLocationFull() const;
+    const Utf8Str& i_getFormat() const;
+    const ComObjPtr<MediumFormat> & i_getMediumFormat() const;
+    bool i_isMediumFormatFile() const;
+    uint64_t i_getSize() const;
+    uint64_t i_getLogicalSize() const;
+    DeviceType_T i_getDeviceType() const;
+    MediumType_T i_getType() const;
+    Utf8Str i_getName();
+
+    /* handles caller/locking itself */
+    bool i_addRegistry(const Guid &id);
+    bool i_addRegistryNoCallerCheck(const Guid &id);
+    /* handles caller/locking itself, caller is responsible for tree lock */
+    bool i_addRegistryAll(const Guid &id);
+    /* handles caller/locking itself */
+    bool i_removeRegistry(const Guid& id);
+    /* handles caller/locking itself, caller is responsible for tree lock */
+    bool i_removeRegistryAll(const Guid& id);
+    bool i_isInRegistry(const Guid& id);
+    bool i_getFirstRegistryMachineId(Guid &uuid) const;
+    void i_markRegistriesModified();
+
+    HRESULT i_setPropertyDirect(const Utf8Str &aName, const Utf8Str &aValue);
+
+    HRESULT i_addBackReference(const Guid &aMachineId,
+                               const Guid &aSnapshotId = Guid::Empty);
+    HRESULT i_removeBackReference(const Guid &aMachineId,
+                                  const Guid &aSnapshotId = Guid::Empty);
+
+
+    const Guid* i_getFirstMachineBackrefId() const;
+    const Guid* i_getAnyMachineBackref(const Guid &aId) const;
+    const Guid* i_getFirstMachineBackrefSnapshotId() const;
+    size_t i_getMachineBackRefCount() const;
+
+#ifdef DEBUG
+    void i_dumpBackRefs();
+#endif
+
+    HRESULT i_updatePath(const Utf8Str &strOldPath, const Utf8Str &strNewPath);
+
+    /* handles caller/locking itself */
+    ComObjPtr<Medium> i_getBase(uint32_t *aLevel = NULL);
+    /* handles caller/locking itself */
+    uint32_t i_getDepth();
+
+    bool i_isReadOnly();
+    void i_updateId(const Guid &id);
+
+    void i_saveSettingsOne(settings::Medium &data,
+                           const Utf8Str &strHardDiskFolder);
+    HRESULT i_saveSettings(settings::Medium &data,
+                           const Utf8Str &strHardDiskFolder);
+
+    HRESULT i_createMediumLockList(bool fFailIfInaccessible,
+                                   Medium *pToLock,
+                                   bool fMediumLockWriteAll,
+                                   Medium *pToBeParent,
+                                   MediumLockList &mediumLockList);
+
+    HRESULT i_createDiffStorage(ComObjPtr<Medium> &aTarget,
+                                MediumVariant_T aVariant,
+                                MediumLockList *pMediumLockList,
+                                ComObjPtr<Progress> *aProgress,
+                                bool aWait,
+                                bool aNotify);
+    Utf8Str i_getPreferredDiffFormat();
+    MediumVariant_T i_getPreferredDiffVariant();
+
+    HRESULT i_close(AutoCaller &autoCaller);
+    HRESULT i_unlockRead(MediumState_T *aState);
+    HRESULT i_unlockWrite(MediumState_T *aState);
+    HRESULT i_deleteStorage(ComObjPtr<Progress> *aProgress, bool aWait, bool aNotify);
+    HRESULT i_markForDeletion();
+    HRESULT i_unmarkForDeletion();
+    HRESULT i_markLockedForDeletion();
+    HRESULT i_unmarkLockedForDeletion();
+
+    HRESULT i_queryPreferredMergeDirection(const ComObjPtr<Medium> &pOther,
+                                           bool &fMergeForward);
+
+    HRESULT i_prepareMergeTo(const ComObjPtr<Medium> &pTarget,
+                             const Guid *aMachineId,
+                             const Guid *aSnapshotId,
+                             bool fLockMedia,
+                             bool &fMergeForward,
+                             ComObjPtr<Medium> &pParentForTarget,
+                             MediumLockList * &aChildrenToReparent,
+                             MediumLockList * &aMediumLockList);
+    HRESULT i_mergeTo(const ComObjPtr<Medium> &pTarget,
+                      bool fMergeForward,
+                      const ComObjPtr<Medium> &pParentForTarget,
+                      MediumLockList *aChildrenToReparent,
+                      MediumLockList *aMediumLockList,
+                      ComObjPtr<Progress> *aProgress,
+                      bool aWait,
+                      bool aNotify);
+    void i_cancelMergeTo(MediumLockList *aChildrenToReparent,
+                       MediumLockList *aMediumLockList);
+
+    HRESULT i_resize(uint64_t aLogicalSize,
+                     MediumLockList *aMediumLockList,
+                     ComObjPtr<Progress> *aProgress,
+                     bool aWait,
+                     bool aNotify);
+
+    HRESULT i_fixParentUuidOfChildren(MediumLockList *pChildrenToReparent);
+
+    HRESULT i_addRawToFss(const char *aFilename, SecretKeyStore *pKeyStore, RTVFSFSSTREAM hVfsFssDst,
+                          const ComObjPtr<Progress> &aProgress, bool fSparse);
+
+    HRESULT i_exportFile(const char *aFilename,
+                         const ComObjPtr<MediumFormat> &aFormat,
+                         MediumVariant_T aVariant,
+                         SecretKeyStore *pKeyStore,
+                         RTVFSIOSTREAM hVfsIosDst,
+                         const ComObjPtr<Progress> &aProgress);
+    HRESULT i_importFile(const char *aFilename,
+                         const ComObjPtr<MediumFormat> &aFormat,
+                         MediumVariant_T aVariant,
+                         RTVFSIOSTREAM hVfsIosSrc,
+                         const ComObjPtr<Medium> &aParent,
+                         const ComObjPtr<Progress> &aProgress,
+                         bool aNotify);
+
+    HRESULT i_cloneToEx(const ComObjPtr<Medium> &aTarget, MediumVariant_T aVariant,
+                        const ComObjPtr<Medium> &aParent, IProgress **aProgress,
+                        uint32_t idxSrcImageSame, uint32_t idxDstImageSame, bool aNotify);
+
+    const Utf8Str& i_getKeyId();
+
+    HRESULT i_openForIO(bool fWritable, SecretKeyStore *pKeyStore, PVDISK *ppHdd, MediumLockList *pMediumLockList,
+                        struct MediumCryptoFilterSettings *pCryptoSettings);
+
+private:
+
+    // wrapped IMedium properties
+    HRESULT getId(com::Guid &aId);
+    HRESULT getDescription(AutoCaller &autoCaller, com::Utf8Str &aDescription);
+    HRESULT setDescription(AutoCaller &autoCaller, const com::Utf8Str &aDescription);
+    HRESULT getState(MediumState_T *aState);
+    HRESULT getVariant(std::vector<MediumVariant_T> &aVariant);
+    HRESULT getLocation(com::Utf8Str &aLocation);
+    HRESULT setLocation(const com::Utf8Str &aLocation);
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT getDeviceType(DeviceType_T *aDeviceType);
+    HRESULT getHostDrive(BOOL *aHostDrive);
+    HRESULT getSize(LONG64 *aSize);
+    HRESULT getFormat(com::Utf8Str &aFormat);
+    HRESULT getMediumFormat(ComPtr<IMediumFormat> &aMediumFormat);
+    HRESULT getType(AutoCaller &autoCaller, MediumType_T *aType);
+    HRESULT setType(AutoCaller &autoCaller, MediumType_T aType);
+    HRESULT getAllowedTypes(std::vector<MediumType_T> &aAllowedTypes);
+    HRESULT getParent(AutoCaller &autoCaller, ComPtr<IMedium> &aParent);
+    HRESULT getChildren(AutoCaller &autoCaller, std::vector<ComPtr<IMedium> > &aChildren);
+    HRESULT getBase(AutoCaller &autoCaller, ComPtr<IMedium> &aBase);
+    HRESULT getReadOnly(AutoCaller &autoCaller, BOOL *aReadOnly);
+    HRESULT getLogicalSize(LONG64 *aLogicalSize);
+    HRESULT getAutoReset(BOOL *aAutoReset);
+    HRESULT setAutoReset(BOOL aAutoReset);
+    HRESULT getLastAccessError(com::Utf8Str &aLastAccessError);
+    HRESULT getMachineIds(std::vector<com::Guid> &aMachineIds);
+
+    // wrapped IMedium methods
+    HRESULT setIds(AutoCaller &aAutoCaller,
+                   BOOL aSetImageId,
+                   const com::Guid &aImageId,
+                   BOOL aSetParentId,
+                   const com::Guid &aParentId);
+    HRESULT refreshState(AutoCaller &aAutoCaller,
+                         MediumState_T *aState);
+    HRESULT getSnapshotIds(const com::Guid &aMachineId,
+                           std::vector<com::Guid> &aSnapshotIds);
+    HRESULT lockRead(ComPtr<IToken> &aToken);
+    HRESULT lockWrite(ComPtr<IToken> &aToken);
+    HRESULT close(AutoCaller &aAutoCaller);
+    HRESULT getProperty(const com::Utf8Str &aName,
+                        com::Utf8Str &aValue);
+    HRESULT setProperty(const com::Utf8Str &aName,
+                        const com::Utf8Str &aValue);
+    HRESULT getProperties(const com::Utf8Str &aNames,
+                          std::vector<com::Utf8Str> &aReturnNames,
+                          std::vector<com::Utf8Str> &aReturnValues);
+    HRESULT setProperties(const std::vector<com::Utf8Str> &aNames,
+                          const std::vector<com::Utf8Str> &aValues);
+    HRESULT createBaseStorage(LONG64 aLogicalSize,
+                              const std::vector<MediumVariant_T> &aVariant,
+                              ComPtr<IProgress> &aProgress);
+    HRESULT deleteStorage(ComPtr<IProgress> &aProgress);
+    HRESULT createDiffStorage(AutoCaller &autoCaller,
+                              const ComPtr<IMedium> &aTarget,
+                              const std::vector<MediumVariant_T> &aVariant,
+                              ComPtr<IProgress> &aProgress);
+    HRESULT mergeTo(const ComPtr<IMedium> &aTarget,
+                    ComPtr<IProgress> &aProgress);
+    HRESULT cloneTo(const ComPtr<IMedium> &aTarget,
+                    const std::vector<MediumVariant_T> &aVariant,
+                    const ComPtr<IMedium> &aParent,
+                    ComPtr<IProgress> &aProgress);
+    HRESULT resizeAndCloneTo(const ComPtr<IMedium> &aTarget,
+                             LONG64 aLogicalSize,
+                             const std::vector<MediumVariant_T> &aVariant,
+                             const ComPtr<IMedium> &aParent,
+                             ComPtr<IProgress> &aProgress);
+    HRESULT cloneToBase(const ComPtr<IMedium> &aTarget,
+                        const std::vector<MediumVariant_T> &aVariant,
+                        ComPtr<IProgress> &aProgress);
+    HRESULT moveTo(AutoCaller &autoCaller,
+                   const com::Utf8Str &aLocation,
+                   ComPtr<IProgress> &aProgress);
+    HRESULT compact(ComPtr<IProgress> &aProgress);
+    HRESULT resize(LONG64 aLogicalSize,
+                   ComPtr<IProgress> &aProgress);
+    HRESULT reset(AutoCaller &autoCaller, ComPtr<IProgress> &aProgress);
+    HRESULT changeEncryption(const com::Utf8Str &aCurrentPassword, const com::Utf8Str &aCipher,
+                             const com::Utf8Str &aNewPassword, const com::Utf8Str &aNewPasswordId,
+                             ComPtr<IProgress> &aProgress);
+    HRESULT getEncryptionSettings(AutoCaller &autoCaller, com::Utf8Str &aCipher, com::Utf8Str &aPasswordId);
+    HRESULT checkEncryptionPassword(const com::Utf8Str &aPassword);
+    HRESULT openForIO(BOOL aWritable, com::Utf8Str const &aPassword, ComPtr<IMediumIO> &aMediumIO);
+
+    // Private internal nmethods
+    HRESULT i_queryInfo(bool fSetImageId, bool fSetParentId, AutoCaller &autoCaller);
+    HRESULT i_canClose();
+    HRESULT i_unregisterWithVirtualBox();
+    HRESULT i_setStateError();
+    HRESULT i_setLocation(const Utf8Str &aLocation, const Utf8Str &aFormat = Utf8Str::Empty);
+    HRESULT i_setFormat(const Utf8Str &aFormat);
+    VDTYPE i_convertDeviceType();
+    DeviceType_T i_convertToDeviceType(VDTYPE enmType);
+    Utf8Str i_vdError(int aVRC);
+
+    bool    i_isPropertyForFilter(const com::Utf8Str &aName);
+
+    HRESULT i_getFilterProperties(std::vector<com::Utf8Str> &aReturnNames,
+                                  std::vector<com::Utf8Str> &aReturnValues);
+
+    HRESULT i_preparationForMoving(const Utf8Str &aLocation);
+    bool    i_isMoveOperation(const ComObjPtr<Medium> &pTarget) const;
+    bool    i_resetMoveOperationData();
+    Utf8Str i_getNewLocationForMoving() const;
+
+    static DECLCALLBACK(void) i_vdErrorCall(void *pvUser, int vrc, RT_SRC_POS_DECL,
+                                            const char *pszFormat, va_list va);
+    static DECLCALLBACK(bool) i_vdConfigAreKeysValid(void *pvUser,
+                                                     const char *pszzValid);
+    static DECLCALLBACK(int) i_vdConfigQuerySize(void *pvUser, const char *pszName,
+                                                 size_t *pcbValue);
+    static DECLCALLBACK(int) i_vdConfigUpdate(void *pvUser, bool fCreate,
+                                            const char *pszName, const char *pszValue);
+
+    static DECLCALLBACK(int) i_vdConfigQuery(void *pvUser, const char *pszName,
+                                             char *pszValue, size_t cchValue);
+
+    static DECLCALLBACK(bool) i_vdCryptoConfigAreKeysValid(void *pvUser,
+                                                           const char *pszzValid);
+    static DECLCALLBACK(int) i_vdCryptoConfigQuerySize(void *pvUser, const char *pszName,
+                                                       size_t *pcbValue);
+    static DECLCALLBACK(int) i_vdCryptoConfigQuery(void *pvUser, const char *pszName,
+                                                   char *pszValue, size_t cchValue);
+
+    static DECLCALLBACK(int) i_vdCryptoKeyRetain(void *pvUser, const char *pszId,
+                                                 const uint8_t **ppbKey, size_t *pcbKey);
+    static DECLCALLBACK(int) i_vdCryptoKeyRelease(void *pvUser, const char *pszId);
+    static DECLCALLBACK(int) i_vdCryptoKeyStorePasswordRetain(void *pvUser, const char *pszId, const char **ppszPassword);
+    static DECLCALLBACK(int) i_vdCryptoKeyStorePasswordRelease(void *pvUser, const char *pszId);
+    static DECLCALLBACK(int) i_vdCryptoKeyStoreSave(void *pvUser, const void *pvKeyStore, size_t cbKeyStore);
+    static DECLCALLBACK(int) i_vdCryptoKeyStoreReturnParameters(void *pvUser, const char *pszCipher,
+                                                                const uint8_t *pbDek, size_t cbDek);
+
+    class Task;
+    class CreateBaseTask;
+    class CreateDiffTask;
+    class CloneTask;
+    class MoveTask;
+    class CompactTask;
+    class ResizeTask;
+    class ResetTask;
+    class DeleteTask;
+    class MergeTask;
+    class ImportTask;
+    class EncryptTask;
+    friend class Task;
+    friend class CreateBaseTask;
+    friend class CreateDiffTask;
+    friend class CloneTask;
+    friend class MoveTask;
+    friend class CompactTask;
+    friend class ResizeTask;
+    friend class ResetTask;
+    friend class DeleteTask;
+    friend class MergeTask;
+    friend class ImportTask;
+    friend class EncryptTask;
+
+    HRESULT i_taskCreateBaseHandler(Medium::CreateBaseTask &task);
+    HRESULT i_taskCreateDiffHandler(Medium::CreateDiffTask &task);
+    HRESULT i_taskMergeHandler(Medium::MergeTask &task);
+    HRESULT i_taskCloneHandler(Medium::CloneTask &task);
+    HRESULT i_taskMoveHandler(Medium::MoveTask &task);
+    HRESULT i_taskDeleteHandler(Medium::DeleteTask &task);
+    HRESULT i_taskResetHandler(Medium::ResetTask &task);
+    HRESULT i_taskCompactHandler(Medium::CompactTask &task);
+    HRESULT i_taskResizeHandler(Medium::ResizeTask &task);
+    HRESULT i_taskImportHandler(Medium::ImportTask &task);
+    HRESULT i_taskEncryptHandler(Medium::EncryptTask &task);
+
+    void i_taskEncryptSettingsSetup(struct MediumCryptoFilterSettings *pSettings, const char *pszCipher,
+                                    const char *pszKeyStore,  const char *pszPassword,
+                                    bool fCreateKeyStore);
+
+    struct Data;            // opaque data struct, defined in MediumImpl.cpp
+    Data *m;
+};
+
+
+/**
+ * Settings for a crypto filter instance.
+ */
+struct MediumCryptoFilterSettings
+{
+    MediumCryptoFilterSettings()
+        : fCreateKeyStore(false),
+          pszPassword(NULL),
+          pszKeyStore(NULL),
+          pszKeyStoreLoad(NULL),
+          pbDek(NULL),
+          cbDek(0),
+          pszCipher(NULL),
+          pszCipherReturned(NULL)
+    { }
+
+    bool              fCreateKeyStore;
+    const char        *pszPassword;
+    char              *pszKeyStore;
+    const char        *pszKeyStoreLoad;
+
+    const uint8_t     *pbDek;
+    size_t            cbDek;
+    const char        *pszCipher;
+
+    /** The cipher returned by the crypto filter. */
+    char              *pszCipherReturned;
+
+    PVDINTERFACE      vdFilterIfaces;
+
+    VDINTERFACECONFIG vdIfCfg;
+    VDINTERFACECRYPTO vdIfCrypto;
+};
+
+
+
+#endif /* !MAIN_INCLUDED_MediumImpl_h */
+
diff --git a/src/VBox/Main/include/MediumLock.h b/src/VBox/Main/include/MediumLock.h
new file mode 100644
index 00000000..d01fb9f3
--- /dev/null
+++ b/src/VBox/Main/include/MediumLock.h
@@ -0,0 +1,354 @@
+/* $Id: MediumLock.h $ */
+
+/** @file
+ *
+ * VirtualBox medium object lock collections
+ */
+
+/*
+ * Copyright (C) 2010-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
+ */
+
+#ifndef MAIN_INCLUDED_MediumLock_h
+#define MAIN_INCLUDED_MediumLock_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+/* interface definitions */
+#include "VBox/com/VirtualBox.h"
+#include "VirtualBoxBase.h"
+#include "AutoCaller.h"
+
+#include <iprt/types.h>
+
+#include <list>
+#include <map>
+
+class Medium;
+class MediumAttachment;
+
+/**
+ * Single entry for medium lock lists. Has a medium object reference,
+ * information about what kind of lock should be taken, and if it is
+ * locked right now.
+ */
+class MediumLock
+{
+public:
+    /**
+     * Default medium lock constructor.
+     */
+    MediumLock();
+
+    /**
+     * Default medium lock destructor.
+     */
+    ~MediumLock();
+
+    /**
+     * Create a new medium lock description
+     *
+     * @param aMedium       Reference to medium object
+     * @param aLockWrite    @c true means a write lock should be taken
+     */
+    MediumLock(const ComObjPtr<Medium> &aMedium, bool aLockWrite);
+
+    /**
+     * Copy constructor. Needed because we contain an AutoCaller
+     * instance which is deliberately not copyable. The copy is not
+     * marked as locked, so be careful.
+     *
+     * @param aMediumLock   Reference to source object.
+     */
+    MediumLock(const MediumLock &aMediumLock);
+
+    /**
+     * Update a medium lock description.
+     *
+     * @note May be used in locked state.
+     *
+     * @return COM status code
+     * @param aLockWrite    @c true means a write lock should be taken
+     */
+    HRESULT UpdateLock(bool aLockWrite);
+
+    /**
+     * Get medium object reference.
+     */
+    const ComObjPtr<Medium> &GetMedium() const;
+
+    /**
+     * Get medium object lock request type.
+     */
+    bool GetLockRequest() const;
+
+    /**
+     * Check if this medium object has been locked by this MediumLock.
+     */
+    bool IsLocked() const;
+
+    /**
+     * Acquire a medium lock.
+     *
+     * @return COM status code
+     * @param aIgnoreLockedMedia    If set ignore all media which is already
+     *                              locked in an incompatible way.
+     */
+    HRESULT Lock(bool aIgnoreLockedMedia = false);
+
+    /**
+     * Release a medium lock.
+     *
+     * @return COM status code
+     */
+    HRESULT Unlock();
+
+private:
+    ComObjPtr<Medium> mMedium;
+    ComPtr<IToken> mToken;
+    AutoCaller mMediumCaller;
+    bool mLockWrite;
+    bool mIsLocked;
+    /** Flag whether the medium was skipped when taking the locks.
+     * Only existing and accessible media objects need to be locked. */
+    bool mLockSkipped;
+};
+
+
+/**
+ * Medium lock list. Meant for storing the ordered locking information
+ * for a single medium chain.
+ */
+class MediumLockList
+{
+public:
+
+    /* Base list data type. */
+    typedef std::list<MediumLock> Base;
+
+    /**
+     * Default medium lock list constructor.
+     */
+    MediumLockList();
+
+    /**
+     * Default medium lock list destructor.
+     */
+    ~MediumLockList();
+
+    /**
+     * Checks if medium lock declaration list is empty.
+     *
+     * @return true if list is empty.
+     */
+    bool IsEmpty();
+
+    /**
+     * Add a new medium lock declaration to the end of the list.
+     *
+     * @note May be only used in unlocked state.
+     *
+     * @return COM status code
+     * @param aMedium       Reference to medium object
+     * @param aLockWrite    @c true means a write lock should be taken
+     */
+    HRESULT Append(const ComObjPtr<Medium> &aMedium, bool aLockWrite);
+
+    /**
+     * Add a new medium lock declaration to the beginning of the list.
+     *
+     * @note May be only used in unlocked state.
+     *
+     * @return COM status code
+     * @param aMedium       Reference to medium object
+     * @param aLockWrite    @c true means a write lock should be taken
+     */
+    HRESULT Prepend(const ComObjPtr<Medium> &aMedium, bool aLockWrite);
+
+    /**
+     * Update a medium lock declaration.
+     *
+     * @note May be used in locked state.
+     *
+     * @return COM status code
+     * @param aMedium       Reference to medium object
+     * @param aLockWrite    @c true means a write lock should be taken
+     */
+    HRESULT Update(const ComObjPtr<Medium> &aMedium, bool aLockWrite);
+
+    /**
+     * Remove a medium lock declaration and return an updated iterator.
+     *
+     * @note May be used in locked state.
+     *
+     * @return COM status code
+     * @param aIt           Iterator for the element to remove
+     */
+    HRESULT RemoveByIterator(Base::iterator &aIt);
+
+    /**
+     * Clear all medium lock declarations.
+     *
+     * @note Implicitly unlocks all locks.
+     *
+     * @return COM status code
+     */
+    HRESULT Clear();
+
+    /**
+     * Get iterator begin() for base list.
+     */
+    Base::iterator GetBegin();
+
+    /**
+     * Get iterator end() for base list.
+     */
+    Base::iterator GetEnd();
+
+    /**
+     * Acquire all medium locks "atomically", i.e. all or nothing.
+     *
+     * @return COM status code
+     * @param aSkipOverLockedMedia  If set ignore all media which is already
+     *                              locked for reading or writing. For callers
+     *                              which need to know which medium objects
+     *                              have been locked by this lock list you
+     *                              can iterate over the list and check the
+     *                              MediumLock state.
+     */
+    HRESULT Lock(bool aSkipOverLockedMedia = false);
+
+    /**
+     * Release all medium locks.
+     *
+     * @return COM status code
+     */
+    HRESULT Unlock();
+
+private:
+    Base mMediumLocks;
+    bool mIsLocked;
+};
+
+/**
+ * Medium lock list map. Meant for storing a collection of lock lists.
+ * The usual use case is creating such a map when locking all medium chains
+ * belonging to one VM, however that's not the limit. Be creative.
+ */
+class MediumLockListMap
+{
+public:
+
+    /**
+     * Default medium lock list map constructor.
+     */
+    MediumLockListMap();
+
+    /**
+     * Default medium lock list map destructor.
+     */
+    ~MediumLockListMap();
+
+    /**
+     * Checks if medium lock list map is empty.
+     *
+     * @return true if list is empty.
+     */
+    bool IsEmpty();
+
+    /**
+     * Insert a new medium lock list into the map.
+     *
+     * @note May be only used in unlocked state.
+     *
+     * @return COM status code
+     * @param aMediumAttachment Reference to medium attachment object, the key.
+     * @param aMediumLockList   Reference to medium lock list object
+     */
+    HRESULT Insert(const ComObjPtr<MediumAttachment> &aMediumAttachment, MediumLockList *aMediumLockList);
+
+    /**
+     * Replace the medium lock list key by a different one.
+     *
+     * @note May be used in locked state.
+     *
+     * @return COM status code
+     * @param aMediumAttachmentOld  Reference to medium attachment object.
+     * @param aMediumAttachmentNew  Reference to medium attachment object.
+     */
+    HRESULT ReplaceKey(const ComObjPtr<MediumAttachment> &aMediumAttachmentOld, const ComObjPtr<MediumAttachment> &aMediumAttachmentNew);
+
+    /**
+     * Remove a medium lock list from the map. The list will get deleted.
+     *
+     * @note May be only used in unlocked state.
+     *
+     * @return COM status code
+     * @param aMediumAttachment Reference to medium attachment object, the key.
+     */
+    HRESULT Remove(const ComObjPtr<MediumAttachment> &aMediumAttachment);
+
+    /**
+     * Clear all medium lock declarations in this map.
+     *
+     * @note Implicitly unlocks all locks.
+     *
+     * @return COM status code
+     */
+    HRESULT Clear();
+
+    /**
+     * Get the medium lock list identified by the given key.
+     *
+     * @note May be used in locked state.
+     *
+     * @return COM status code
+     * @param aMediumAttachment     Key for medium attachment object.
+     * @param aMediumLockList       Out: medium attachment object reference.
+     */
+    HRESULT Get(const ComObjPtr<MediumAttachment> &aMediumAttachment, MediumLockList * &aMediumLockList);
+
+    /**
+     * Acquire all medium locks "atomically", i.e. all or nothing.
+     *
+     * @return COM status code
+     */
+    HRESULT Lock();
+
+    /**
+     * Release all medium locks.
+     *
+     * @return COM status code
+     */
+    HRESULT Unlock();
+
+    /** Introspection. */
+    bool IsLocked(void) const { return mIsLocked; }
+
+private:
+    typedef std::map<ComObjPtr<MediumAttachment>, MediumLockList *> Base;
+    Base mMediumLocks;
+    bool mIsLocked;
+};
+
+#endif /* !MAIN_INCLUDED_MediumLock_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/MouseImpl.h b/src/VBox/Main/include/MouseImpl.h
new file mode 100644
index 00000000..8636ce3e
--- /dev/null
+++ b/src/VBox/Main/include/MouseImpl.h
@@ -0,0 +1,175 @@
+/* $Id: MouseImpl.h $ */
+/** @file
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_MouseImpl_h
+#define MAIN_INCLUDED_MouseImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "MouseWrap.h"
+#include "ConsoleImpl.h"
+#include "EventImpl.h"
+#include <VBox/vmm/pdmdrv.h>
+
+/** Maximum number of devices supported */
+enum { MOUSE_MAX_DEVICES = 4 };
+/** Mouse driver instance data. */
+typedef struct DRVMAINMOUSE DRVMAINMOUSE, *PDRVMAINMOUSE;
+
+class ATL_NO_VTABLE Mouse :
+    public MouseWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS (Mouse)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(ConsoleMouseInterface *parent);
+    void uninit();
+
+    static const PDMDRVREG  DrvReg;
+
+    ConsoleMouseInterface *i_getParent() const
+    {
+        return mParent;
+    }
+
+    /** notify the front-end of guest capability changes */
+    void i_onVMMDevGuestCapsChange(uint32_t fCaps)
+    {
+        mfVMMDevGuestCaps = fCaps;
+        i_sendMouseCapsNotifications();
+    }
+
+    void updateMousePointerShape(bool fVisible, bool fAlpha,
+                                 uint32_t hotX, uint32_t hotY,
+                                 uint32_t width, uint32_t height,
+                                 const uint8_t *pu8Shape, uint32_t cbShape);
+private:
+
+    // Wrapped IMouse properties
+    HRESULT getAbsoluteSupported(BOOL *aAbsoluteSupported);
+    HRESULT getRelativeSupported(BOOL *aRelativeSupported);
+    HRESULT getTouchScreenSupported(BOOL *aTouchScreenSupported);
+    HRESULT getTouchPadSupported(BOOL *aTouchPadSupported);
+    HRESULT getNeedsHostCursor(BOOL *aNeedsHostCursor);
+    HRESULT getPointerShape(ComPtr<IMousePointerShape> &aPointerShape);
+    HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
+
+    // Wrapped IMouse methods
+    HRESULT putMouseEvent(LONG aDx,
+                          LONG aDy,
+                          LONG aDz,
+                          LONG aDw,
+                          LONG aButtonState);
+    HRESULT putMouseEventAbsolute(LONG aX,
+                                  LONG aY,
+                                  LONG aDz,
+                                  LONG aDw,
+                                  LONG aButtonState);
+    HRESULT putEventMultiTouch(LONG aCount,
+                               const std::vector<LONG64> &aContacts,
+                               BOOL isTouchScreen,
+                               ULONG aScanTime);
+    HRESULT putEventMultiTouchString(LONG aCount,
+                                     const com::Utf8Str &aContacts,
+                                     BOOL isTouchScreen,
+                                     ULONG aScanTime);
+
+
+    static DECLCALLBACK(void *) i_drvQueryInterface(PPDMIBASE pInterface, const char *pszIID);
+    static DECLCALLBACK(void)   i_mouseReportModes(PPDMIMOUSECONNECTOR pInterface, bool fRel, bool fAbs, bool fMTAbs, bool fMTRel);
+    static DECLCALLBACK(int)    i_drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
+    static DECLCALLBACK(void)   i_drvDestruct(PPDMDRVINS pDrvIns);
+
+    HRESULT i_updateVMMDevMouseCaps(uint32_t fCapsAdded, uint32_t fCapsRemoved);
+    HRESULT i_reportRelEventToMouseDev(int32_t dx, int32_t dy, int32_t dz,
+                                 int32_t dw, uint32_t fButtons);
+    HRESULT i_reportAbsEventToMouseDev(int32_t x, int32_t y, int32_t dz,
+                                     int32_t dw, uint32_t fButtons);
+    HRESULT i_reportMTEventToMouseDev(int32_t x, int32_t z, uint32_t cContact,
+                                    uint32_t fContact);
+    HRESULT i_reportMultiTouchEventToDevice(uint8_t cContacts, const uint64_t *pau64Contacts, bool fTouchScreen, uint32_t u32ScanTime);
+    HRESULT i_reportAbsEventToVMMDev(int32_t x, int32_t y, int32_t dz, int32_t dw, uint32_t fButtons);
+    HRESULT i_reportAbsEventToInputDevices(int32_t x, int32_t y, int32_t dz, int32_t dw, uint32_t fButtons,
+                                           bool fUsesVMMDevEvent);
+    HRESULT i_reportAbsEventToDisplayDevice(int32_t x, int32_t y);
+    HRESULT i_convertDisplayRes(LONG x, LONG y, int32_t *pxAdj, int32_t *pyAdj,
+                                 bool *pfValid);
+    HRESULT i_putEventMultiTouch(LONG aCount, const LONG64 *paContacts, BOOL isTouchScreen, ULONG aScanTime);
+
+    uint32_t i_getDeviceCaps(void);
+    void i_sendMouseCapsNotifications(void);
+    bool i_guestNeedsHostCursor(void);
+    bool i_vmmdevCanAbs(void);
+    bool i_deviceCanAbs(void);
+    bool i_supportsAbs(uint32_t fCaps) const;
+    bool i_supportsAbs(void);
+    bool i_supportsRel(void);
+    bool i_supportsTS(void);
+    bool i_supportsTP(void);
+
+    ConsoleMouseInterface * const         mParent;
+    /** Pointer to the associated mouse driver. */
+    struct DRVMAINMOUSE    *mpDrv[MOUSE_MAX_DEVICES];
+
+    uint32_t mfVMMDevGuestCaps;  /** We cache this to avoid access races */
+    int32_t mcLastX;
+    int32_t mcLastY;
+    uint32_t mfLastButtons;
+
+    ComPtr<IMousePointerShape> mPointerShape;
+    struct
+    {
+        bool fVisible;
+        bool fAlpha;
+        uint32_t hotX;
+        uint32_t hotY;
+        uint32_t width;
+        uint32_t height;
+        uint8_t *pu8Shape;
+        uint32_t cbShape;
+    } mPointerData;
+
+    const ComObjPtr<EventSource> mEventSource;
+    VBoxEventDesc                mMouseEvent;
+
+    void i_fireMouseEvent(bool fAbsolute, LONG x, LONG y, LONG dz, LONG dw,
+                          LONG fButtons);
+
+    void i_fireMultiTouchEvent(uint8_t cContacts,
+                               const LONG64 *paContacts,
+                               bool fTouchScreen,
+                               uint32_t u32ScanTime);
+};
+
+#endif /* !MAIN_INCLUDED_MouseImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/NATEngineImpl.h b/src/VBox/Main/include/NATEngineImpl.h
new file mode 100644
index 00000000..2f21000b
--- /dev/null
+++ b/src/VBox/Main/include/NATEngineImpl.h
@@ -0,0 +1,124 @@
+/* $Id: NATEngineImpl.h $ */
+
+/** @file
+ *
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_NATEngineImpl_h
+#define MAIN_INCLUDED_NATEngineImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "NATEngineWrap.h"
+
+namespace settings
+{
+    struct NAT;
+}
+
+
+class ATL_NO_VTABLE NATEngine :
+    public NATEngineWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(NATEngine)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    HRESULT init(Machine *aParent, INetworkAdapter *aAdapter);
+    HRESULT init(Machine *aParent, INetworkAdapter *aAdapter, NATEngine *aThat);
+    HRESULT initCopy(Machine *aParent, INetworkAdapter *aAdapter, NATEngine *aThat);
+    void uninit();
+
+    bool i_isModified();
+    void i_rollback();
+    void i_commit();
+    void i_copyFrom(NATEngine *aThat);
+    void i_applyDefaults();
+    bool i_hasDefaults();
+    HRESULT i_loadSettings(const settings::NAT &data);
+    HRESULT i_saveSettings(settings::NAT &data);
+
+private:
+
+    // wrapped INATEngine properties
+    HRESULT setNetwork(const com::Utf8Str &aNetwork);
+    HRESULT getNetwork(com::Utf8Str &aNetwork);
+    HRESULT setHostIP(const com::Utf8Str &aHostIP);
+    HRESULT getHostIP(com::Utf8Str &aBindIP);
+    HRESULT setLocalhostReachable(BOOL fLocalhostReachable);
+    HRESULT getLocalhostReachable(BOOL *pfLocalhostReachable);
+    /* TFTP properties */
+    HRESULT setTFTPPrefix(const com::Utf8Str &aTFTPPrefix);
+    HRESULT getTFTPPrefix(com::Utf8Str &aTFTPPrefix);
+    HRESULT setTFTPBootFile(const com::Utf8Str &aTFTPBootFile);
+    HRESULT getTFTPBootFile(com::Utf8Str &aTFTPBootFile);
+    HRESULT setTFTPNextServer(const com::Utf8Str &aTFTPNextServer);
+    HRESULT getTFTPNextServer(com::Utf8Str &aTFTPNextServer);
+    /* DNS properties */
+    HRESULT setDNSPassDomain(BOOL aDNSPassDomain);
+    HRESULT getDNSPassDomain(BOOL *aDNSPassDomain);
+    HRESULT setDNSProxy(BOOL aDNSProxy);
+    HRESULT getDNSProxy(BOOL *aDNSProxy);
+    HRESULT getDNSUseHostResolver(BOOL *aDNSUseHostResolver);
+    HRESULT setDNSUseHostResolver(BOOL aDNSUseHostResolver);
+    /* Alias properties */
+    HRESULT setAliasMode(ULONG aAliasMode);
+    HRESULT getAliasMode(ULONG *aAliasMode);
+
+    HRESULT getRedirects(std::vector<com::Utf8Str> &aRedirects);
+
+    HRESULT setNetworkSettings(ULONG aMtu,
+                               ULONG aSockSnd,
+                               ULONG aSockRcv,
+                               ULONG aTcpWndSnd,
+                               ULONG aTcpWndRcv);
+
+    HRESULT getNetworkSettings(ULONG *aMtu,
+                               ULONG *aSockSnd,
+                               ULONG *aSockRcv,
+                               ULONG *aTcpWndSnd,
+                               ULONG *aTcpWndRcv);
+
+    HRESULT addRedirect(const com::Utf8Str  &aName,
+                              NATProtocol_T aProto,
+                        const com::Utf8Str  &aHostIP,
+                              USHORT        aHostPort,
+                        const com::Utf8Str  &aGuestIP,
+                              USHORT        aGuestPort);
+
+    HRESULT removeRedirect(const com::Utf8Str &aName);
+
+    struct Data;
+    Data *mData;
+    const ComObjPtr<NATEngine> mPeer;
+    Machine * const mParent;
+    INetworkAdapter * const mAdapter;
+};
+#endif /* !MAIN_INCLUDED_NATEngineImpl_h */
diff --git a/src/VBox/Main/include/NATNetworkImpl.h b/src/VBox/Main/include/NATNetworkImpl.h
new file mode 100644
index 00000000..1a59aa62
--- /dev/null
+++ b/src/VBox/Main/include/NATNetworkImpl.h
@@ -0,0 +1,143 @@
+/* $Id: NATNetworkImpl.h $ */
+/** @file
+ * INATNetwork implementation header, lives 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
+ */
+
+#ifndef MAIN_INCLUDED_NATNetworkImpl_h
+#define MAIN_INCLUDED_NATNetworkImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "VBoxEvents.h"
+#include "NATNetworkWrap.h"
+
+#ifdef VBOX_WITH_HOSTNETIF_API
+struct NETIFINFO;
+#endif
+
+namespace settings
+{
+    struct NATNetwork;
+    struct NATRule;
+    typedef std::map<com::Utf8Str, NATRule> NATRulesMap;
+}
+
+#ifdef RT_OS_WINDOWS
+# define NATSR_EXECUTABLE_NAME "VBoxNetNAT.exe"
+#else
+# define NATSR_EXECUTABLE_NAME "VBoxNetNAT"
+#endif
+
+#undef ADDR_ANY ///@todo ADDR_ANY collides with some windows header!
+
+enum ADDRESSLOOKUPTYPE
+{
+    ADDR_GATEWAY,
+    ADDR_DHCP,
+    ADDR_DHCPLOWERIP,
+    ADDR_ANY
+};
+
+class NATNetworkServiceRunner: public NetworkServiceRunner
+{
+public:
+    NATNetworkServiceRunner(): NetworkServiceRunner(NATSR_EXECUTABLE_NAME){}
+    ~NATNetworkServiceRunner(){}
+};
+
+class ATL_NO_VTABLE NATNetwork :
+    public NATNetworkWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(NATNetwork)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    HRESULT init(VirtualBox *aVirtualBox, com::Utf8Str aName);
+    HRESULT i_loadSettings(const settings::NATNetwork &data);
+    void uninit();
+    HRESULT i_saveSettings(settings::NATNetwork &data);
+
+private:
+
+    // Wrapped INATNetwork properties
+    HRESULT getNetworkName(com::Utf8Str &aNetworkName);
+    HRESULT setNetworkName(const com::Utf8Str &aNetworkName);
+    HRESULT getEnabled(BOOL *aEnabled);
+    HRESULT setEnabled(BOOL aEnabled);
+    HRESULT getNetwork(com::Utf8Str &aNetwork);
+    HRESULT setNetwork(const com::Utf8Str &aNetwork);
+    HRESULT getGateway(com::Utf8Str &aGateway);
+    HRESULT getIPv6Enabled(BOOL *aIPv6Enabled);
+    HRESULT setIPv6Enabled(BOOL aIPv6Enabled);
+    HRESULT getIPv6Prefix(com::Utf8Str &aIPv6Prefix);
+    HRESULT setIPv6Prefix(const com::Utf8Str &aIPv6Prefix);
+    HRESULT getAdvertiseDefaultIPv6RouteEnabled(BOOL *aAdvertiseDefaultIPv6RouteEnabled);
+    HRESULT setAdvertiseDefaultIPv6RouteEnabled(BOOL aAdvertiseDefaultIPv6RouteEnabled);
+    HRESULT getNeedDhcpServer(BOOL *aNeedDhcpServer);
+    HRESULT setNeedDhcpServer(BOOL aNeedDhcpServer);
+    HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
+    HRESULT getPortForwardRules4(std::vector<com::Utf8Str> &aPortForwardRules4);
+    HRESULT getLocalMappings(std::vector<com::Utf8Str> &aLocalMappings);
+    HRESULT getLoopbackIp6(LONG *aLoopbackIp6);
+    HRESULT setLoopbackIp6(LONG aLoopbackIp6);
+    HRESULT getPortForwardRules6(std::vector<com::Utf8Str> &aPortForwardRules6);
+
+    // wrapped INATNetwork methods
+    HRESULT addLocalMapping(const com::Utf8Str &aHostid,
+                            LONG aOffset);
+    HRESULT addPortForwardRule(BOOL aIsIpv6,
+                               const com::Utf8Str &aRuleName,
+                               NATProtocol_T aProto,
+                               const com::Utf8Str &aHostIP,
+                               USHORT aHostPort,
+                               const com::Utf8Str &aGuestIP,
+                               USHORT aGuestPort);
+    HRESULT removePortForwardRule(BOOL aISipv6,
+                                  const com::Utf8Str &aRuleName);
+    HRESULT start();
+    HRESULT stop();
+
+    // Internal methods
+    HRESULT setErrorBusy();
+
+    int i_recalculateIpv4AddressAssignments();
+    int i_findFirstAvailableOffset(ADDRESSLOOKUPTYPE, uint32_t *);
+    int i_recalculateIPv6Prefix();
+
+    void i_getPortForwardRulesFromMap(std::vector<Utf8Str> &aPortForwardRules, settings::NATRulesMap &aRules);
+
+    void i_updateDnsOptions();
+    void i_updateDomainNameOption(ComPtr<IHost> &host);
+    void i_updateDomainNameServerOption(ComPtr<IHost> &host);
+
+    struct Data;
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_NATNetworkImpl_h */
diff --git a/src/VBox/Main/include/NetworkAdapterImpl.h b/src/VBox/Main/include/NetworkAdapterImpl.h
new file mode 100644
index 00000000..3efcd332
--- /dev/null
+++ b/src/VBox/Main/include/NetworkAdapterImpl.h
@@ -0,0 +1,141 @@
+/* $Id: NetworkAdapterImpl.h $ */
+/** @file
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_NetworkAdapterImpl_h
+#define MAIN_INCLUDED_NetworkAdapterImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "NetworkAdapterWrap.h"
+
+class GuestOSType;
+class BandwidthControl;
+class BandwidthGroup;
+class NATEngine;
+
+namespace settings
+{
+    struct NetworkAdapter;
+}
+
+class ATL_NO_VTABLE NetworkAdapter :
+    public NetworkAdapterWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(NetworkAdapter)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Machine *aParent, ULONG aSlot);
+    HRESULT init(Machine *aParent, NetworkAdapter *aThat, bool aReshare = false);
+    HRESULT initCopy(Machine *aParent, NetworkAdapter *aThat);
+    void uninit();
+
+    // public methods only for internal purposes
+    HRESULT i_loadSettings(BandwidthControl *bwctl, const settings::NetworkAdapter &data);
+    HRESULT i_saveSettings(settings::NetworkAdapter &data);
+
+    bool i_isModified();
+    void i_rollback();
+    void i_commit();
+    void i_copyFrom(NetworkAdapter *aThat);
+    void i_applyDefaults(GuestOSType *aOsType);
+    bool i_hasDefaults();
+
+    ComObjPtr<NetworkAdapter> i_getPeer();
+
+private:
+
+    // wrapped INetworkAdapter properties
+    HRESULT getAdapterType(NetworkAdapterType_T *aAdapterType);
+    HRESULT setAdapterType(NetworkAdapterType_T aAdapterType);
+    HRESULT getSlot(ULONG *aSlot);
+    HRESULT getEnabled(BOOL *aEnabled);
+    HRESULT setEnabled(BOOL aEnabled);
+    HRESULT getMACAddress(com::Utf8Str &aMACAddress);
+    HRESULT setMACAddress(const com::Utf8Str &aMACAddress);
+    HRESULT getAttachmentType(NetworkAttachmentType_T *aAttachmentType);
+    HRESULT setAttachmentType(NetworkAttachmentType_T aAttachmentType);
+    HRESULT getBridgedInterface(com::Utf8Str &aBridgedInterface);
+    HRESULT setBridgedInterface(const com::Utf8Str &aBridgedInterface);
+    HRESULT getHostOnlyInterface(com::Utf8Str &aHostOnlyInterface);
+    HRESULT setHostOnlyInterface(const com::Utf8Str &aHostOnlyInterface);
+    HRESULT getHostOnlyNetwork(com::Utf8Str &aHostOnlyNetwork);
+    HRESULT setHostOnlyNetwork(const com::Utf8Str &aHostOnlyNetwork);
+    HRESULT getInternalNetwork(com::Utf8Str &aInternalNetwork);
+    HRESULT setInternalNetwork(const com::Utf8Str &aInternalNetwork);
+    HRESULT getNATNetwork(com::Utf8Str &aNATNetwork);
+    HRESULT setNATNetwork(const com::Utf8Str &aNATNetwork);
+    HRESULT getGenericDriver(com::Utf8Str &aGenericDriver);
+    HRESULT setGenericDriver(const com::Utf8Str &aGenericDriver);
+    HRESULT getCloudNetwork(com::Utf8Str &aCloudNetwork);
+    HRESULT setCloudNetwork(const com::Utf8Str &aCloudNetwork);
+    HRESULT getCableConnected(BOOL *aCableConnected);
+    HRESULT setCableConnected(BOOL aCableConnected);
+    HRESULT getLineSpeed(ULONG *aLineSpeed);
+    HRESULT setLineSpeed(ULONG aLineSpeed);
+    HRESULT getPromiscModePolicy(NetworkAdapterPromiscModePolicy_T *aPromiscModePolicy);
+    HRESULT setPromiscModePolicy(NetworkAdapterPromiscModePolicy_T aPromiscModePolicy);
+    HRESULT getTraceEnabled(BOOL *aTraceEnabled);
+    HRESULT setTraceEnabled(BOOL aTraceEnabled);
+    HRESULT getTraceFile(com::Utf8Str &aTraceFile);
+    HRESULT setTraceFile(const com::Utf8Str &aTraceFile);
+    HRESULT getNATEngine(ComPtr<INATEngine> &aNATEngine);
+    HRESULT getBootPriority(ULONG *aBootPriority);
+    HRESULT setBootPriority(ULONG aBootPriority);
+    HRESULT getBandwidthGroup(ComPtr<IBandwidthGroup> &aBandwidthGroup);
+    HRESULT setBandwidthGroup(const ComPtr<IBandwidthGroup> &aBandwidthGroup);
+
+    // wrapped INetworkAdapter methods
+    HRESULT getProperty(const com::Utf8Str &aKey,
+                        com::Utf8Str &aValue);
+    HRESULT setProperty(const com::Utf8Str &aKey,
+                        const com::Utf8Str &aValue);
+    HRESULT getProperties(const com::Utf8Str &aNames,
+                          std::vector<com::Utf8Str> &aReturnNames,
+                          std::vector<com::Utf8Str> &aReturnValues);
+    // Misc.
+    void i_generateMACAddress();
+    HRESULT i_updateMacAddress(Utf8Str aMacAddress);
+    void i_updateBandwidthGroup(BandwidthGroup *aBwGroup);
+    HRESULT i_switchFromNatNetworking(const com::Utf8Str &aNatnetworkName);
+    HRESULT i_switchToNatNetworking(const com::Utf8Str &aNatNetworkName);
+
+
+    Machine * const     mParent;
+    const ComObjPtr<NetworkAdapter> mPeer;
+    const ComObjPtr<NATEngine> mNATEngine;
+
+    Backupable<settings::NetworkAdapter> mData;
+};
+
+#endif /* !MAIN_INCLUDED_NetworkAdapterImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/NetworkServiceRunner.h b/src/VBox/Main/include/NetworkServiceRunner.h
new file mode 100644
index 00000000..6b0dd3ce
--- /dev/null
+++ b/src/VBox/Main/include/NetworkServiceRunner.h
@@ -0,0 +1,87 @@
+/* $Id: NetworkServiceRunner.h $ */
+/** @file
+ * VirtualBox Main - interface for VBox DHCP server.
+ */
+
+/*
+ * Copyright (C) 2009-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
+ */
+
+#ifndef MAIN_INCLUDED_NetworkServiceRunner_h
+#define MAIN_INCLUDED_NetworkServiceRunner_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/com/string.h>
+
+
+/** @name Internal networking trunk type option values (NetworkServiceRunner::kpszKeyTrunkType)
+ *  @{ */
+#define TRUNKTYPE_WHATEVER "whatever"
+#define TRUNKTYPE_NETFLT   "netflt"
+#define TRUNKTYPE_NETADP   "netadp"
+#define TRUNKTYPE_SRVNAT   "srvnat"
+/** @} */
+
+/**
+ * Network service runner.
+ *
+ * Build arguments, starts and stops network service processes.
+ */
+class NetworkServiceRunner
+{
+public:
+    NetworkServiceRunner(const char *aProcName);
+    virtual ~NetworkServiceRunner();
+
+    /** @name Argument management
+     * @{ */
+    int  addArgument(const char *pszArgument);
+    int  addArgPair(const char *pszOption, const char *pszValue);
+    void resetArguments();
+    /** @} */
+
+    int  start(bool aKillProcessOnStop);
+    int  stop();
+    void detachFromServer();
+    bool isRunning();
+
+    RTPROCESS getPid() const;
+
+    /** @name Common options
+     * @{ */
+    static const char * const kpszKeyNetwork;
+    static const char * const kpszKeyTrunkType;
+    static const char * const kpszTrunkName;
+    static const char * const kpszMacAddress;
+    static const char * const kpszIpAddress;
+    static const char * const kpszIpNetmask;
+    static const char * const kpszKeyNeedMain;
+    /** @} */
+
+private:
+    struct Data;
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_NetworkServiceRunner_h */
+
diff --git a/src/VBox/Main/include/NvramStoreImpl.h b/src/VBox/Main/include/NvramStoreImpl.h
new file mode 100644
index 00000000..f863975b
--- /dev/null
+++ b/src/VBox/Main/include/NvramStoreImpl.h
@@ -0,0 +1,156 @@
+/* $Id: NvramStoreImpl.h $ */
+/** @file
+ * VirtualBox COM NVRAM store class implementation
+ */
+
+/*
+ * Copyright (C) 2021-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
+ */
+
+#ifndef MAIN_INCLUDED_NvramStoreImpl_h
+#define MAIN_INCLUDED_NvramStoreImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "NvramStoreWrap.h"
+#include "SecretKeyStore.h"
+#include <VBox/vmm/pdmdrv.h>
+#include <VBox/VBoxCryptoIf.h>
+
+
+#ifdef VBOX_COM_INPROC
+class Console;
+#else
+class GuestOSType;
+
+namespace settings
+{
+    struct NvramSettings;
+}
+#endif
+
+class ATL_NO_VTABLE NvramStore :
+    public NvramStoreWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(NvramStore)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+#ifdef VBOX_COM_INPROC
+    HRESULT init(Console *aParent, const com::Utf8Str &strNonVolatileStorageFile);
+#else
+    HRESULT init(Machine *parent);
+    HRESULT init(Machine *parent, NvramStore *that);
+    HRESULT initCopy(Machine *parent, NvramStore *that);
+#endif
+    void uninit();
+
+    // public methods for internal purposes only
+#ifndef VBOX_COM_INPROC
+    HRESULT i_loadSettings(const settings::NvramSettings &data);
+    HRESULT i_saveSettings(settings::NvramSettings &data);
+#endif
+
+#ifdef VBOX_COM_INPROC
+    static const PDMDRVREG  DrvReg;
+#else
+    void i_rollback();
+    void i_commit();
+    void i_copyFrom(NvramStore *aThat);
+    HRESULT i_applyDefaults(GuestOSType *aOSType);
+#endif
+
+    com::Utf8Str i_getNonVolatileStorageFile();
+    void i_updateNonVolatileStorageFile(const com::Utf8Str &aNonVolatileStorageFile);
+
+    int i_loadStore(const char *pszPath);
+    int i_saveStore(void);
+
+#ifndef VBOX_COM_INPROC
+    HRESULT i_retainUefiVarStore(PRTVFS phVfs, bool fReadonly);
+    HRESULT i_releaseUefiVarStore(RTVFS hVfs);
+#endif
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+    HRESULT i_updateEncryptionSettings(const com::Utf8Str &strKeyId,
+                                       const com::Utf8Str &strKeyStore);
+    HRESULT i_getEncryptionSettings(com::Utf8Str &strKeyId,
+                                    com::Utf8Str &strKeyStore);
+
+    int i_addPassword(const Utf8Str &strKeyId, const Utf8Str &strPassword);
+    int i_removePassword(const Utf8Str &strKeyId);
+    int i_removeAllPasswords();
+#endif
+
+private:
+
+    int initImpl(void);
+
+    // Wrapped NVRAM store properties
+    HRESULT getNonVolatileStorageFile(com::Utf8Str &aNonVolatileStorageFile);
+    HRESULT getUefiVariableStore(ComPtr<IUefiVariableStore> &aUefiVarStore);
+    HRESULT getKeyId(com::Utf8Str &aKeyId);
+    HRESULT getKeyStore(com::Utf8Str &aKeyStore);
+
+    // Wrapped NVRAM store members
+    HRESULT initUefiVariableStore(ULONG aSize);
+
+    int i_loadStoreFromTar(RTVFSFSSTREAM hVfsFssTar);
+    int i_saveStoreAsTar(const char *pszPath);
+
+    int i_retainCryptoIf(PCVBOXCRYPTOIF *ppCryptoIf);
+    int i_releaseCryptoIf(PCVBOXCRYPTOIF pCryptoIf);
+
+#ifdef VBOX_WITH_FULL_VM_ENCRYPTION
+    int i_setupEncryptionOrDecryption(RTVFSIOSTREAM hVfsIosInOut, bool fEncrypt,
+                                      PCVBOXCRYPTOIF *ppCryptoIf, SecretKey **ppKey,
+                                      PRTVFSIOSTREAM phVfsIos);
+    void i_releaseEncryptionOrDecryptionResources(RTVFSIOSTREAM hVfsIos, PCVBOXCRYPTOIF pCryptoIf,
+                                                  SecretKey *pKey);
+#endif
+
+#ifdef VBOX_COM_INPROC
+    static DECLCALLBACK(int)    i_SsmSaveExec(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM);
+    static DECLCALLBACK(int)    i_SsmLoadExec(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
+
+    static DECLCALLBACK(int)    i_nvramStoreQuerySize(PPDMIVFSCONNECTOR pInterface, const char *pszNamespace, const char *pszPath,
+                                                      uint64_t *pcb);
+    static DECLCALLBACK(int)    i_nvramStoreReadAll(PPDMIVFSCONNECTOR pInterface, const char *pszNamespace, const char *pszPath,
+                                                    void *pvBuf, size_t cbRead);
+    static DECLCALLBACK(int)    i_nvramStoreWriteAll(PPDMIVFSCONNECTOR pInterface, const char *pszNamespace, const char *pszPath,
+                                                     const void *pvBuf, size_t cbWrite);
+    static DECLCALLBACK(int)    i_nvramStoreDelete(PPDMIVFSCONNECTOR pInterface, const char *pszNamespace, const char *pszPath);
+    static DECLCALLBACK(void *) i_drvQueryInterface(PPDMIBASE pInterface, const char *pszIID);
+    static DECLCALLBACK(int)    i_drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
+    static DECLCALLBACK(void)   i_drvDestruct(PPDMDRVINS pDrvIns);
+#endif
+
+    struct Data;            // opaque data struct, defined in NvramStoreImpl.cpp
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_NvramStoreImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/ObjectState.h b/src/VBox/Main/include/ObjectState.h
new file mode 100644
index 00000000..8006fe5e
--- /dev/null
+++ b/src/VBox/Main/include/ObjectState.h
@@ -0,0 +1,150 @@
+/* $Id: ObjectState.h $ */
+/** @file
+ *
+ * VirtualBox object state handling definitions
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_ObjectState_h
+#define MAIN_INCLUDED_ObjectState_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "VBox/com/defs.h"
+#include "VBox/com/AutoLock.h"
+#include "VBox/com/ErrorInfo.h"
+
+// Forward declaration needed, but nothing more.
+class VirtualBoxBase;
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// ObjectState
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Thec functionality implemented by this class is the primary object state
+ * (used by VirtualBoxBase and thus part of all API classes) that indicates
+ * if the object is ready to serve the calls, and if not, what stage it is
+ * currently at. Here is the primary state diagram:
+ *
+ *              +-------------------------------------------------------+
+ *              |                                                       |
+ *              |         (InitFailed) -----------------------+         |
+ *              |              ^                              |         |
+ *              v              |                              v         |
+ *  [*] ---> NotReady ----> (InInit) -----> Ready -----> (InUninit) ----+
+ *                     ^       |
+ *                     |       v
+ *                     |    Limited
+ *                     |       |
+ *                     +-------+
+ *
+ * The object is fully operational only when its state is Ready. The Limited
+ * state means that only some vital part of the object is operational, and it
+ * requires some sort of reinitialization to become fully operational. The
+ * NotReady state means the object is basically dead: it either was not yet
+ * initialized after creation at all, or was uninitialized and is waiting to be
+ * destroyed when the last reference to it is released. All other states are
+ * transitional.
+ *
+ * The NotReady->InInit->Ready, NotReady->InInit->Limited and
+ * NotReady->InInit->InitFailed transition is done by the AutoInitSpan smart
+ * class.
+ *
+ * The Limited->InInit->Ready, Limited->InInit->Limited and
+ * Limited->InInit->InitFailed transition is done by the AutoReinitSpan smart
+ * class.
+ *
+ * The Ready->InUninit->NotReady and InitFailed->InUninit->NotReady
+ * transitions are done by the AutoUninitSpan smart class.
+ *
+ * In order to maintain the primary state integrity and declared functionality
+ * the following rules apply everywhere:
+ *
+ * 1) Use the above Auto*Span classes to perform state transitions. See the
+ *    individual class descriptions for details.
+ *
+ * 2) All public methods of subclasses (i.e. all methods that can be called
+ *    directly, not only from within other methods of the subclass) must have a
+ *    standard prolog as described in the AutoCaller and AutoLimitedCaller
+ *    documentation. Alternatively, they must use #addCaller() and
+ *    #releaseCaller() directly (and therefore have both the prolog and the
+ *    epilog), but this is not recommended because it is easy to forget the
+ *    matching release, e.g. returning before reaching the call.
+ */
+class ObjectState
+{
+public:
+    enum State { NotReady, Ready, InInit, InUninit, InitFailed, Limited };
+
+    ObjectState(VirtualBoxBase *aObj);
+    ~ObjectState();
+
+    State getState();
+
+    HRESULT addCaller(bool aLimited = false);
+    void releaseCaller();
+
+    bool autoInitSpanConstructor(State aExpectedState);
+    void autoInitSpanDestructor(State aNewState, HRESULT aFailedRC, com::ErrorInfo *aFailedEI);
+    State autoUninitSpanConstructor(bool fTry);
+    void autoUninitSpanDestructor();
+
+private:
+    ObjectState();
+
+    void setState(State aState);
+
+    /** Pointer to the managed object, mostly for error signalling or debugging
+     * purposes, not used much. Guaranteed to be valid during the lifetime of
+     * this object, no need to mess with refcount. */
+    VirtualBoxBase *mObj;
+    /** Primary state of this object */
+    State mState;
+    /** Thread that caused the last state change */
+    RTTHREAD mStateChangeThread;
+    /** Result code for failed object initialization */
+    HRESULT mFailedRC;
+    /** Error information for failed object initialization */
+    com::ErrorInfo *mpFailedEI;
+    /** Total number of active calls to this object */
+    unsigned mCallers;
+    /** Posted when the number of callers drops to zero */
+    RTSEMEVENT mZeroCallersSem;
+    /** Posted when the object goes from InInit/InUninit to some other state */
+    RTSEMEVENTMULTI mInitUninitSem;
+    /** Number of threads waiting for mInitUninitDoneSem */
+    unsigned mInitUninitWaiters;
+
+    /** Protects access to state related data members */
+    util::RWLockHandle mStateLock;
+
+private:
+    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(ObjectState); /* Shuts up MSC warning C4625. */
+};
+
+#endif /* !MAIN_INCLUDED_ObjectState_h */
diff --git a/src/VBox/Main/include/PCIDeviceAttachmentImpl.h b/src/VBox/Main/include/PCIDeviceAttachmentImpl.h
new file mode 100644
index 00000000..ca3cbbed
--- /dev/null
+++ b/src/VBox/Main/include/PCIDeviceAttachmentImpl.h
@@ -0,0 +1,79 @@
+/* $Id: PCIDeviceAttachmentImpl.h $ */
+
+/** @file
+ *
+ * PCI attachment information implmentation.
+ */
+
+/*
+ * Copyright (C) 2010-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
+ */
+
+#ifndef MAIN_INCLUDED_PCIDeviceAttachmentImpl_h
+#define MAIN_INCLUDED_PCIDeviceAttachmentImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "PCIDeviceAttachmentWrap.h"
+
+namespace settings
+{
+    struct HostPCIDeviceAttachment;
+}
+
+class ATL_NO_VTABLE PCIDeviceAttachment :
+    public PCIDeviceAttachmentWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(PCIDeviceAttachment)
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(IMachine *    aParent,
+                 const Utf8Str &aDevName,
+                 LONG          aHostAddess,
+                 LONG          aGuestAddress,
+                 BOOL          fPhysical);
+    HRESULT initCopy(IMachine *aParent, PCIDeviceAttachment *aThat);
+    void uninit();
+
+    // settings
+    HRESULT i_loadSettings(IMachine * aParent,
+                           const settings::HostPCIDeviceAttachment& aHpda);
+    HRESULT i_saveSettings(settings::HostPCIDeviceAttachment &data);
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+private:
+
+    // wrapped IPCIDeviceAttachment properties
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT getIsPhysicalDevice(BOOL *aIsPhysicalDevice);
+    HRESULT getHostAddress(LONG *aHostAddress);
+    HRESULT getGuestAddress(LONG *aGuestAddress);
+
+    struct Data;
+    Data*  m;
+};
+
+#endif /* !MAIN_INCLUDED_PCIDeviceAttachmentImpl_h */
diff --git a/src/VBox/Main/include/PCIRawDevImpl.h b/src/VBox/Main/include/PCIRawDevImpl.h
new file mode 100644
index 00000000..717937f4
--- /dev/null
+++ b/src/VBox/Main/include/PCIRawDevImpl.h
@@ -0,0 +1,64 @@
+/* $Id: PCIRawDevImpl.h $ */
+/** @file
+ * VirtualBox Driver interface to raw PCI device
+ */
+
+/*
+ * Copyright (C) 2010-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
+ */
+
+#ifndef MAIN_INCLUDED_PCIRawDevImpl_h
+#define MAIN_INCLUDED_PCIRawDevImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/vmm/pdmdrv.h>
+
+class Console;
+struct DRVMAINPCIRAWDEV;
+
+class PCIRawDev
+{
+  public:
+    PCIRawDev(Console *console);
+    virtual ~PCIRawDev();
+
+    static const PDMDRVREG DrvReg;
+
+    Console *getParent() const
+    {
+        return mParent;
+    }
+
+  private:
+    static DECLCALLBACK(void *) drvQueryInterface(PPDMIBASE pInterface, const char *pszIID);
+    static DECLCALLBACK(int)    drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
+    static DECLCALLBACK(void)   drvDestruct(PPDMDRVINS pDrvIns);
+    static DECLCALLBACK(int)    drvDeviceConstructComplete(PPDMIPCIRAWCONNECTOR pInterface, const char *pcszName,
+                                                           uint32_t uHostPCIAddress, uint32_t uGuestPCIAddress,
+                                                           int vrc);
+
+    Console * const mParent;
+    struct DRVMAINPCIRAWDEV *mpDrv;
+};
+
+#endif /* !MAIN_INCLUDED_PCIRawDevImpl_h */
diff --git a/src/VBox/Main/include/ParallelPortImpl.h b/src/VBox/Main/include/ParallelPortImpl.h
new file mode 100644
index 00000000..72c4ea49
--- /dev/null
+++ b/src/VBox/Main/include/ParallelPortImpl.h
@@ -0,0 +1,87 @@
+/* $Id: ParallelPortImpl.h $ */
+
+/** @file
+ * VirtualBox COM class implementation.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_ParallelPortImpl_h
+#define MAIN_INCLUDED_ParallelPortImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "ParallelPortWrap.h"
+
+namespace settings
+{
+    struct ParallelPort;
+}
+
+class ATL_NO_VTABLE ParallelPort :
+    public ParallelPortWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(ParallelPort)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Machine *aParent, ULONG aSlot);
+    HRESULT init(Machine *aParent, ParallelPort *aThat);
+    HRESULT initCopy(Machine *parent, ParallelPort *aThat);
+    void uninit();
+
+    HRESULT i_loadSettings(const settings::ParallelPort &data);
+    HRESULT i_saveSettings(settings::ParallelPort &data);
+
+    // public methods only for internal purposes
+    bool i_isModified();
+    void i_rollback();
+    void i_commit();
+    void i_copyFrom(ParallelPort *aThat);
+    void i_applyDefaults();
+    bool i_hasDefaults();
+
+private:
+
+    // Wrapped IParallelPort properties
+    HRESULT getEnabled(BOOL *aEnabled);
+    HRESULT setEnabled(BOOL aEnabled);
+    HRESULT getSlot(ULONG *aSlot);
+    HRESULT getIRQ(ULONG *aIRQ);
+    HRESULT setIRQ(ULONG aIRQ);
+    HRESULT getIOBase(ULONG *aIOBase);
+    HRESULT setIOBase(ULONG aIOBase);
+    HRESULT getPath(com::Utf8Str &aPath);
+    HRESULT setPath(const com::Utf8Str &aPath);
+
+    struct Data;
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_ParallelPortImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/Performance.h b/src/VBox/Main/include/Performance.h
new file mode 100644
index 00000000..e8d1fa1a
--- /dev/null
+++ b/src/VBox/Main/include/Performance.h
@@ -0,0 +1,915 @@
+/* $Id: Performance.h $ */
+/** @file
+ * VirtualBox Main - Performance Classes declaration.
+ */
+
+/*
+ * Copyright (C) 2008-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
+ */
+
+#ifndef MAIN_INCLUDED_Performance_h
+#define MAIN_INCLUDED_Performance_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/com/defs.h>
+#include <VBox/com/ptr.h>
+#include <VBox/com/string.h>
+#include <VBox/com/VirtualBox.h>
+
+#include <iprt/types.h>
+#include <iprt/err.h>
+#include <iprt/cpp/lock.h>
+
+#include <algorithm>
+#include <functional> /* For std::fun_ptr in testcase */
+#include <list>
+#include <vector>
+#include <queue>
+
+#include "MediumImpl.h"
+
+/* Forward decl. */
+class Machine;
+
+namespace pm
+{
+    /* CPU load is measured in 1/1000 of per cent. */
+    const uint64_t PM_CPU_LOAD_MULTIPLIER = UINT64_C(100000);
+    /* Network load is measured in 1/1000 of per cent. */
+    const uint64_t PM_NETWORK_LOAD_MULTIPLIER = UINT64_C(100000);
+    /* Disk load is measured in 1/1000 of per cent. */
+    const uint64_t PM_DISK_LOAD_MULTIPLIER = UINT64_C(100000);
+    /* Sampler precision in milliseconds. */
+    const uint64_t PM_SAMPLER_PRECISION_MS = 50;
+
+    /* Sub Metrics **********************************************************/
+    class CircularBuffer
+    {
+    public:
+        CircularBuffer() : mData(0), mLength(0), mEnd(0), mWrapped(false) {};
+        ~CircularBuffer() { if (mData) RTMemFree(mData); };
+        void init(ULONG length);
+        ULONG length();
+        ULONG getSequenceNumber() { return mSequenceNumber; }
+        void put(ULONG value);
+        void copyTo(ULONG *data);
+    private:
+        ULONG *mData;
+        ULONG  mLength;
+        ULONG  mEnd;
+        ULONG  mSequenceNumber;
+        bool   mWrapped;
+    };
+
+    class SubMetric : public CircularBuffer
+    {
+    public:
+        SubMetric(com::Utf8Str name, const char *description)
+        : mName(name), mDescription(description) {};
+        void query(ULONG *data);
+        const char *getName() { return mName.c_str(); };
+        const char *getDescription() { return mDescription; };
+    private:
+        const com::Utf8Str mName;
+        const char *mDescription;
+    };
+
+
+    enum {
+        COLLECT_NONE        = 0x0,
+        COLLECT_CPU_LOAD    = 0x1,
+        COLLECT_RAM_USAGE   = 0x2,
+        COLLECT_GUEST_STATS = 0x4
+    };
+    typedef int HintFlags;
+    typedef std::pair<RTPROCESS, HintFlags> ProcessFlagsPair;
+
+    class CollectorHints
+    {
+    public:
+        typedef std::list<ProcessFlagsPair> ProcessList;
+
+        CollectorHints() : mHostFlags(COLLECT_NONE) {}
+        void collectHostCpuLoad()
+            { mHostFlags |= COLLECT_CPU_LOAD; }
+        void collectHostRamUsage()
+            { mHostFlags |= COLLECT_RAM_USAGE; }
+        void collectHostRamVmm()
+            { mHostFlags |= COLLECT_GUEST_STATS; }
+        void collectProcessCpuLoad(RTPROCESS process)
+            { findProcess(process).second |= COLLECT_CPU_LOAD; }
+        void collectProcessRamUsage(RTPROCESS process)
+            { findProcess(process).second |= COLLECT_RAM_USAGE; }
+        void collectGuestStats(RTPROCESS process)
+            { findProcess(process).second |= COLLECT_GUEST_STATS; }
+        bool isHostCpuLoadCollected() const
+            { return (mHostFlags & COLLECT_CPU_LOAD) != 0; }
+        bool isHostRamUsageCollected() const
+            { return (mHostFlags & COLLECT_RAM_USAGE) != 0; }
+        bool isHostRamVmmCollected() const
+            { return (mHostFlags & COLLECT_GUEST_STATS) != 0; }
+        bool isProcessCpuLoadCollected(RTPROCESS process)
+            { return (findProcess(process).second & COLLECT_CPU_LOAD) != 0; }
+        bool isProcessRamUsageCollected(RTPROCESS process)
+            { return (findProcess(process).second & COLLECT_RAM_USAGE) != 0; }
+        bool isGuestStatsCollected(RTPROCESS process)
+            { return (findProcess(process).second & COLLECT_GUEST_STATS) != 0; }
+        void getProcesses(std::vector<RTPROCESS>& processes) const
+        {
+            processes.clear();
+            processes.reserve(mProcesses.size());
+            for (ProcessList::const_iterator it = mProcesses.begin(); it != mProcesses.end(); ++it)
+                processes.push_back(it->first);
+        }
+        const ProcessList& getProcessFlags() const
+        {
+            return mProcesses;
+        }
+    private:
+        HintFlags   mHostFlags;
+        ProcessList mProcesses;
+
+        ProcessFlagsPair& findProcess(RTPROCESS process)
+        {
+            ProcessList::iterator it;
+            for (it = mProcesses.begin(); it != mProcesses.end(); ++it)
+                if (it->first == process)
+                    return *it;
+
+            /* Not found -- add new */
+            mProcesses.push_back(ProcessFlagsPair(process, COLLECT_NONE));
+            return mProcesses.back();
+        }
+    };
+
+    /* Guest Collector Classes  *********************************/
+    /*
+     * WARNING! The bits in the following masks must correspond to parameters
+     * of CollectorGuest::updateStats().
+     */
+    typedef enum
+    {
+        VMSTATMASK_NONE             = 0x00000000,
+        VMSTATMASK_GUEST_CPUUSER    = 0x00000001,
+        VMSTATMASK_GUEST_CPUKERNEL  = 0x00000002,
+        VMSTATMASK_GUEST_CPUIDLE    = 0x00000004,
+        VMSTATMASK_GUEST_MEMTOTAL   = 0x00000008,
+        VMSTATMASK_GUEST_MEMFREE    = 0x00000010,
+        VMSTATMASK_GUEST_MEMBALLOON = 0x00000020,
+        VMSTATMASK_GUEST_MEMSHARED  = 0x00000040,
+        VMSTATMASK_GUEST_MEMCACHE   = 0x00000080,
+        VMSTATMASK_GUEST_PAGETOTAL  = 0x00000100,
+        VMSTATMASK_VMM_ALLOC        = 0x00010000,
+        VMSTATMASK_VMM_FREE         = 0x00020000,
+        VMSTATMASK_VMM_BALOON       = 0x00040000,
+        VMSTATMASK_VMM_SHARED       = 0x00080000,
+        VMSTATMASK_NET_RX           = 0x01000000,
+        VMSTATMASK_NET_TX           = 0x02000000
+    } VMSTATMASK;
+
+    const ULONG VMSTATS_GUEST_CPULOAD =
+        VMSTATMASK_GUEST_CPUUSER    | VMSTATMASK_GUEST_CPUKERNEL |
+        VMSTATMASK_GUEST_CPUIDLE;
+    const ULONG VMSTATS_GUEST_RAMUSAGE =
+        VMSTATMASK_GUEST_MEMTOTAL   | VMSTATMASK_GUEST_MEMFREE |
+        VMSTATMASK_GUEST_MEMBALLOON | VMSTATMASK_GUEST_MEMSHARED |
+        VMSTATMASK_GUEST_MEMCACHE   | VMSTATMASK_GUEST_PAGETOTAL;
+    const ULONG VMSTATS_VMM_RAM =
+        VMSTATMASK_VMM_ALLOC        | VMSTATMASK_VMM_FREE|
+        VMSTATMASK_VMM_BALOON       | VMSTATMASK_VMM_SHARED;
+    const ULONG VMSTATS_NET_RATE =
+        VMSTATMASK_NET_RX           | VMSTATMASK_NET_TX;
+    const ULONG VMSTATS_ALL =
+        VMSTATS_GUEST_CPULOAD       | VMSTATS_GUEST_RAMUSAGE |
+        VMSTATS_VMM_RAM             | VMSTATS_NET_RATE;
+    class CollectorGuest;
+
+    class CollectorGuestRequest
+    {
+    public:
+        CollectorGuestRequest()
+            : mCGuest(0) {};
+        virtual ~CollectorGuestRequest() {};
+        void setGuest(CollectorGuest *aGuest) { mCGuest = aGuest; };
+        CollectorGuest *getGuest() { return mCGuest; };
+        virtual HRESULT execute() = 0;
+
+        virtual void debugPrint(void *aObject, const char *aFunction, const char *aText) = 0;
+    protected:
+        CollectorGuest *mCGuest;
+        const char *mDebugName;
+    };
+
+    class CGRQEnable : public CollectorGuestRequest
+    {
+    public:
+        CGRQEnable(ULONG aMask)
+            : mMask(aMask) {};
+        HRESULT execute();
+
+        void debugPrint(void *aObject, const char *aFunction, const char *aText);
+    private:
+        ULONG mMask;
+    };
+
+    class CGRQDisable : public CollectorGuestRequest
+    {
+    public:
+        CGRQDisable(ULONG aMask)
+            : mMask(aMask) {};
+        HRESULT execute();
+
+        void debugPrint(void *aObject, const char *aFunction, const char *aText);
+    private:
+        ULONG mMask;
+    };
+
+    class CGRQAbort : public CollectorGuestRequest
+    {
+    public:
+        CGRQAbort() {};
+        HRESULT execute();
+
+        void debugPrint(void *aObject, const char *aFunction, const char *aText);
+    };
+
+    class CollectorGuestQueue
+    {
+    public:
+        CollectorGuestQueue();
+        ~CollectorGuestQueue();
+        void push(CollectorGuestRequest* rq);
+        CollectorGuestRequest* pop();
+    private:
+        RTCLockMtx mLockMtx;
+        RTSEMEVENT mEvent;
+        std::queue<CollectorGuestRequest*> mQueue;
+    };
+
+    class CollectorGuestManager;
+
+    class CollectorGuest
+    {
+    public:
+        CollectorGuest(Machine *machine, RTPROCESS process);
+        ~CollectorGuest();
+
+        void setManager(CollectorGuestManager *aManager)
+                                    { mManager = aManager; };
+        bool isUnregistered()       { return mUnregistered; };
+        bool isEnabled()            { return mEnabled != 0; };
+        bool isValid(ULONG mask)    { return (mValid & mask) == mask; };
+        void invalidate(ULONG mask) { mValid &= ~mask; };
+        void unregister()           { mUnregistered = true; };
+        void updateStats(ULONG aValidStats, ULONG aCpuUser,
+                         ULONG aCpuKernel, ULONG aCpuIdle,
+                         ULONG aMemTotal, ULONG aMemFree,
+                         ULONG aMemBalloon, ULONG aMemShared,
+                         ULONG aMemCache, ULONG aPageTotal,
+                         ULONG aAllocVMM, ULONG aFreeVMM,
+                         ULONG aBalloonedVMM, ULONG aSharedVMM,
+                         ULONG aVmNetRx, ULONG aVmNetTx);
+        HRESULT enable(ULONG mask);
+        HRESULT disable(ULONG mask);
+
+        HRESULT enqueueRequest(CollectorGuestRequest *aRequest);
+        HRESULT enableInternal(ULONG mask);
+        HRESULT disableInternal(ULONG mask);
+
+        const com::Utf8Str& getVMName() const { return mMachineName; };
+
+        RTPROCESS getProcess()  { return mProcess; };
+        ULONG getCpuUser()      { return mCpuUser; };
+        ULONG getCpuKernel()    { return mCpuKernel; };
+        ULONG getCpuIdle()      { return mCpuIdle; };
+        ULONG getMemTotal()     { return mMemTotal; };
+        ULONG getMemFree()      { return mMemFree; };
+        ULONG getMemBalloon()   { return mMemBalloon; };
+        ULONG getMemShared()    { return mMemShared; };
+        ULONG getMemCache()     { return mMemCache; };
+        ULONG getPageTotal()    { return mPageTotal; };
+        ULONG getAllocVMM()     { return mAllocVMM; };
+        ULONG getFreeVMM()      { return mFreeVMM; };
+        ULONG getBalloonedVMM() { return mBalloonedVMM; };
+        ULONG getSharedVMM()    { return mSharedVMM; };
+        ULONG getVmNetRx()      { return mVmNetRx; };
+        ULONG getVmNetTx()      { return mVmNetTx; };
+
+    private:
+        HRESULT enableVMMStats(bool mCollectVMMStats);
+
+        CollectorGuestManager *mManager;
+
+        bool                 mUnregistered;
+        ULONG                mEnabled;
+        ULONG                mValid;
+        Machine             *mMachine;
+        com::Utf8Str         mMachineName;
+        RTPROCESS            mProcess;
+        ComPtr<IConsole>     mConsole;
+        ComPtr<IGuest>       mGuest;
+        ULONG                mCpuUser;
+        ULONG                mCpuKernel;
+        ULONG                mCpuIdle;
+        ULONG                mMemTotal;
+        ULONG                mMemFree;
+        ULONG                mMemBalloon;
+        ULONG                mMemShared;
+        ULONG                mMemCache;
+        ULONG                mPageTotal;
+        ULONG                mAllocVMM;
+        ULONG                mFreeVMM;
+        ULONG                mBalloonedVMM;
+        ULONG                mSharedVMM;
+        ULONG                mVmNetRx;
+        ULONG                mVmNetTx;
+    };
+
+    typedef std::list<CollectorGuest*> CollectorGuestList;
+    class CollectorGuestManager
+    {
+    public:
+        CollectorGuestManager();
+        ~CollectorGuestManager();
+        void registerGuest(CollectorGuest* pGuest);
+        void unregisterGuest(CollectorGuest* pGuest);
+        CollectorGuest *getVMMStatsProvider() { return mVMMStatsProvider; };
+        void preCollect(CollectorHints& hints, uint64_t iTick);
+        void destroyUnregistered();
+        HRESULT enqueueRequest(CollectorGuestRequest *aRequest);
+
+        CollectorGuest *getBlockedGuest() { return mGuestBeingCalled; };
+
+        static DECLCALLBACK(int) requestProcessingThread(RTTHREAD aThread, void *pvUser);
+    private:
+        RTTHREAD            mThread;
+        CollectorGuestList  mGuests;
+        CollectorGuest     *mVMMStatsProvider;
+        CollectorGuestQueue mQueue;
+        CollectorGuest     *mGuestBeingCalled;
+    };
+
+    /* Collector Hardware Abstraction Layer *********************************/
+    typedef std::list<RTCString> DiskList;
+
+    class CollectorHAL
+    {
+    public:
+                 CollectorHAL() {};
+        virtual ~CollectorHAL() { };
+        virtual int preCollect(const CollectorHints& /* hints */, uint64_t /* iTick */) { return VINF_SUCCESS; }
+        /** Returns averaged CPU usage in 1/1000th per cent across all host's CPUs. */
+        virtual int getHostCpuLoad(ULONG *user, ULONG *kernel, ULONG *idle);
+        /** Returns the average frequency in MHz across all host's CPUs. */
+        virtual int getHostCpuMHz(ULONG *mhz);
+        /** Returns the amount of physical memory in kilobytes. */
+        virtual int getHostMemoryUsage(ULONG *total, ULONG *used, ULONG *available);
+        /** Returns file system counters in megabytes. */
+        virtual int getHostFilesystemUsage(const char *name, ULONG *total, ULONG *used, ULONG *available);
+        /** Returns disk size in bytes. */
+        virtual int getHostDiskSize(const char *name, uint64_t *size);
+        /** Returns CPU usage in 1/1000th per cent by a particular process. */
+        virtual int getProcessCpuLoad(RTPROCESS process, ULONG *user, ULONG *kernel);
+        /** Returns the amount of memory used by a process in kilobytes. */
+        virtual int getProcessMemoryUsage(RTPROCESS process, ULONG *used);
+
+        /** Returns CPU usage counters in platform-specific units. */
+        virtual int getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle);
+        /** Returns received and transmitted bytes. */
+        virtual int getRawHostNetworkLoad(const char *name, uint64_t *rx, uint64_t *tx);
+        /** Returns disk usage counters in platform-specific units. */
+        virtual int getRawHostDiskLoad(const char *name, uint64_t *disk_ms, uint64_t *total_ms);
+        /** Returns process' CPU usage counter in platform-specific units. */
+        virtual int getRawProcessCpuLoad(RTPROCESS process, uint64_t *user, uint64_t *kernel, uint64_t *total);
+
+        /** Returns the lists of disks (aggregate and physical) used by the specified file system. */
+        virtual int getDiskListByFs(const char *name, DiskList& listUsage, DiskList& listLoad);
+    };
+
+    extern CollectorHAL *createHAL();
+
+    /* Base Metrics *********************************************************/
+    class BaseMetric
+    {
+    public:
+        BaseMetric(CollectorHAL *hal, const com::Utf8Str name, ComPtr<IUnknown> object)
+            : mPeriod(0), mLength(0), mHAL(hal), mName(name), mObject(object),
+              mLastSampleTaken(0), mEnabled(false), mUnregistered(false) {};
+        virtual ~BaseMetric() {};
+
+        virtual void init(ULONG period, ULONG length) = 0;
+        virtual void preCollect(CollectorHints& hints, uint64_t iTick) = 0;
+        virtual void collect() = 0;
+        virtual const char *getUnit() = 0;
+        virtual ULONG getMinValue() = 0;
+        virtual ULONG getMaxValue() = 0;
+        virtual ULONG getScale() = 0;
+
+        bool collectorBeat(uint64_t nowAt);
+
+        virtual HRESULT enable()  { mEnabled = true; return S_OK; };
+        virtual HRESULT disable() { mEnabled = false; return S_OK; };
+        void unregister() { mUnregistered = true; };
+
+        bool isUnregistered() { return mUnregistered; };
+        bool isEnabled() { return mEnabled; };
+        ULONG getPeriod() { return mPeriod; };
+        ULONG getLength() { return mLength; };
+        const char *getName() { return mName.c_str(); };
+        ComPtr<IUnknown> getObject() { return mObject; };
+        bool associatedWith(ComPtr<IUnknown> object) { return mObject == object; };
+
+    protected:
+        ULONG           mPeriod;
+        ULONG           mLength;
+        CollectorHAL    *mHAL;
+        const com::Utf8Str mName;
+        ComPtr<IUnknown> mObject;
+        uint64_t         mLastSampleTaken;
+        bool             mEnabled;
+        bool             mUnregistered;
+    };
+
+    class BaseGuestMetric : public BaseMetric
+    {
+    public:
+        BaseGuestMetric(CollectorGuest *cguest, const char *name, ComPtr<IUnknown> object)
+            : BaseMetric(NULL, name, object), mCGuest(cguest) {};
+    protected:
+        CollectorGuest *mCGuest;
+    };
+
+    class HostCpuLoad : public BaseMetric
+    {
+    public:
+        HostCpuLoad(CollectorHAL *hal, ComPtr<IUnknown> object, SubMetric *user, SubMetric *kernel, SubMetric *idle)
+        : BaseMetric(hal, "CPU/Load", object), mUser(user), mKernel(kernel), mIdle(idle) {};
+        ~HostCpuLoad() { delete mUser; delete mKernel; delete mIdle; };
+
+        void init(ULONG period, ULONG length);
+
+        void collect();
+        const char *getUnit() { return "%"; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return PM_CPU_LOAD_MULTIPLIER; };
+        ULONG getScale() { return PM_CPU_LOAD_MULTIPLIER / 100; }
+
+    protected:
+        SubMetric *mUser;
+        SubMetric *mKernel;
+        SubMetric *mIdle;
+    };
+
+    class HostCpuLoadRaw : public HostCpuLoad
+    {
+    public:
+        HostCpuLoadRaw(CollectorHAL *hal, ComPtr<IUnknown> object, SubMetric *user, SubMetric *kernel, SubMetric *idle)
+        : HostCpuLoad(hal, object, user, kernel, idle), mUserPrev(0), mKernelPrev(0), mIdlePrev(0) {};
+
+        void init(ULONG period, ULONG length);
+        void preCollect(CollectorHints& hints, uint64_t iTick);
+        void collect();
+    private:
+        uint64_t mUserPrev;
+        uint64_t mKernelPrev;
+        uint64_t mIdlePrev;
+    };
+
+    class HostCpuMhz : public BaseMetric
+    {
+    public:
+        HostCpuMhz(CollectorHAL *hal, ComPtr<IUnknown> object, SubMetric *mhz)
+        : BaseMetric(hal, "CPU/MHz", object), mMHz(mhz) {};
+        ~HostCpuMhz() { delete mMHz; };
+
+        void init(ULONG period, ULONG length);
+        void preCollect(CollectorHints& /* hints */, uint64_t /* iTick */) {}
+        void collect();
+        const char *getUnit() { return "MHz"; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return INT32_MAX; };
+        ULONG getScale() { return 1; }
+    private:
+        SubMetric *mMHz;
+    };
+
+    class HostRamUsage : public BaseMetric
+    {
+    public:
+        HostRamUsage(CollectorHAL *hal, ComPtr<IUnknown> object, SubMetric *total, SubMetric *used, SubMetric *available)
+        : BaseMetric(hal, "RAM/Usage", object), mTotal(total), mUsed(used), mAvailable(available) {};
+        ~HostRamUsage() { delete mTotal; delete mUsed; delete mAvailable; };
+
+        void init(ULONG period, ULONG length);
+        void preCollect(CollectorHints& hints, uint64_t iTick);
+        void collect();
+        const char *getUnit() { return "kB"; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return INT32_MAX; };
+        ULONG getScale() { return 1; }
+    private:
+        SubMetric *mTotal;
+        SubMetric *mUsed;
+        SubMetric *mAvailable;
+    };
+
+    class HostNetworkSpeed : public BaseMetric
+    {
+    public:
+        HostNetworkSpeed(CollectorHAL *hal, ComPtr<IUnknown> object, com::Utf8Str name, com::Utf8Str shortname, com::Utf8Str /* ifname */, uint32_t speed, SubMetric *linkspeed)
+        : BaseMetric(hal, name, object), mShortName(shortname), mSpeed(speed), mLinkSpeed(linkspeed) {};
+        ~HostNetworkSpeed() { delete mLinkSpeed; };
+
+        void init(ULONG period, ULONG length);
+
+        void preCollect(CollectorHints& /* hints */, uint64_t /* iTick */) {};
+        void collect() { if (mSpeed) mLinkSpeed->put(mSpeed); };
+        const char *getUnit() { return "mbit/s"; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return INT32_MAX; };
+        ULONG getScale() { return 1; }
+    private:
+        com::Utf8Str mShortName;
+        uint32_t     mSpeed;
+        SubMetric   *mLinkSpeed;
+    };
+
+    class HostNetworkLoadRaw : public BaseMetric
+    {
+    public:
+        HostNetworkLoadRaw(CollectorHAL *hal, ComPtr<IUnknown> object, com::Utf8Str name, com::Utf8Str shortname, com::Utf8Str ifname, uint32_t speed, SubMetric *rx, SubMetric *tx)
+            : BaseMetric(hal, name, object), mShortName(shortname), mInterfaceName(ifname), mRx(rx), mTx(tx), mRxPrev(0), mTxPrev(0), mRc(VINF_SUCCESS) { mSpeed = (uint64_t)speed * (1000000/8); /* Convert to bytes/sec */ };
+        ~HostNetworkLoadRaw() { delete mRx; delete mTx; };
+
+        void init(ULONG period, ULONG length);
+
+        void preCollect(CollectorHints& hints, uint64_t iTick);
+        void collect();
+        const char *getUnit() { return "%"; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return PM_NETWORK_LOAD_MULTIPLIER; };
+        ULONG getScale() { return PM_NETWORK_LOAD_MULTIPLIER / 100; }
+
+    private:
+        com::Utf8Str  mShortName;
+        com::Utf8Str  mInterfaceName;
+        SubMetric    *mRx;
+        SubMetric    *mTx;
+        uint64_t      mRxPrev;
+        uint64_t      mTxPrev;
+        uint64_t      mSpeed;
+        int           mRc;
+    };
+
+    class HostFilesystemUsage : public BaseMetric
+    {
+    public:
+        HostFilesystemUsage(CollectorHAL *hal, ComPtr<IUnknown> object, com::Utf8Str name, com::Utf8Str fsname, SubMetric *total, SubMetric *used, SubMetric *available)
+            : BaseMetric(hal, name, object), mFsName(fsname), mTotal(total), mUsed(used), mAvailable(available) {};
+        ~HostFilesystemUsage() { delete mTotal; delete mUsed; delete mAvailable; };
+
+        void init(ULONG period, ULONG length);
+        void preCollect(CollectorHints& hints, uint64_t iTick);
+        void collect();
+        const char *getUnit() { return "MB"; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return INT32_MAX; };
+        ULONG getScale() { return 1; }
+    private:
+        com::Utf8Str mFsName;
+        SubMetric   *mTotal;
+        SubMetric   *mUsed;
+        SubMetric   *mAvailable;
+    };
+
+    class HostDiskUsage : public BaseMetric
+    {
+    public:
+        HostDiskUsage(CollectorHAL *hal, ComPtr<IUnknown> object, com::Utf8Str name, com::Utf8Str diskname, SubMetric *total)
+            : BaseMetric(hal, name, object), mDiskName(diskname), mTotal(total) {};
+        ~HostDiskUsage() { delete mTotal; };
+
+        void init(ULONG period, ULONG length);
+        void preCollect(CollectorHints& hints, uint64_t iTick);
+        void collect();
+        const char *getUnit() { return "MB"; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return INT32_MAX; };
+        ULONG getScale() { return 1; }
+    private:
+        com::Utf8Str mDiskName;
+        SubMetric   *mTotal;
+    };
+
+    class HostDiskLoadRaw : public BaseMetric
+    {
+    public:
+        HostDiskLoadRaw(CollectorHAL *hal, ComPtr<IUnknown> object, com::Utf8Str name, com::Utf8Str diskname, SubMetric *util)
+            : BaseMetric(hal, name, object), mDiskName(diskname), mUtil(util), mDiskPrev(0), mTotalPrev(0) {};
+        ~HostDiskLoadRaw() { delete mUtil; };
+
+        void init(ULONG period, ULONG length);
+
+        void preCollect(CollectorHints& hints, uint64_t iTick);
+        void collect();
+        const char *getUnit() { return "%"; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return PM_DISK_LOAD_MULTIPLIER; };
+        ULONG getScale() { return PM_DISK_LOAD_MULTIPLIER / 100; }
+
+    private:
+        com::Utf8Str  mDiskName;
+        SubMetric    *mUtil;
+        uint64_t      mDiskPrev;
+        uint64_t      mTotalPrev;
+    };
+
+
+#ifndef VBOX_COLLECTOR_TEST_CASE
+    class HostRamVmm : public BaseMetric
+    {
+    public:
+        HostRamVmm(CollectorGuestManager *gm, ComPtr<IUnknown> object, SubMetric *allocVMM, SubMetric *freeVMM, SubMetric *balloonVMM, SubMetric *sharedVMM)
+            : BaseMetric(NULL, "RAM/VMM", object), mCollectorGuestManager(gm),
+            mAllocVMM(allocVMM), mFreeVMM(freeVMM), mBalloonVMM(balloonVMM), mSharedVMM(sharedVMM),
+            mAllocCurrent(0), mFreeCurrent(0), mBalloonedCurrent(0), mSharedCurrent(0) {};
+        ~HostRamVmm() { delete mAllocVMM; delete mFreeVMM; delete mBalloonVMM; delete mSharedVMM; };
+
+        void init(ULONG period, ULONG length);
+        void preCollect(CollectorHints& hints, uint64_t iTick);
+        void collect();
+        HRESULT enable();
+        HRESULT disable();
+        const char *getUnit() { return "kB"; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return INT32_MAX; };
+        ULONG getScale() { return 1; }
+
+    private:
+        CollectorGuestManager *mCollectorGuestManager;
+        SubMetric             *mAllocVMM;
+        SubMetric             *mFreeVMM;
+        SubMetric             *mBalloonVMM;
+        SubMetric             *mSharedVMM;
+        ULONG                  mAllocCurrent;
+        ULONG                  mFreeCurrent;
+        ULONG                  mBalloonedCurrent;
+        ULONG                  mSharedCurrent;
+    };
+#endif /* VBOX_COLLECTOR_TEST_CASE */
+
+    class MachineCpuLoad : public BaseMetric
+    {
+    public:
+        MachineCpuLoad(CollectorHAL *hal, ComPtr<IUnknown> object, RTPROCESS process, SubMetric *user, SubMetric *kernel)
+        : BaseMetric(hal, "CPU/Load", object), mProcess(process), mUser(user), mKernel(kernel) {};
+        ~MachineCpuLoad() { delete mUser; delete mKernel; };
+
+        void init(ULONG period, ULONG length);
+        void collect();
+        const char *getUnit() { return "%"; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return PM_CPU_LOAD_MULTIPLIER; };
+        ULONG getScale() { return PM_CPU_LOAD_MULTIPLIER / 100; }
+    protected:
+        RTPROCESS  mProcess;
+        SubMetric *mUser;
+        SubMetric *mKernel;
+    };
+
+    class MachineCpuLoadRaw : public MachineCpuLoad
+    {
+    public:
+        MachineCpuLoadRaw(CollectorHAL *hal, ComPtr<IUnknown> object, RTPROCESS process, SubMetric *user, SubMetric *kernel)
+        : MachineCpuLoad(hal, object, process, user, kernel), mHostTotalPrev(0), mProcessUserPrev(0), mProcessKernelPrev(0) {};
+
+        void preCollect(CollectorHints& hints, uint64_t iTick);
+        void collect();
+    private:
+        uint64_t mHostTotalPrev;
+        uint64_t mProcessUserPrev;
+        uint64_t mProcessKernelPrev;
+    };
+
+    class MachineRamUsage : public BaseMetric
+    {
+    public:
+        MachineRamUsage(CollectorHAL *hal, ComPtr<IUnknown> object, RTPROCESS process, SubMetric *used)
+        : BaseMetric(hal, "RAM/Usage", object), mProcess(process), mUsed(used) {};
+        ~MachineRamUsage() { delete mUsed; };
+
+        void init(ULONG period, ULONG length);
+        void preCollect(CollectorHints& hints, uint64_t iTick);
+        void collect();
+        const char *getUnit() { return "kB"; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return INT32_MAX; };
+        ULONG getScale() { return 1; }
+    private:
+        RTPROCESS  mProcess;
+        SubMetric *mUsed;
+    };
+
+
+#ifndef VBOX_COLLECTOR_TEST_CASE
+    typedef std::list<ComObjPtr<Medium> > MediaList;
+    class MachineDiskUsage : public BaseMetric
+    {
+    public:
+        MachineDiskUsage(CollectorHAL *hal, ComPtr<IUnknown> object, MediaList &disks, SubMetric *used)
+        : BaseMetric(hal, "Disk/Usage", object), mDisks(disks), mUsed(used) {};
+        ~MachineDiskUsage() { delete mUsed; };
+
+        void init(ULONG period, ULONG length);
+        void preCollect(CollectorHints& hints, uint64_t iTick);
+        void collect();
+        const char *getUnit() { return "MB"; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return INT32_MAX; };
+        ULONG getScale() { return 1; }
+    private:
+        MediaList   mDisks;
+        SubMetric *mUsed;
+    };
+
+    /*
+     * Although MachineNetRate is measured for VM, not for the guest, it is
+     * derived from BaseGuestMetric since it uses the same mechanism for
+     * data collection -- values get pushed by Guest class along with other
+     * guest statistics.
+     */
+    class MachineNetRate : public BaseGuestMetric
+    {
+    public:
+        MachineNetRate(CollectorGuest *cguest, ComPtr<IUnknown> object, SubMetric *rx, SubMetric *tx)
+            : BaseGuestMetric(cguest, "Net/Rate", object), mRx(rx), mTx(tx) {};
+        ~MachineNetRate() { delete mRx; delete mTx; };
+
+        void init(ULONG period, ULONG length);
+        void preCollect(CollectorHints& hints, uint64_t iTick);
+        void collect();
+        HRESULT enable();
+        HRESULT disable();
+        const char *getUnit() { return "B/s"; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return INT32_MAX; };
+        ULONG getScale() { return 1; }
+    private:
+        SubMetric *mRx, *mTx;
+    };
+
+    class GuestCpuLoad : public BaseGuestMetric
+    {
+    public:
+        GuestCpuLoad(CollectorGuest *cguest, ComPtr<IUnknown> object, SubMetric *user, SubMetric *kernel, SubMetric *idle)
+            : BaseGuestMetric(cguest, "Guest/CPU/Load", object), mUser(user), mKernel(kernel), mIdle(idle) {};
+        ~GuestCpuLoad() { delete mUser; delete mKernel; delete mIdle; };
+
+        void init(ULONG period, ULONG length);
+        void preCollect(CollectorHints& hints, uint64_t iTick);
+        void collect();
+        HRESULT enable();
+        HRESULT disable();
+        const char *getUnit() { return "%"; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return PM_CPU_LOAD_MULTIPLIER; };
+        ULONG getScale() { return PM_CPU_LOAD_MULTIPLIER / 100; }
+    protected:
+        SubMetric *mUser;
+        SubMetric *mKernel;
+        SubMetric *mIdle;
+    };
+
+    class GuestRamUsage : public BaseGuestMetric
+    {
+    public:
+        GuestRamUsage(CollectorGuest *cguest, ComPtr<IUnknown> object, SubMetric *total, SubMetric *free, SubMetric *balloon, SubMetric *shared, SubMetric *cache, SubMetric *pagedtotal)
+            : BaseGuestMetric(cguest, "Guest/RAM/Usage", object), mTotal(total), mFree(free), mBallooned(balloon), mCache(cache), mPagedTotal(pagedtotal), mShared(shared) {};
+        ~GuestRamUsage() { delete mTotal; delete mFree; delete mBallooned; delete mShared; delete mCache; delete mPagedTotal; };
+
+        void init(ULONG period, ULONG length);
+        void preCollect(CollectorHints& hints, uint64_t iTick);
+        void collect();
+        HRESULT enable();
+        HRESULT disable();
+        const char *getUnit() { return "kB"; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return INT32_MAX; };
+        ULONG getScale() { return 1; }
+    private:
+        SubMetric *mTotal, *mFree, *mBallooned, *mCache, *mPagedTotal, *mShared;
+    };
+#endif /* VBOX_COLLECTOR_TEST_CASE */
+
+    /* Aggregate Functions **************************************************/
+    class Aggregate
+    {
+    public:
+        virtual ULONG compute(ULONG *data, ULONG length) = 0;
+        virtual const char *getName() = 0;
+        virtual ~Aggregate() {}
+    };
+
+    class AggregateAvg : public Aggregate
+    {
+    public:
+        virtual ULONG compute(ULONG *data, ULONG length);
+        virtual const char *getName();
+    };
+
+    class AggregateMin : public Aggregate
+    {
+    public:
+        virtual ULONG compute(ULONG *data, ULONG length);
+        virtual const char *getName();
+    };
+
+    class AggregateMax : public Aggregate
+    {
+    public:
+        virtual ULONG compute(ULONG *data, ULONG length);
+        virtual const char *getName();
+    };
+
+    /* Metric Class *********************************************************/
+    class Metric
+    {
+    public:
+        Metric(BaseMetric *baseMetric, SubMetric *subMetric, Aggregate *aggregate) :
+            mName(subMetric->getName()), mBaseMetric(baseMetric), mSubMetric(subMetric), mAggregate(aggregate)
+        {
+            if (mAggregate)
+            {
+                mName.append(":");
+                mName.append(mAggregate->getName());
+            }
+        }
+
+        ~Metric()
+        {
+            delete mAggregate;
+        }
+        bool associatedWith(ComPtr<IUnknown> object) { return getObject() == object; };
+
+        const char *getName() { return mName.c_str(); };
+        ComPtr<IUnknown> getObject() { return mBaseMetric->getObject(); };
+        const char *getDescription()
+            { return mAggregate ? "" : mSubMetric->getDescription(); };
+        const char *getUnit() { return mBaseMetric->getUnit(); };
+        ULONG getMinValue() { return mBaseMetric->getMinValue(); };
+        ULONG getMaxValue() { return mBaseMetric->getMaxValue(); };
+        ULONG getPeriod() { return mBaseMetric->getPeriod(); };
+        ULONG getLength()
+            { return mAggregate ? 1 : mBaseMetric->getLength(); };
+        ULONG getScale() { return mBaseMetric->getScale(); }
+        void query(ULONG **data, ULONG *count, ULONG *sequenceNumber);
+
+    private:
+        RTCString mName;
+        BaseMetric *mBaseMetric;
+        SubMetric  *mSubMetric;
+        Aggregate  *mAggregate;
+    };
+
+    /* Filter Class *********************************************************/
+
+    class Filter
+    {
+    public:
+        Filter(const std::vector<com::Utf8Str> &metricNames,
+               const std::vector<ComPtr<IUnknown> > &objects);
+        Filter(const com::Utf8Str &name, const ComPtr<IUnknown> &aObject);
+        static bool patternMatch(const char *pszPat, const char *pszName,
+                                 bool fSeenColon = false);
+        bool match(const ComPtr<IUnknown> object, const RTCString &name) const;
+    private:
+        typedef std::pair<const ComPtr<IUnknown>, const RTCString> FilterElement;
+        typedef std::list<FilterElement> ElementList;
+
+        ElementList mElements;
+
+        void processMetricList(const com::Utf8Str &name, const ComPtr<IUnknown> object);
+    };
+}
+#endif /* !MAIN_INCLUDED_Performance_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/PerformanceImpl.h b/src/VBox/Main/include/PerformanceImpl.h
new file mode 100644
index 00000000..bc01d8a3
--- /dev/null
+++ b/src/VBox/Main/include/PerformanceImpl.h
@@ -0,0 +1,206 @@
+/* $Id: PerformanceImpl.h $ */
+
+/** @file
+ *
+ * VBox Performance COM class implementation.
+ */
+
+/*
+ * Copyright (C) 2008-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
+ */
+
+#ifndef MAIN_INCLUDED_PerformanceImpl_h
+#define MAIN_INCLUDED_PerformanceImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "PerformanceCollectorWrap.h"
+#include "PerformanceMetricWrap.h"
+
+#include <VBox/com/com.h>
+#include <VBox/com/array.h>
+//#ifdef VBOX_WITH_RESOURCE_USAGE_API
+#include <iprt/timer.h>
+//#endif /* VBOX_WITH_RESOURCE_USAGE_API */
+
+#include <list>
+
+namespace pm
+{
+    class Metric;
+    class BaseMetric;
+    class CollectorHAL;
+    class CollectorGuest;
+    class CollectorGuestManager;
+}
+
+#undef min
+#undef max
+
+/* Each second we obtain new CPU load stats. */
+#define VBOX_USAGE_SAMPLER_MIN_INTERVAL 1000
+
+class ATL_NO_VTABLE PerformanceMetric :
+    public PerformanceMetricWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(PerformanceMetric)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(pm::Metric *aMetric);
+    HRESULT init(pm::BaseMetric *aMetric);
+    void uninit();
+
+private:
+
+    // wrapped IPerformanceMetric properties
+    HRESULT getMetricName(com::Utf8Str &aMetricName);
+    HRESULT getObject(ComPtr<IUnknown> &aObject);
+    HRESULT getDescription(com::Utf8Str &aDescription);
+    HRESULT getPeriod(ULONG *aPeriod);
+    HRESULT getCount(ULONG *aCount);
+    HRESULT getUnit(com::Utf8Str &aUnit);
+    HRESULT getMinimumValue(LONG *aMinimumValue);
+    HRESULT getMaximumValue(LONG *aMaximumValue);
+
+    struct Data
+    {
+        /* Constructor. */
+        Data()
+            : period(0), count(0), min(0), max(0)
+        {
+        }
+
+        Utf8Str          name;
+        ComPtr<IUnknown> object;
+        Utf8Str          description;
+        ULONG            period;
+        ULONG            count;
+        Utf8Str          unit;
+        LONG             min;
+        LONG             max;
+    };
+
+    Data m;
+};
+
+
+class ATL_NO_VTABLE PerformanceCollector :
+    public PerformanceCollectorWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(PerformanceCollector)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializers/uninitializers only for internal purposes
+    HRESULT init();
+    void uninit();
+
+    // public methods only for internal purposes
+
+    void registerBaseMetric(pm::BaseMetric *baseMetric);
+    void registerMetric(pm::Metric *metric);
+    void unregisterBaseMetricsFor(const ComPtr<IUnknown> &object, const Utf8Str name = "*");
+    void unregisterMetricsFor(const ComPtr<IUnknown> &object, const Utf8Str name = "*");
+    void registerGuest(pm::CollectorGuest* pGuest);
+    void unregisterGuest(pm::CollectorGuest* pGuest);
+
+    void suspendSampling();
+    void resumeSampling();
+
+    // public methods for internal purposes only
+    // (ensure there is a caller and a read lock before calling them!)
+
+    pm::CollectorHAL          *getHAL()          { return m.hal; };
+    pm::CollectorGuestManager *getGuestManager() { return m.gm; };
+
+private:
+
+    // wrapped IPerformanceCollector properties
+    HRESULT getMetricNames(std::vector<com::Utf8Str> &aMetricNames);
+
+    // wrapped IPerformanceCollector methods
+    HRESULT getMetrics(const std::vector<com::Utf8Str> &aMetricNames,
+                       const std::vector<ComPtr<IUnknown> > &aObjects,
+                       std::vector<ComPtr<IPerformanceMetric> > &aMetrics);
+    HRESULT setupMetrics(const std::vector<com::Utf8Str> &aMetricNames,
+                         const std::vector<ComPtr<IUnknown> > &aObjects,
+                         ULONG aPeriod,
+                         ULONG aCount,
+                         std::vector<ComPtr<IPerformanceMetric> > &aAffectedMetrics);
+    HRESULT enableMetrics(const std::vector<com::Utf8Str> &aMetricNames,
+                          const std::vector<ComPtr<IUnknown> > &aObjects,
+                          std::vector<ComPtr<IPerformanceMetric> > &aAffectedMetrics);
+    HRESULT disableMetrics(const std::vector<com::Utf8Str> &aMetricNames,
+                           const std::vector<ComPtr<IUnknown> > &aObjects,
+                           std::vector<ComPtr<IPerformanceMetric> > &aAffectedMetrics);
+    HRESULT queryMetricsData(const std::vector<com::Utf8Str> &aMetricNames,
+                             const std::vector<ComPtr<IUnknown> > &aObjects,
+                             std::vector<com::Utf8Str> &aReturnMetricNames,
+                             std::vector<ComPtr<IUnknown> > &aReturnObjects,
+                             std::vector<com::Utf8Str> &aReturnUnits,
+                             std::vector<ULONG> &aReturnScales,
+                             std::vector<ULONG> &aReturnSequenceNumbers,
+                             std::vector<ULONG> &aReturnDataIndices,
+                             std::vector<ULONG> &aReturnDataLengths,
+                             std::vector<LONG> &aReturnData);
+
+
+    HRESULT toIPerformanceMetric(pm::Metric *src, ComPtr<IPerformanceMetric> &dst);
+    HRESULT toIPerformanceMetric(pm::BaseMetric *src, ComPtr<IPerformanceMetric> &dst);
+
+    static DECLCALLBACK(void) staticSamplerCallback(RTTIMERLR hTimerLR, void *pvUser, uint64_t iTick);
+    void samplerCallback(uint64_t iTick);
+
+    const Utf8Str& getFailedGuestName();
+
+    typedef std::list<pm::Metric*> MetricList;
+    typedef std::list<pm::BaseMetric*> BaseMetricList;
+
+/** PerformanceMetric::mMagic value. */
+#define PERFORMANCE_METRIC_MAGIC    UINT32_C(0xABBA1972)
+    uint32_t mMagic;
+    const Utf8Str mUnknownGuest;
+
+    struct Data
+    {
+        Data() : hal(0) {};
+
+        BaseMetricList             baseMetrics;
+        MetricList                 metrics;
+        RTTIMERLR                  sampler;
+        pm::CollectorHAL          *hal;
+        pm::CollectorGuestManager *gm;
+    };
+
+    Data m;
+};
+
+#endif /* !MAIN_INCLUDED_PerformanceImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/ProgressImpl.h b/src/VBox/Main/include/ProgressImpl.h
new file mode 100644
index 00000000..341a6672
--- /dev/null
+++ b/src/VBox/Main/include/ProgressImpl.h
@@ -0,0 +1,259 @@
+/* $Id: ProgressImpl.h $ */
+/** @file
+ *
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_ProgressImpl_h
+#define MAIN_INCLUDED_ProgressImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "ProgressWrap.h"
+#include "VirtualBoxBase.h"
+#include "EventImpl.h"
+
+#include <iprt/semaphore.h>
+
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Class for progress objects.
+ */
+class ATL_NO_VTABLE Progress :
+    public ProgressWrap
+{
+public:
+    DECLARE_NOT_AGGREGATABLE(Progress)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+
+    /**
+     * Simplified constructor for progress objects that have only one
+     * operation as a task.
+     * @param aParent
+     * @param aInitiator
+     * @param aDescription
+     * @param aCancelable
+     * @return
+     */
+    HRESULT init(
+#if !defined(VBOX_COM_INPROC)
+                  VirtualBox *aParent,
+#endif
+                  IUnknown *aInitiator,
+                  const Utf8Str &aDescription,
+                  BOOL aCancelable)
+    {
+        return init(
+#if !defined(VBOX_COM_INPROC)
+            aParent,
+#endif
+            aInitiator,
+            aDescription,
+            aCancelable,
+            1,      // cOperations
+            1,      // ulTotalOperationsWeight
+            aDescription, // aFirstOperationDescription
+            1);     // ulFirstOperationWeight
+    }
+
+    /**
+     * Not quite so simplified constructor for progress objects that have
+     * more than one operation, but all sub-operations are weighed the same.
+     * @param aParent
+     * @param aInitiator
+     * @param aDescription
+     * @param aCancelable
+     * @param cOperations
+     * @param aFirstOperationDescription
+     * @return
+     */
+    HRESULT init(
+#if !defined(VBOX_COM_INPROC)
+                  VirtualBox *aParent,
+#endif
+                  IUnknown *aInitiator,
+                  const Utf8Str &aDescription, BOOL aCancelable,
+                  ULONG cOperations,
+                  const Utf8Str &aFirstOperationDescription)
+    {
+        return init(
+#if !defined(VBOX_COM_INPROC)
+            aParent,
+#endif
+            aInitiator,
+            aDescription,
+            aCancelable,
+            cOperations,      // cOperations
+            cOperations,      // ulTotalOperationsWeight = cOperations
+            aFirstOperationDescription, // aFirstOperationDescription
+            1);     // ulFirstOperationWeight: weigh them all the same
+    }
+
+    HRESULT init(
+#if !defined(VBOX_COM_INPROC)
+                  VirtualBox *aParent,
+#endif
+                  IUnknown *aInitiator,
+                  const Utf8Str &aDescription,
+                  BOOL aCancelable,
+                  ULONG cOperations,
+                  ULONG ulTotalOperationsWeight,
+                  const Utf8Str &aFirstOperationDescription,
+                  ULONG ulFirstOperationWeight);
+
+    HRESULT init(BOOL aCancelable,
+                 ULONG aOperationCount,
+                 const Utf8Str &aOperationDescription);
+
+    void uninit();
+
+
+    // public methods only for internal purposes
+    HRESULT i_notifyComplete(HRESULT aResultCode);
+    HRESULT i_notifyComplete(HRESULT aResultCode,
+                             const GUID &aIID,
+                             const char *pcszComponent,
+                             const char *aText,
+                             ...);
+    HRESULT i_notifyCompleteV(HRESULT aResultCode,
+                              const GUID &aIID,
+                              const char *pcszComponent,
+                              const char *aText,
+                              va_list va);
+    HRESULT i_notifyCompleteBoth(HRESULT aResultCode,
+                                 int vrc,
+                                 const GUID &aIID,
+                                 const char *pcszComponent,
+                                 const char *aText,
+                                 ...);
+    HRESULT i_notifyCompleteBothV(HRESULT aResultCode,
+                                  int vrc,
+                                  const GUID &aIID,
+                                  const char *pcszComponent,
+                                  const char *aText,
+                                  va_list va);
+
+    bool i_setCancelCallback(void (*pfnCallback)(void *), void *pvUser);
+
+    static DECLCALLBACK(int) i_iprtProgressCallback(unsigned uPercentage, void *pvUser);
+    static DECLCALLBACK(int) i_vdProgressCallback(void *pvUser, unsigned uPercentage);
+
+protected:
+    DECLARE_COMMON_CLASS_METHODS(Progress)
+
+#if !defined(VBOX_COM_INPROC)
+    /** Weak parent. */
+    VirtualBox * const      mParent;
+#endif
+    const ComObjPtr<EventSource> pEventSource;
+    const ComPtr<IUnknown>  mInitiator;
+
+    const Guid mId;
+    const com::Utf8Str mDescription;
+
+    uint64_t m_ullTimestamp;                        // progress object creation timestamp, for ETA computation
+
+    void (*m_pfnCancelCallback)(void *);
+    void *m_pvCancelUserArg;
+
+    /* The fields below are to be properly initialized by subclasses */
+
+    BOOL mCompleted;
+    BOOL mCancelable;
+    BOOL mCanceled;
+    HRESULT mResultCode;
+    ComPtr<IVirtualBoxErrorInfo> mErrorInfo;
+
+    ULONG m_cOperations;                            // number of operations (so that progress dialog can
+                                                    // display something like 1/3)
+    ULONG m_ulTotalOperationsWeight;                // sum of weights of all operations, given to constructor
+
+    ULONG m_ulOperationsCompletedWeight;            // summed-up weight of operations that have been completed; initially 0
+
+    ULONG m_ulCurrentOperation;                     // operations counter, incremented with
+                                                    // each setNextOperation()
+    com::Utf8Str m_operationDescription;            // name of current operation; initially
+                                                    // from constructor, changed with setNextOperation()
+    ULONG m_ulCurrentOperationWeight;               // weight of current operation, given to setNextOperation()
+    ULONG m_ulOperationPercent;                     // percentage of current operation, set with setCurrentOperationProgress()
+    ULONG m_cMsTimeout;                             /**< Automatic timeout value. 0 means none. */
+
+private:
+    // wrapped IProgress properties
+    HRESULT getId(com::Guid &aId);
+    HRESULT getDescription(com::Utf8Str &aDescription);
+    HRESULT getInitiator(ComPtr<IUnknown> &aInitiator);
+    HRESULT getCancelable(BOOL *aCancelable);
+    HRESULT getPercent(ULONG *aPercent);
+    HRESULT getTimeRemaining(LONG *aTimeRemaining);
+    HRESULT getCompleted(BOOL *aCompleted);
+    HRESULT getCanceled(BOOL *aCanceled);
+    HRESULT getResultCode(LONG *aResultCode);
+    HRESULT getErrorInfo(ComPtr<IVirtualBoxErrorInfo> &aErrorInfo);
+    HRESULT getOperationCount(ULONG *aOperationCount);
+    HRESULT getOperation(ULONG *aOperation);
+    HRESULT getOperationDescription(com::Utf8Str &aOperationDescription);
+    HRESULT getOperationPercent(ULONG *aOperationPercent);
+    HRESULT getOperationWeight(ULONG *aOperationWeight);
+    HRESULT getTimeout(ULONG *aTimeout);
+    HRESULT setTimeout(ULONG aTimeout);
+    HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
+
+    // wrapped IProgress methods
+    HRESULT waitForCompletion(LONG aTimeout);
+    HRESULT waitForOperationCompletion(ULONG aOperation,
+                                       LONG aTimeout);
+    HRESULT cancel();
+
+    // wrapped IInternalProgressControl methods
+    HRESULT setCurrentOperationProgress(ULONG aPercent);
+    HRESULT waitForOtherProgressCompletion(const ComPtr<IProgress> &aProgressOther,
+                                           ULONG aTimeoutMS);
+    HRESULT setNextOperation(const com::Utf8Str &aNextOperationDescription,
+                             ULONG aNextOperationsWeight);
+    HRESULT notifyPointOfNoReturn();
+    HRESULT notifyComplete(LONG aResultCode,
+                           const ComPtr<IVirtualBoxErrorInfo> &aErrorInfo);
+
+    // internal helper methods
+    HRESULT i_notifyCompleteWorker(HRESULT aResultCode, const ComPtr<IVirtualBoxErrorInfo> &aErrorInfo);
+    double i_calcTotalPercent();
+    void i_checkForAutomaticTimeout(void);
+
+    RTSEMEVENTMULTI mCompletedSem;
+    ULONG mWaitersCount;
+
+private:
+    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(Progress); /* Shuts up MSC warning C4625. */
+};
+
+#endif /* !MAIN_INCLUDED_ProgressImpl_h */
+
diff --git a/src/VBox/Main/include/ProgressProxyImpl.h b/src/VBox/Main/include/ProgressProxyImpl.h
new file mode 100644
index 00000000..40cc2e39
--- /dev/null
+++ b/src/VBox/Main/include/ProgressProxyImpl.h
@@ -0,0 +1,130 @@
+/* $Id: ProgressProxyImpl.h $ */
+/** @file
+ * IProgress implementation for Machine::LaunchVMProcess 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
+ */
+
+#ifndef MAIN_INCLUDED_ProgressProxyImpl_h
+#define MAIN_INCLUDED_ProgressProxyImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "ProgressImpl.h"
+#include "AutoCaller.h"
+
+
+/**
+ * The ProgressProxy class allows proxying the important Progress calls and
+ * attributes to a different IProgress object for a period of time.
+ */
+class ATL_NO_VTABLE ProgressProxy :
+    public Progress
+{
+public:
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(ProgressProxy, IProgress)
+
+    DECLARE_NOT_AGGREGATABLE(ProgressProxy)
+    DECLARE_PROTECT_FINAL_CONSTRUCT()
+
+    BEGIN_COM_MAP(ProgressProxy)
+        COM_INTERFACE_ENTRY(ISupportErrorInfo)
+        COM_INTERFACE_ENTRY(IProgress)
+        COM_INTERFACE_ENTRY2(IDispatch, IProgress)
+        VBOX_TWEAK_INTERFACE_ENTRY(IProgress)
+    END_COM_MAP()
+
+    HRESULT FinalConstruct();
+    void    FinalRelease();
+    HRESULT init(
+#ifndef VBOX_COM_INPROC
+                 VirtualBox *pParent,
+#endif
+                 IUnknown *pInitiator,
+                 Utf8Str strDescription,
+                 BOOL fCancelable);
+    HRESULT init(
+#ifndef VBOX_COM_INPROC
+                 VirtualBox *pParent,
+#endif
+                 IUnknown *pInitiator,
+                 Utf8Str strDescription,
+                 BOOL fCancelable,
+                 ULONG uTotalOperationsWeight,
+                 Utf8Str strFirstOperationDescription,
+                 ULONG uFirstOperationWeight,
+                 ULONG cOtherProgressObjectOperations);
+    void    uninit();
+
+    // IProgress properties
+    STDMETHOD(COMGETTER(Cancelable))(BOOL *aCancelable);
+    STDMETHOD(COMGETTER(Percent))(ULONG *aPercent);
+    STDMETHOD(COMGETTER(TimeRemaining))(LONG *aTimeRemaining);
+    STDMETHOD(COMGETTER(Completed))(BOOL *aCompleted);
+    STDMETHOD(COMGETTER(Canceled))(BOOL *aCanceled);
+    STDMETHOD(COMGETTER(ResultCode))(LONG *aResultCode);
+    STDMETHOD(COMGETTER(ErrorInfo))(IVirtualBoxErrorInfo **aErrorInfo);
+    //STDMETHOD(COMGETTER(OperationCount))(ULONG *aOperationCount); - not necessary
+    STDMETHOD(COMGETTER(Operation))(ULONG *aOperation);
+    STDMETHOD(COMGETTER(OperationDescription))(BSTR *aOperationDescription);
+    STDMETHOD(COMGETTER(OperationPercent))(ULONG *aOperationPercent);
+    STDMETHOD(COMSETTER(Timeout))(ULONG aTimeout);
+    STDMETHOD(COMGETTER(Timeout))(ULONG *aTimeout);
+
+    // IProgress methods
+    STDMETHOD(WaitForCompletion)(LONG aTimeout);
+    STDMETHOD(WaitForOperationCompletion)(ULONG aOperation, LONG aTimeout);
+    STDMETHOD(Cancel)();
+    STDMETHOD(SetCurrentOperationProgress)(ULONG aPercent);
+    STDMETHOD(SetNextOperation)(IN_BSTR bstrNextOperationDescription, ULONG ulNextOperationsWeight);
+
+    // public methods only for internal purposes
+
+    HRESULT notifyComplete(HRESULT aResultCode);
+    HRESULT notifyComplete(HRESULT aResultCode,
+                           const GUID &aIID,
+                           const char *pcszComponent,
+                           const char *aText, ...);
+    bool setOtherProgressObject(IProgress *pOtherProgress);
+
+protected:
+    void clearOtherProgressObjectInternal(bool fEarly);
+    void copyProgressInfo(IProgress *pOtherProgress, bool fEarly);
+
+private:
+    /** The other progress object.  This can be NULL. */
+    ComPtr<IProgress> mptrOtherProgress;
+    /** Set if the other progress object has multiple operations. */
+    bool mfMultiOperation;
+    /** The weight the other progress object started at. */
+    ULONG muOtherProgressStartWeight;
+    /** The weight of other progress object. */
+    ULONG muOtherProgressWeight;
+    /** The operation number the other progress object started at. */
+    ULONG muOtherProgressStartOperation;
+
+};
+
+#endif /* !MAIN_INCLUDED_ProgressProxyImpl_h */
+
diff --git a/src/VBox/Main/include/QMTranslator.h b/src/VBox/Main/include/QMTranslator.h
new file mode 100644
index 00000000..95616fa5
--- /dev/null
+++ b/src/VBox/Main/include/QMTranslator.h
@@ -0,0 +1,79 @@
+/* $Id: QMTranslator.h $ */
+/** @file
+ * VirtualBox API translation handling class
+ */
+
+/*
+ * Copyright (C) 2014-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
+ */
+
+#ifndef MAIN_INCLUDED_QMTranslator_h
+#define MAIN_INCLUDED_QMTranslator_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+class QMTranslator_Impl;
+
+class QMTranslator
+{
+public:
+    QMTranslator();
+    virtual ~QMTranslator();
+
+    /**
+     * Gets translation from loaded QM file
+     *
+     * @param   pszContext      QM context to look for translation
+     * @param   pszSource       Source string in one-byte encoding
+     * @param   ppszSafeSource  Where to return pointer to a safe copy of @a
+     *                          pszSource for the purpose of reverse translation.
+     *                          Will be set to NULL if @a pszSource is returned.
+     * @param   pszDisamb       Disambiguationg comment, empty by default
+     * @param   aNum            Plural form indicator.
+     *
+     * @returns Pointer to a translation (UTF-8 encoding), source string on failure.
+     */
+    const char *translate(const char *pszContext, const char *pszSource, const char **ppszSafeSource,
+                          const char *pszDisamb = NULL, const size_t aNum = ~(size_t)0) const RT_NOEXCEPT;
+
+    /**
+     * Loads and parses QM file
+     *
+     * @param   pszFilename The name of the file to load
+     * @param   hStrCache   The string cache to use for storing strings.
+     *
+     * @returns VBox status code.
+     */
+    int load(const char *pszFilename, RTSTRCACHE hStrCache) RT_NOEXCEPT;
+
+private:
+    /** QMTranslator implementation.
+     * To separate all the code from the interface */
+    QMTranslator_Impl *m_impl;
+
+    /* If copying is required, please define the following operators */
+    void operator=(QMTranslator &);
+    QMTranslator(const QMTranslator &);
+};
+
+#endif /* !MAIN_INCLUDED_QMTranslator_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/Recording.h b/src/VBox/Main/include/Recording.h
new file mode 100644
index 00000000..2679ae2b
--- /dev/null
+++ b/src/VBox/Main/include/Recording.h
@@ -0,0 +1,174 @@
+/* $Id: Recording.h $ */
+/** @file
+ * Recording code header.
+ */
+
+/*
+ * Copyright (C) 2012-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
+ */
+
+#ifndef MAIN_INCLUDED_Recording_h
+#define MAIN_INCLUDED_Recording_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/err.h>
+#include <VBox/settings.h>
+
+#include "RecordingStream.h"
+
+class Console;
+
+/**
+ * Class for managing a recording context.
+ */
+class RecordingContext
+{
+public:
+
+    RecordingContext();
+
+    RecordingContext(Console *ptrConsole, const settings::RecordingSettings &Settings);
+
+    virtual ~RecordingContext(void);
+
+public:
+
+    const settings::RecordingSettings &GetConfig(void) const;
+    RecordingStream *GetStream(unsigned uScreen) const;
+    size_t GetStreamCount(void) const;
+#ifdef VBOX_WITH_AUDIO_RECORDING
+    PRECORDINGCODEC GetCodecAudio(void) { return &this->m_CodecAudio; }
+#endif
+
+    int Create(Console *pConsole, const settings::RecordingSettings &Settings);
+    void Destroy(void);
+
+    int Start(void);
+    int Stop(void);
+
+    int SendAudioFrame(const void *pvData, size_t cbData, uint64_t uTimestampMs);
+    int SendVideoFrame(uint32_t uScreen,
+                       uint32_t x, uint32_t y, uint32_t uPixelFormat, uint32_t uBPP,
+                       uint32_t uBytesPerLine, uint32_t uSrcWidth, uint32_t uSrcHeight,
+                       uint8_t *puSrcData, uint64_t msTimestamp);
+public:
+
+    bool IsFeatureEnabled(RecordingFeature_T enmFeature);
+    bool IsReady(void);
+    bool IsReady(uint32_t uScreen, uint64_t msTimestamp);
+    bool IsStarted(void);
+    bool IsLimitReached(void);
+    bool IsLimitReached(uint32_t uScreen, uint64_t msTimestamp);
+    bool NeedsUpdate(uint32_t uScreen, uint64_t msTimestamp);
+
+    DECLCALLBACK(int) OnLimitReached(uint32_t uScreen, int vrc);
+
+protected:
+
+    int createInternal(Console *ptrConsole, const settings::RecordingSettings &Settings);
+    int startInternal(void);
+    int stopInternal(void);
+
+    void destroyInternal(void);
+
+    RecordingStream *getStreamInternal(unsigned uScreen) const;
+
+    int processCommonData(RecordingBlockMap &mapCommon, RTMSINTERVAL msTimeout);
+    int writeCommonData(RecordingBlockMap &mapCommon, PRECORDINGCODEC pCodec, const void *pvData, size_t cbData, uint64_t msAbsPTS, uint32_t uFlags);
+
+    int lock(void);
+    int unlock(void);
+
+    static DECLCALLBACK(int) threadMain(RTTHREAD hThreadSelf, void *pvUser);
+
+    int threadNotify(void);
+
+protected:
+
+    int audioInit(const settings::RecordingScreenSettings &screenSettings);
+
+    static DECLCALLBACK(int) audioCodecWriteDataCallback(PRECORDINGCODEC pCodec, const void *pvData, size_t cbData, uint64_t msAbsPTS, uint32_t uFlags, void *pvUser);
+
+protected:
+
+    /**
+     * Enumeration for a recording context state.
+     */
+    enum RECORDINGSTS
+    {
+        /** Context not initialized. */
+        RECORDINGSTS_UNINITIALIZED = 0,
+        /** Context was created. */
+        RECORDINGSTS_CREATED       = 1,
+        /** Context was started. */
+        RECORDINGSTS_STARTED       = 2,
+        /** The usual 32-bit hack. */
+        RECORDINGSTS_32BIT_HACK    = 0x7fffffff
+    };
+
+    /** Pointer to the console object. */
+    Console                     *m_pConsole;
+    /** Used recording configuration. */
+    settings::RecordingSettings  m_Settings;
+    /** The current state. */
+    RECORDINGSTS                 m_enmState;
+    /** Critical section to serialize access. */
+    RTCRITSECT                   m_CritSect;
+    /** Semaphore to signal the encoding worker thread. */
+    RTSEMEVENT                   m_WaitEvent;
+    /** Shutdown indicator. */
+    bool                         m_fShutdown;
+    /** Encoding worker thread. */
+    RTTHREAD                     m_Thread;
+    /** Vector of current recording streams.
+     *  Per VM screen (display) one recording stream is being used. */
+    RecordingStreams             m_vecStreams;
+    /** Number of streams in vecStreams which currently are enabled for recording. */
+    uint16_t                     m_cStreamsEnabled;
+    /** Timestamp (in ms) of when recording has been started. */
+    uint64_t                     m_tsStartMs;
+#ifdef VBOX_WITH_AUDIO_RECORDING
+    /** Audio codec to use.
+     *
+     *  We multiplex audio data from this recording context to all streams,
+     *  to avoid encoding the same audio data for each stream. We ASSUME that
+     *  all audio data of a VM will be the same for each stream at a given
+     *  point in time. */
+    RECORDINGCODEC               m_CodecAudio;
+#endif /* VBOX_WITH_AUDIO_RECORDING */
+    /** Block map of raw common data blocks which need to get encoded first. */
+    RecordingBlockMap            m_mapBlocksRaw;
+    /** Block map of encoded common blocks.
+     *
+     *  Only do the encoding of common data blocks only once and then multiplex
+     *  the encoded data to all affected recording streams.
+     *
+     *  This avoids doing the (expensive) encoding + multiplexing work in other
+     *  threads like EMT / audio async I/O..
+     *
+     *  For now this only affects audio, e.g. all recording streams
+     *  need to have the same audio data at a specific point in time. */
+    RecordingBlockMap            m_mapBlocksEncoded;
+};
+#endif /* !MAIN_INCLUDED_Recording_h */
+
diff --git a/src/VBox/Main/include/RecordingInternals.h b/src/VBox/Main/include/RecordingInternals.h
new file mode 100644
index 00000000..a98f1be5
--- /dev/null
+++ b/src/VBox/Main/include/RecordingInternals.h
@@ -0,0 +1,504 @@
+/* $Id: RecordingInternals.h $ */
+/** @file
+ * Recording internals header.
+ */
+
+/*
+ * Copyright (C) 2012-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
+ */
+
+#ifndef MAIN_INCLUDED_RecordingInternals_h
+#define MAIN_INCLUDED_RecordingInternals_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <list>
+
+#include <iprt/assert.h>
+#include <iprt/types.h> /* drag in stdint.h before vpx does it. */
+
+#include "VBox/com/string.h"
+#include "VBox/com/VirtualBox.h"
+#include "VBox/settings.h"
+#include <VBox/vmm/pdmaudioifs.h>
+
+#ifdef VBOX_WITH_LIBVPX
+# define VPX_CODEC_DISABLE_COMPAT 1
+# include "vpx/vp8cx.h"
+# include "vpx/vpx_image.h"
+# include "vpx/vpx_encoder.h"
+#endif /* VBOX_WITH_LIBVPX */
+
+#ifdef VBOX_WITH_LIBVORBIS
+# include "vorbis/vorbisenc.h"
+#endif
+
+
+/*********************************************************************************************************************************
+*   Defines                                                                                                                      *
+*********************************************************************************************************************************/
+#define VBOX_RECORDING_VORBIS_HZ_MAX             48000   /**< Maximum sample rate (in Hz) Vorbis can handle. */
+#define VBOX_RECORDING_VORBIS_FRAME_MS_DEFAULT   20      /**< Default Vorbis frame size (in ms). */
+
+
+/*********************************************************************************************************************************
+*   Prototypes                                                                                                                   *
+*********************************************************************************************************************************/
+struct RECORDINGCODEC;
+typedef RECORDINGCODEC *PRECORDINGCODEC;
+
+struct RECORDINGFRAME;
+typedef RECORDINGFRAME *PRECORDINGFRAME;
+
+
+/*********************************************************************************************************************************
+*   Internal structures, defines and APIs                                                                                        *
+*********************************************************************************************************************************/
+
+/**
+ * Enumeration for specifying a (generic) codec type.
+ */
+typedef enum RECORDINGCODECTYPE
+{
+    /** Invalid codec type. Do not use. */
+    RECORDINGCODECTYPE_INVALID = 0,
+    /** Video codec. */
+    RECORDINGCODECTYPE_VIDEO,
+    /** Audio codec. */
+    RECORDINGCODECTYPE_AUDIO
+} RECORDINGCODECTYPE;
+
+/**
+ * Structure for keeping a codec operations table.
+ */
+typedef struct RECORDINGCODECOPS
+{
+    /**
+     * Initializes a codec.
+     *
+     * @returns VBox status code.
+     * @param   pCodec              Codec instance to initialize.
+     */
+    DECLCALLBACKMEMBER(int, pfnInit,         (PRECORDINGCODEC pCodec));
+
+    /**
+     * Destroys a codec.
+     *
+     * @returns VBox status code.
+     * @param   pCodec              Codec instance to destroy.
+     */
+    DECLCALLBACKMEMBER(int, pfnDestroy,      (PRECORDINGCODEC pCodec));
+
+    /**
+     * Parses an options string to configure advanced / hidden / experimental features of a recording stream.
+     * Unknown values will be skipped. Optional.
+     *
+     * @returns VBox status code.
+     * @param   pCodec              Codec instance to parse options for.
+     * @param   strOptions          Options string to parse.
+     */
+    DECLCALLBACKMEMBER(int, pfnParseOptions, (PRECORDINGCODEC pCodec, const com::Utf8Str &strOptions));
+
+    /**
+     * Feeds the codec encoder with data to encode.
+     *
+     * @returns VBox status code.
+     * @param   pCodec              Codec instance to use.
+     * @param   pFrame              Pointer to frame data to encode.
+     * @param   pcEncoded           Where to return the number of encoded blocks in \a pvDst on success. Optional.
+     * @param   pcbEncoded          Where to return the number of encoded bytes in \a pvDst on success. Optional.
+     */
+    DECLCALLBACKMEMBER(int, pfnEncode,       (PRECORDINGCODEC pCodec, const PRECORDINGFRAME pFrame, size_t *pcEncoded, size_t *pcbEncoded));
+
+    /**
+     * Tells the codec to finalize the current stream. Optional.
+     *
+     * @returns VBox status code.
+     * @param   pCodec              Codec instance to finalize stream for.
+     */
+    DECLCALLBACKMEMBER(int, pfnFinalize,     (PRECORDINGCODEC pCodec));
+} RECORDINGCODECOPS, *PRECORDINGCODECOPS;
+
+/** No encoding flags set. */
+#define RECORDINGCODEC_ENC_F_NONE               UINT32_C(0)
+/** Data block is a key block. */
+#define RECORDINGCODEC_ENC_F_BLOCK_IS_KEY       RT_BIT_32(0)
+/** Data block is invisible. */
+#define RECORDINGCODEC_ENC_F_BLOCK_IS_INVISIBLE RT_BIT_32(1)
+/** Encoding flags valid mask. */
+#define RECORDINGCODEC_ENC_F_VALID_MASK         0x1
+
+/**
+ * Structure for keeping a codec callback table.
+ */
+typedef struct RECORDINGCODECCALLBACKS
+{
+    /**
+     * Callback for notifying that encoded data has been written.
+     *
+     * @returns VBox status code.
+     * @param   pCodec          Pointer to codec instance which has written the data.
+     * @param   pvData          Pointer to written data (encoded).
+     * @param   cbData          Size (in bytes) of \a pvData.
+     * @param   msAbsPTS        Absolute PTS (in ms) of the written data.
+     * @param   uFlags          Encoding flags of type RECORDINGCODEC_ENC_F_XXX.
+     * @param   pvUser          User-supplied pointer.
+     */
+    DECLCALLBACKMEMBER(int, pfnWriteData, (PRECORDINGCODEC pCodec, const void *pvData, size_t cbData, uint64_t msAbsPTS, uint32_t uFlags, void *pvUser));
+    /** User-supplied data pointer. */
+    void                   *pvUser;
+} RECORDINGCODECCALLBACKS, *PRECORDINGCODECCALLBACKS;
+
+/**
+ * Structure for keeping generic codec parameters.
+ */
+typedef struct RECORDINGCODECPARMS
+{
+    /** The generic codec type. */
+    RECORDINGCODECTYPE          enmType;
+    /** The specific codec type, based on \a enmType. */
+    union
+    {
+        /** The container's video codec to use. */
+        RecordingVideoCodec_T   enmVideoCodec;
+        /** The container's audio codec to use. */
+        RecordingAudioCodec_T   enmAudioCodec;
+    };
+    union
+    {
+        struct
+        {
+            /** Frames per second. */
+            uint8_t             uFPS;
+            /** Target width (in pixels) of encoded video image. */
+            uint16_t            uWidth;
+            /** Target height (in pixels) of encoded video image. */
+            uint16_t            uHeight;
+            /** Minimal delay (in ms) between two video frames.
+             *  This value is based on the configured FPS rate. */
+            uint32_t            uDelayMs;
+        } Video;
+        struct
+        {
+            /** The codec's used PCM properties. */
+            PDMAUDIOPCMPROPS    PCMProps;
+        } Audio;
+    };
+    /** Desired (average) bitrate (in kbps) to use, for codecs which support bitrate management.
+     *  Set to 0 to use a variable bit rate (VBR) (if available, otherwise fall back to CBR). */
+    uint32_t                    uBitrate;
+    /** Time (in ms) the encoder expects us to send data to encode.
+     *
+     *  For Vorbis, valid frame sizes are powers of two from 64 to 8192 bytes.
+     */
+    uint32_t                    msFrame;
+    /** The frame size in bytes (based on \a msFrame). */
+    uint32_t                    cbFrame;
+    /** The frame size in samples per frame (based on \a msFrame). */
+    uint32_t                    csFrame;
+} RECORDINGCODECPARMS, *PRECORDINGCODECPARMS;
+
+#ifdef VBOX_WITH_LIBVPX
+/**
+ * VPX encoder state (needs libvpx).
+ */
+typedef struct RECORDINGCODECVPX
+{
+    /** VPX codec context. */
+    vpx_codec_ctx_t     Ctx;
+    /** VPX codec configuration. */
+    vpx_codec_enc_cfg_t Cfg;
+    /** VPX image context. */
+    vpx_image_t         RawImage;
+    /** Pointer to the codec's internal YUV buffer. */
+    uint8_t            *pu8YuvBuf;
+    /** The encoder's deadline (in ms).
+     *  The more time the encoder is allowed to spend encoding, the better the encoded
+     *  result, in exchange for higher CPU usage and time spent encoding. */
+    unsigned int        uEncoderDeadline;
+} RECORDINGCODECVPX;
+/** Pointer to a VPX encoder state. */
+typedef RECORDINGCODECVPX *PRECORDINGCODECVPX;
+#endif /* VBOX_WITH_LIBVPX */
+
+#ifdef VBOX_WITH_LIBVORBIS
+/**
+ * Vorbis encoder state (needs libvorbis + libogg).
+ */
+typedef struct RECORDINGCODECVORBIS
+{
+    /** Basic information about the audio in a Vorbis bitstream. */
+    vorbis_info      info;
+    /** Encoder state. */
+    vorbis_dsp_state dsp_state;
+    /** Current block being worked on. */
+    vorbis_block     block_cur;
+} RECORDINGCODECVORBIS;
+/** Pointer to a Vorbis encoder state. */
+typedef RECORDINGCODECVORBIS *PRECORDINGCODECVORBIS;
+#endif /* VBOX_WITH_LIBVORBIS */
+
+/**
+ * Structure for keeping a codec's internal state.
+ */
+typedef struct RECORDINGCODECSTATE
+{
+    /** Timestamp Timestamp (PTS, in ms) of the last frame was encoded. */
+    uint64_t            tsLastWrittenMs;
+    /** Number of encoding errors. */
+    uint64_t            cEncErrors;
+} RECORDINGCODECSTATE;
+/** Pointer to an internal encoder state. */
+typedef RECORDINGCODECSTATE *PRECORDINGCODECSTATE;
+
+/**
+ * Structure for keeping codec-specific data.
+ */
+typedef struct RECORDINGCODEC
+{
+    /** Callback table for codec operations. */
+    RECORDINGCODECOPS           Ops;
+    /** Table for user-supplied callbacks. */
+    RECORDINGCODECCALLBACKS     Callbacks;
+    /** Generic codec parameters. */
+    RECORDINGCODECPARMS         Parms;
+    /** Generic codec parameters. */
+    RECORDINGCODECSTATE         State;
+
+#ifdef VBOX_WITH_LIBVPX
+    union
+    {
+        RECORDINGCODECVPX       VPX;
+    } Video;
+#endif
+
+#ifdef VBOX_WITH_AUDIO_RECORDING
+    union
+    {
+# ifdef VBOX_WITH_LIBVORBIS
+        RECORDINGCODECVORBIS    Vorbis;
+# endif /* VBOX_WITH_LIBVORBIS */
+    } Audio;
+#endif /* VBOX_WITH_AUDIO_RECORDING */
+
+    /** Internal scratch buffer for en-/decoding steps. */
+    void               *pvScratch;
+    /** Size (in bytes) of \a pvScratch. */
+    uint32_t            cbScratch;
+
+#ifdef VBOX_WITH_STATISTICS /** @todo Register these values with STAM. */
+    struct
+    {
+        /** Number of frames encoded. */
+        uint64_t        cEncBlocks;
+        /** Total time (in ms) of already encoded audio data. */
+        uint64_t        msEncTotal;
+    } STAM;
+#endif
+} RECORDINGCODEC, *PRECORDINGCODEC;
+
+/**
+ * Enumeration for supported pixel formats.
+ */
+enum RECORDINGPIXELFMT
+{
+    /** Unknown pixel format. */
+    RECORDINGPIXELFMT_UNKNOWN    = 0,
+    /** RGB 24. */
+    RECORDINGPIXELFMT_RGB24      = 1,
+    /** RGB 24. */
+    RECORDINGPIXELFMT_RGB32      = 2,
+    /** RGB 565. */
+    RECORDINGPIXELFMT_RGB565     = 3,
+    /** The usual 32-bit hack. */
+    RECORDINGPIXELFMT_32BIT_HACK = 0x7fffffff
+};
+
+/**
+ * Enumeration for a recording frame type.
+ */
+enum RECORDINGFRAME_TYPE
+{
+    /** Invalid frame type; do not use. */
+    RECORDINGFRAME_TYPE_INVALID   = 0,
+    /** Frame is an audio frame. */
+    RECORDINGFRAME_TYPE_AUDIO     = 1,
+    /** Frame is an video frame. */
+    RECORDINGFRAME_TYPE_VIDEO     = 2,
+    /** Frame contains a video frame pointer. */
+    RECORDINGFRAME_TYPE_VIDEO_PTR = 3
+};
+
+/**
+ * Structure for keeping a single recording video frame.
+ */
+typedef struct RECORDINGVIDEOFRAME
+{
+    /** X origin  (in pixel) of this frame. */
+    uint16_t            uX;
+    /** X origin  (in pixel) of this frame. */
+    uint16_t            uY;
+    /** X resolution (in pixel) of this frame. */
+    uint16_t            uWidth;
+    /** Y resolution (in pixel)  of this frame. */
+    uint16_t            uHeight;
+    /** Bits per pixel (BPP). */
+    uint8_t             uBPP;
+    /** Pixel format of this frame. */
+    RECORDINGPIXELFMT   enmPixelFmt;
+    /** Bytes per scan line. */
+    uint16_t            uBytesPerLine;
+    /** RGB buffer containing the unmodified frame buffer data from Main's display. */
+    uint8_t            *pu8RGBBuf;
+    /** Size (in bytes) of the RGB buffer. */
+    size_t              cbRGBBuf;
+} RECORDINGVIDEOFRAME, *PRECORDINGVIDEOFRAME;
+
+/**
+ * Structure for keeping a single recording audio frame.
+ */
+typedef struct RECORDINGAUDIOFRAME
+{
+    /** Pointer to audio data. */
+    uint8_t            *pvBuf;
+    /** Size (in bytes) of audio data. */
+    size_t              cbBuf;
+} RECORDINGAUDIOFRAME, *PRECORDINGAUDIOFRAME;
+
+/**
+ * Structure for keeping a single recording audio frame.
+ */
+typedef struct RECORDINGFRAME
+{
+    /** List node. */
+    RTLISTNODE              Node;
+    /** Stream index (hint) where this frame should go to.
+     *  Specify UINT16_MAX to broadcast to all streams. */
+    uint16_t                idStream;
+    /** The frame type. */
+    RECORDINGFRAME_TYPE     enmType;
+    /** Timestamp (PTS, in ms). */
+    uint64_t                msTimestamp;
+    union
+    {
+#ifdef VBOX_WITH_AUDIO_RECORDING
+        /** Audio frame data. */
+        RECORDINGAUDIOFRAME  Audio;
+#endif
+        /** Video frame data. */
+        RECORDINGVIDEOFRAME  Video;
+        /** A (weak) pointer to a video frame. */
+        RECORDINGVIDEOFRAME *VideoPtr;
+    };
+} RECORDINGFRAME, *PRECORDINGFRAME;
+
+/**
+ * Enumeration for specifying a video recording block type.
+ */
+typedef enum RECORDINGBLOCKTYPE
+{
+    /** Uknown block type, do not use. */
+    RECORDINGBLOCKTYPE_UNKNOWN = 0,
+    /** The block is a video frame. */
+    RECORDINGBLOCKTYPE_VIDEO,
+    /** The block is an audio frame. */
+    RECORDINGBLOCKTYPE_AUDIO
+} RECORDINGBLOCKTYPE;
+
+#ifdef VBOX_WITH_AUDIO_RECORDING
+int RecordingVideoFrameInit(PRECORDINGVIDEOFRAME pFrame, int w, int h, uint8_t uBPP, RECORDINGPIXELFMT enmPixelFmt);
+void RecordingVideoFrameDestroy(PRECORDINGVIDEOFRAME pFrame);
+void RecordingAudioFrameFree(PRECORDINGAUDIOFRAME pFrame);
+#endif
+void RecordingVideoFrameFree(PRECORDINGVIDEOFRAME pFrame);
+void RecordingFrameFree(PRECORDINGFRAME pFrame);
+
+/**
+ * Generic structure for keeping a single video recording (data) block.
+ */
+struct RecordingBlock
+{
+    RecordingBlock()
+        : enmType(RECORDINGBLOCKTYPE_UNKNOWN)
+        , cRefs(0)
+        , uFlags(RECORDINGCODEC_ENC_F_NONE)
+        , pvData(NULL)
+        , cbData(0) { }
+
+    virtual ~RecordingBlock()
+    {
+        Reset();
+    }
+
+    void Reset(void)
+    {
+        switch (enmType)
+        {
+            case RECORDINGBLOCKTYPE_UNKNOWN:
+                break;
+
+            case RECORDINGBLOCKTYPE_VIDEO:
+                RecordingVideoFrameFree((PRECORDINGVIDEOFRAME)pvData);
+                break;
+
+#ifdef VBOX_WITH_AUDIO_RECORDING
+            case RECORDINGBLOCKTYPE_AUDIO:
+                RecordingAudioFrameFree((PRECORDINGAUDIOFRAME)pvData);
+                break;
+#endif
+            default:
+                AssertFailed();
+                break;
+        }
+
+        enmType = RECORDINGBLOCKTYPE_UNKNOWN;
+        cRefs   = 0;
+        pvData  = NULL;
+        cbData  = 0;
+    }
+
+    /** The block's type. */
+    RECORDINGBLOCKTYPE enmType;
+    /** Number of references held of this block. */
+    uint16_t           cRefs;
+    /** Block flags of type RECORDINGCODEC_ENC_F_XXX. */
+    uint64_t           uFlags;
+    /** The (absolute) timestamp (in ms, PTS) of this block. */
+    uint64_t           msTimestamp;
+    /** Opaque data block to the actual block data, depending on the block's type. */
+    void              *pvData;
+    /** Size (in bytes) of the (opaque) data block. */
+    size_t             cbData;
+};
+
+/** List for keeping video recording (data) blocks. */
+typedef std::list<RecordingBlock *> RecordingBlockList;
+
+int recordingCodecCreateAudio(PRECORDINGCODEC pCodec, RecordingAudioCodec_T enmAudioCodec);
+int recordingCodecCreateVideo(PRECORDINGCODEC pCodec, RecordingVideoCodec_T enmVideoCodec);
+int recordingCodecInit(const PRECORDINGCODEC pCodec, const PRECORDINGCODECCALLBACKS pCallbacks, const settings::RecordingScreenSettings &Settings);
+int recordingCodecDestroy(PRECORDINGCODEC pCodec);
+int recordingCodecEncode(PRECORDINGCODEC pCodec, const PRECORDINGFRAME pFrame, size_t *pcEncoded, size_t *pcbEncoded);
+int recordingCodecFinalize(PRECORDINGCODEC pCodec);
+bool recordingCodecIsInitialized(const PRECORDINGCODEC pCodec);
+uint32_t recordingCodecGetWritable(const PRECORDINGCODEC pCodec, uint64_t msTimestamp);
+#endif /* !MAIN_INCLUDED_RecordingInternals_h */
diff --git a/src/VBox/Main/include/RecordingScreenSettingsImpl.h b/src/VBox/Main/include/RecordingScreenSettingsImpl.h
new file mode 100644
index 00000000..55c25f2c
--- /dev/null
+++ b/src/VBox/Main/include/RecordingScreenSettingsImpl.h
@@ -0,0 +1,141 @@
+/* $Id: RecordingScreenSettingsImpl.h $ */
+
+/** @file
+ *
+ * VirtualBox COM class implementation - Recording settings of one virtual screen.
+ */
+
+/*
+ * Copyright (C) 2018-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
+ */
+
+#ifndef MAIN_INCLUDED_RecordingScreenSettingsImpl_h
+#define MAIN_INCLUDED_RecordingScreenSettingsImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "RecordingScreenSettingsWrap.h"
+
+class RecordingSettings;
+
+namespace settings
+{
+    struct RecordingScreenSettings;
+}
+
+class ATL_NO_VTABLE RecordingScreenSettings :
+    public RecordingScreenSettingsWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(RecordingScreenSettings)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(RecordingSettings *aParent, uint32_t uScreenId, const settings::RecordingScreenSettings& aThat);
+    HRESULT init(RecordingSettings *aParent, RecordingScreenSettings *aThat);
+    HRESULT initCopy(RecordingSettings *aParent, RecordingScreenSettings *aThat);
+    void uninit(void);
+
+    // public methods only for internal purposes
+    HRESULT i_loadSettings(const settings::RecordingScreenSettings &data);
+    HRESULT i_saveSettings(settings::RecordingScreenSettings &data);
+
+    void i_rollback(void);
+    void i_commit(void);
+    void i_copyFrom(RecordingScreenSettings *aThat);
+    void i_applyDefaults(void);
+
+    settings::RecordingScreenSettings &i_getData(void);
+
+    int32_t i_reference(void);
+    int32_t i_release(void);
+    int32_t i_getReferences(void);
+
+private:
+
+    // wrapped IRecordingScreenSettings methods
+    HRESULT isFeatureEnabled(RecordingFeature_T aFeature, BOOL *aEnabled);
+
+    // wrapped IRecordingScreenSettings properties
+    HRESULT getId(ULONG *id);
+    HRESULT getEnabled(BOOL *enabled);
+    HRESULT setEnabled(BOOL enabled);
+    HRESULT getFeatures(std::vector<RecordingFeature_T> &aFeatures);
+    HRESULT setFeatures(const std::vector<RecordingFeature_T> &aFeatures);
+    HRESULT getDestination(RecordingDestination_T *aDestination);
+    HRESULT setDestination(RecordingDestination_T aDestination);
+
+    HRESULT getFilename(com::Utf8Str &aFilename);
+    HRESULT setFilename(const com::Utf8Str &aFilename);
+    HRESULT getMaxTime(ULONG *aMaxTimeS);
+    HRESULT setMaxTime(ULONG aMaxTimeS);
+    HRESULT getMaxFileSize(ULONG *aMaxFileSizeMB);
+    HRESULT setMaxFileSize(ULONG aMaxFileSizeMB);
+    HRESULT getOptions(com::Utf8Str &aOptions);
+    HRESULT setOptions(const com::Utf8Str &aOptions);
+
+    HRESULT getAudioCodec(RecordingAudioCodec_T *aCodec);
+    HRESULT setAudioCodec(RecordingAudioCodec_T aCodec);
+    HRESULT getAudioDeadline(RecordingCodecDeadline_T *aDeadline);
+    HRESULT setAudioDeadline(RecordingCodecDeadline_T aDeadline);
+    HRESULT getAudioRateControlMode(RecordingRateControlMode_T *aMode);
+    HRESULT setAudioRateControlMode(RecordingRateControlMode_T aMode);
+    HRESULT getAudioHz(ULONG *aHz);
+    HRESULT setAudioHz(ULONG aHz);
+    HRESULT getAudioBits(ULONG *aBits);
+    HRESULT setAudioBits(ULONG aBits);
+    HRESULT getAudioChannels(ULONG *aChannels);
+    HRESULT setAudioChannels(ULONG aChannels);
+
+    HRESULT getVideoCodec(RecordingVideoCodec_T *aCodec);
+    HRESULT setVideoCodec(RecordingVideoCodec_T aCodec);
+    HRESULT getVideoDeadline(RecordingCodecDeadline_T *aDeadline);
+    HRESULT setVideoDeadline(RecordingCodecDeadline_T aDeadline);
+    HRESULT getVideoWidth(ULONG *aVideoWidth);
+    HRESULT setVideoWidth(ULONG aVideoWidth);
+    HRESULT getVideoHeight(ULONG *aVideoHeight);
+    HRESULT setVideoHeight(ULONG aVideoHeight);
+    HRESULT getVideoRate(ULONG *aVideoRate);
+    HRESULT setVideoRate(ULONG aVideoRate);
+    HRESULT getVideoRateControlMode(RecordingRateControlMode_T *aMode);
+    HRESULT setVideoRateControlMode(RecordingRateControlMode_T aMode);
+    HRESULT getVideoFPS(ULONG *aVideoFPS);
+    HRESULT setVideoFPS(ULONG aVideoFPS);
+    HRESULT getVideoScalingMode(RecordingVideoScalingMode_T *aMode);
+    HRESULT setVideoScalingMode(RecordingVideoScalingMode_T aMode);
+
+private:
+
+    // internal methods
+    int i_initInternal();
+
+private:
+
+    struct Data;
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_RecordingScreenSettingsImpl_h */
+
diff --git a/src/VBox/Main/include/RecordingSettingsImpl.h b/src/VBox/Main/include/RecordingSettingsImpl.h
new file mode 100644
index 00000000..6f4f9aba
--- /dev/null
+++ b/src/VBox/Main/include/RecordingSettingsImpl.h
@@ -0,0 +1,102 @@
+/* $Id: RecordingSettingsImpl.h $ */
+/** @file
+ * VirtualBox COM class implementation - Machine recording screen settings.
+ */
+
+/*
+ * Copyright (C) 2018-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
+ */
+
+#ifndef MAIN_INCLUDED_RecordingSettingsImpl_h
+#define MAIN_INCLUDED_RecordingSettingsImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "RecordingSettingsWrap.h"
+
+namespace settings
+{
+    struct RecordingSettings;
+    struct RecordingScreenSettings;
+}
+
+class RecordingScreenSettings;
+
+class ATL_NO_VTABLE RecordingSettings
+    : public RecordingSettingsWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(RecordingSettings)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Machine *parent);
+    HRESULT init(Machine *parent, RecordingSettings *aThat);
+    HRESULT initCopy(Machine *parent, RecordingSettings *aThat);
+    void uninit();
+
+    // public methods only for internal purposes
+    HRESULT i_loadSettings(const settings::RecordingSettings &data);
+    HRESULT i_saveSettings(settings::RecordingSettings &data);
+
+    void    i_rollback(void);
+    void    i_commit(void);
+    HRESULT i_copyFrom(RecordingSettings *aThat);
+    void    i_applyDefaults(void);
+
+    int i_getDefaultFilename(Utf8Str &strFile, uint32_t idScreen, bool fWithFileExtension);
+    int i_getFilename(Utf8Str &strFile, uint32_t idScreen, const Utf8Str &strTemplate);
+    bool i_canChangeSettings(void);
+    void i_onSettingsChanged(void);
+
+private:
+
+    /** Map of screen settings objects. The key specifies the screen ID. */
+    typedef std::map <uint32_t, ComObjPtr<RecordingScreenSettings> > RecordingScreenSettingsObjMap;
+
+    void i_reset(void);
+    int i_syncToMachineDisplays(uint32_t cDisplays);
+    int i_createScreenObj(RecordingScreenSettingsObjMap &screenSettingsMap, uint32_t idScreen, const settings::RecordingScreenSettings &data);
+    int i_destroyScreenObj(RecordingScreenSettingsObjMap &screenSettingsMap, uint32_t idScreen);
+    int i_destroyAllScreenObj(RecordingScreenSettingsObjMap &screenSettingsMap);
+
+private:
+
+    // wrapped IRecordingSettings properties
+    HRESULT getEnabled(BOOL *enabled);
+    HRESULT setEnabled(BOOL enable);
+    HRESULT getScreens(std::vector<ComPtr<IRecordingScreenSettings> > &aRecordScreenSettings);
+
+    // wrapped IRecordingSettings methods
+    HRESULT getScreenSettings(ULONG uScreenId, ComPtr<IRecordingScreenSettings> &aRecordScreenSettings);
+
+private:
+
+    struct Data;
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_RecordingSettingsImpl_h */
+
diff --git a/src/VBox/Main/include/RecordingStream.h b/src/VBox/Main/include/RecordingStream.h
new file mode 100644
index 00000000..7d9dc48d
--- /dev/null
+++ b/src/VBox/Main/include/RecordingStream.h
@@ -0,0 +1,234 @@
+/* $Id: RecordingStream.h $ */
+/** @file
+ * Recording stream code header.
+ */
+
+/*
+ * Copyright (C) 2012-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
+ */
+
+#ifndef MAIN_INCLUDED_RecordingStream_h
+#define MAIN_INCLUDED_RecordingStream_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <map>
+#include <vector>
+
+#include <iprt/critsect.h>
+
+#include "RecordingInternals.h"
+
+class WebMWriter;
+class RecordingContext;
+
+/** Structure for queuing all blocks bound to a single timecode.
+ *  This can happen if multiple tracks are being involved. */
+struct RecordingBlocks
+{
+    virtual ~RecordingBlocks()
+    {
+        Clear();
+    }
+
+    /**
+     * Resets a recording block list by removing (destroying)
+     * all current elements.
+     */
+    void Clear()
+    {
+        while (!List.empty())
+        {
+            RecordingBlock *pBlock = List.front();
+            List.pop_front();
+            delete pBlock;
+        }
+
+        Assert(List.size() == 0);
+    }
+
+    /** The actual block list for this timecode. */
+    RecordingBlockList List;
+};
+
+/** A block map containing all currently queued blocks.
+ *  The key specifies a unique timecode, whereas the value
+ *  is a list of blocks which all correlate to the same key (timecode). */
+typedef std::map<uint64_t, RecordingBlocks *> RecordingBlockMap;
+
+/**
+ * Structure for holding a set of recording (data) blocks.
+ */
+struct RecordingBlockSet
+{
+    virtual ~RecordingBlockSet()
+    {
+        Clear();
+    }
+
+    /**
+     * Resets a recording block set by removing (destroying)
+     * all current elements.
+     */
+    void Clear(void)
+    {
+        RecordingBlockMap::iterator it = Map.begin();
+        while (it != Map.end())
+        {
+            it->second->Clear();
+            delete it->second;
+            Map.erase(it);
+            it = Map.begin();
+        }
+
+        Assert(Map.size() == 0);
+    }
+
+    /** Timestamp (in ms) when this set was last processed. */
+    uint64_t         tsLastProcessedMs;
+    /** All blocks related to this block set. */
+    RecordingBlockMap Map;
+};
+
+/**
+ * Class for managing a recording stream.
+ *
+ * A recording stream represents one entity to record (e.g. on screen / monitor),
+ * so there is a 1:1 mapping (stream <-> monitors).
+ */
+class RecordingStream
+{
+public:
+
+    RecordingStream(RecordingContext *pCtx, uint32_t uScreen, const settings::RecordingScreenSettings &Settings);
+
+    virtual ~RecordingStream(void);
+
+public:
+
+    int Init(RecordingContext *pCtx, uint32_t uScreen, const settings::RecordingScreenSettings &Settings);
+    int Uninit(void);
+
+    int Process(RecordingBlockMap &mapBlocksCommon);
+    int SendAudioFrame(const void *pvData, size_t cbData, uint64_t msTimestamp);
+    int SendVideoFrame(uint32_t x, uint32_t y, uint32_t uPixelFormat, uint32_t uBPP, uint32_t uBytesPerLine,
+                       uint32_t uSrcWidth, uint32_t uSrcHeight, uint8_t *puSrcData, uint64_t msTimestamp);
+
+    const settings::RecordingScreenSettings &GetConfig(void) const;
+    uint16_t GetID(void) const { return this->m_uScreenID; };
+#ifdef VBOX_WITH_AUDIO_RECORDING
+    PRECORDINGCODEC GetAudioCodec(void) { return this->m_pCodecAudio; };
+#endif
+    PRECORDINGCODEC GetVideoCodec(void) { return &this->m_CodecVideo; };
+
+    bool IsLimitReached(uint64_t msTimestamp) const;
+    bool IsReady(void) const;
+    bool NeedsUpdate(uint64_t msTimestamp) const;
+
+public:
+
+    static DECLCALLBACK(int) codecWriteDataCallback(PRECORDINGCODEC pCodec, const void *pvData, size_t cbData, uint64_t msAbsPTS, uint32_t uFlags, void *pvUser);
+
+protected:
+
+    int open(const settings::RecordingScreenSettings &screenSettings);
+    int close(void);
+
+    int initInternal(RecordingContext *pCtx, uint32_t uScreen, const settings::RecordingScreenSettings &screenSettings);
+    int uninitInternal(void);
+
+    int initVideo(const settings::RecordingScreenSettings &screenSettings);
+    int unitVideo(void);
+
+    bool isLimitReachedInternal(uint64_t msTimestamp) const;
+    int iterateInternal(uint64_t msTimestamp);
+
+    int codecWriteToWebM(PRECORDINGCODEC pCodec, const void *pvData, size_t cbData, uint64_t msAbsPTS, uint32_t uFlags);
+
+    void lock(void);
+    void unlock(void);
+
+protected:
+
+    /**
+     * Enumeration for a recording stream state.
+     */
+    enum RECORDINGSTREAMSTATE
+    {
+        /** Stream not initialized. */
+        RECORDINGSTREAMSTATE_UNINITIALIZED = 0,
+        /** Stream was initialized. */
+        RECORDINGSTREAMSTATE_INITIALIZED   = 1,
+        /** The usual 32-bit hack. */
+        RECORDINGSTREAMSTATE_32BIT_HACK    = 0x7fffffff
+    };
+
+    /** Recording context this stream is associated to. */
+    RecordingContext       *m_pCtx;
+    /** The current state. */
+    RECORDINGSTREAMSTATE    m_enmState;
+    struct
+    {
+        /** File handle to use for writing. */
+        RTFILE              m_hFile;
+        /** Pointer to WebM writer instance being used. */
+        WebMWriter         *m_pWEBM;
+    } File;
+    bool                m_fEnabled;
+    /** Track number of audio stream.
+     *  Set to UINT8_MAX if not being used. */
+    uint8_t             m_uTrackAudio;
+    /** Track number of video stream.
+     *  Set to UINT8_MAX if not being used. */
+    uint8_t             m_uTrackVideo;
+    /** Screen ID. */
+    uint16_t            m_uScreenID;
+    /** Critical section to serialize access. */
+    RTCRITSECT          m_CritSect;
+    /** Timestamp (in ms) of when recording has been started. */
+    uint64_t            m_tsStartMs;
+#ifdef VBOX_WITH_AUDIO_RECORDING
+    /** Pointer to audio codec instance data to use.
+     *
+     *  We multiplex audio data from the recording context to all streams,
+     *  to avoid encoding the same audio data for each stream. We ASSUME that
+     *  all audio data of a VM will be the same for each stream at a given
+     *  point in time.
+     *
+     *  Might be NULL if not being used. */
+    PRECORDINGCODEC     m_pCodecAudio;
+#endif /* VBOX_WITH_AUDIO_RECORDING */
+    /** Video codec instance data to use. */
+    RECORDINGCODEC      m_CodecVideo;
+    /** Screen settings to use. */
+    settings::RecordingScreenSettings
+                        m_ScreenSettings;
+    /** Common set of recording (data) blocks, needed for
+     *  multiplexing to all recording streams. */
+    RecordingBlockSet   m_Blocks;
+};
+
+/** Vector of recording streams. */
+typedef std::vector <RecordingStream *> RecordingStreams;
+
+#endif /* !MAIN_INCLUDED_RecordingStream_h */
+
diff --git a/src/VBox/Main/include/RecordingUtils.h b/src/VBox/Main/include/RecordingUtils.h
new file mode 100644
index 00000000..f8fa1356
--- /dev/null
+++ b/src/VBox/Main/include/RecordingUtils.h
@@ -0,0 +1,217 @@
+/* $Id: RecordingUtils.h $ */
+/** @file
+ * Recording utility header.
+ */
+
+/*
+ * Copyright (C) 2012-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
+ */
+
+#ifndef MAIN_INCLUDED_RecordingUtils_h
+#define MAIN_INCLUDED_RecordingUtils_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "RecordingInternals.h"
+
+
+/**
+ * Iterator class for running through a BGRA32 image buffer and converting
+ * it to RGB.
+ */
+class ColorConvBGRA32Iter
+{
+private:
+    enum { PIX_SIZE = 4 };
+public:
+    ColorConvBGRA32Iter(unsigned aWidth, unsigned aHeight, uint8_t *aBuf)
+    {
+        mPos = 0;
+        mSize = aWidth * aHeight * PIX_SIZE;
+        mBuf = aBuf;
+    }
+
+    /**
+     * Convert the next pixel to RGB.
+     *
+     * @returns true on success, false if we have reached the end of the buffer
+     * @param   aRed            where to store the red value.
+     * @param   aGreen          where to store the green value.
+     * @param   aBlue           where to store the blue value.
+     */
+    bool getRGB(unsigned *aRed, unsigned *aGreen, unsigned *aBlue)
+    {
+        bool rc = false;
+        if (mPos + PIX_SIZE <= mSize)
+        {
+            *aRed   = mBuf[mPos + 2];
+            *aGreen = mBuf[mPos + 1];
+            *aBlue  = mBuf[mPos    ];
+            mPos += PIX_SIZE;
+            rc = true;
+        }
+        return rc;
+    }
+
+    /**
+     * Skip forward by a certain number of pixels.
+     *
+     * @param aPixels           How many pixels to skip.
+     */
+    void skip(unsigned aPixels)
+    {
+        mPos += PIX_SIZE * aPixels;
+    }
+private:
+    /** Size of the picture buffer. */
+    unsigned mSize;
+    /** Current position in the picture buffer. */
+    unsigned mPos;
+    /** Address of the picture buffer. */
+    uint8_t *mBuf;
+};
+
+/**
+ * Iterator class for running through an BGR24 image buffer and converting
+ * it to RGB.
+ */
+class ColorConvBGR24Iter
+{
+private:
+    enum { PIX_SIZE = 3 };
+public:
+    ColorConvBGR24Iter(unsigned aWidth, unsigned aHeight, uint8_t *aBuf)
+    {
+        mPos = 0;
+        mSize = aWidth * aHeight * PIX_SIZE;
+        mBuf = aBuf;
+    }
+
+    /**
+     * Convert the next pixel to RGB.
+     *
+     * @returns true on success, false if we have reached the end of the buffer.
+     * @param   aRed            where to store the red value.
+     * @param   aGreen          where to store the green value.
+     * @param   aBlue           where to store the blue value.
+     */
+    bool getRGB(unsigned *aRed, unsigned *aGreen, unsigned *aBlue)
+    {
+        bool rc = false;
+        if (mPos + PIX_SIZE <= mSize)
+        {
+            *aRed   = mBuf[mPos + 2];
+            *aGreen = mBuf[mPos + 1];
+            *aBlue  = mBuf[mPos    ];
+            mPos += PIX_SIZE;
+            rc = true;
+        }
+        return rc;
+    }
+
+    /**
+     * Skip forward by a certain number of pixels.
+     *
+     * @param aPixels           How many pixels to skip.
+     */
+    void skip(unsigned aPixels)
+    {
+        mPos += PIX_SIZE * aPixels;
+    }
+private:
+    /** Size of the picture buffer. */
+    unsigned mSize;
+    /** Current position in the picture buffer. */
+    unsigned mPos;
+    /** Address of the picture buffer. */
+    uint8_t *mBuf;
+};
+
+/**
+ * Iterator class for running through an BGR565 image buffer and converting
+ * it to RGB.
+ */
+class ColorConvBGR565Iter
+{
+private:
+    enum { PIX_SIZE = 2 };
+public:
+    ColorConvBGR565Iter(unsigned aWidth, unsigned aHeight, uint8_t *aBuf)
+    {
+        mPos = 0;
+        mSize = aWidth * aHeight * PIX_SIZE;
+        mBuf = aBuf;
+    }
+
+    /**
+     * Convert the next pixel to RGB.
+     *
+     * @returns true on success, false if we have reached the end of the buffer.
+     * @param   aRed            Where to store the red value.
+     * @param   aGreen          where to store the green value.
+     * @param   aBlue           where to store the blue value.
+     */
+    bool getRGB(unsigned *aRed, unsigned *aGreen, unsigned *aBlue)
+    {
+        bool rc = false;
+        if (mPos + PIX_SIZE <= mSize)
+        {
+            unsigned uFull =  (((unsigned) mBuf[mPos + 1]) << 8)
+                             | ((unsigned) mBuf[mPos]);
+            *aRed   = (uFull >> 8) & ~7;
+            *aGreen = (uFull >> 3) & ~3 & 0xff;
+            *aBlue  = (uFull << 3) & ~7 & 0xff;
+            mPos += PIX_SIZE;
+            rc = true;
+        }
+        return rc;
+    }
+
+    /**
+     * Skip forward by a certain number of pixels.
+     *
+     * @param aPixels           How many pixels to skip.
+     */
+    void skip(unsigned aPixels)
+    {
+        mPos += PIX_SIZE * aPixels;
+    }
+private:
+    /** Size of the picture buffer. */
+    unsigned mSize;
+    /** Current position in the picture buffer. */
+    unsigned mPos;
+    /** Address of the picture buffer. */
+    uint8_t *mBuf;
+};
+
+int RecordingUtilsRGBToYUV(RECORDINGPIXELFMT enmPixelFormat,
+                           uint8_t *paDst, uint32_t uDstWidth, uint32_t uDstHeight,
+                           uint8_t *paSrc, uint32_t uSrcWidth, uint32_t uSrcHeight);
+
+#ifdef DEBUG
+int RecordingUtilsDbgDumpFrameEx(const uint8_t *pu8RGBBuf, size_t cbRGBBuf, const char *pszPath, const char *pszPrefx, uint16_t uWidth, uint32_t uHeight, uint8_t uBPP);
+int RecordingUtilsDbgDumpFrame(const PRECORDINGFRAME pFrame);
+#endif
+
+#endif /* !MAIN_INCLUDED_RecordingUtils_h */
+
diff --git a/src/VBox/Main/include/RemoteUSBBackend.h b/src/VBox/Main/include/RemoteUSBBackend.h
new file mode 100644
index 00000000..a8902969
--- /dev/null
+++ b/src/VBox/Main/include/RemoteUSBBackend.h
@@ -0,0 +1,153 @@
+/* $Id: RemoteUSBBackend.h $ */
+/** @file
+ *
+ * VirtualBox Remote USB backend
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_RemoteUSBBackend_h
+#define MAIN_INCLUDED_RemoteUSBBackend_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "RemoteUSBDeviceImpl.h"
+
+#include <VBox/RemoteDesktop/VRDE.h>
+#include <VBox/vrdpusb.h>
+
+#include <iprt/critsect.h>
+
+//typedef enum
+//{
+//    RDLIdle = 0,
+//    RDLReqSent,
+//    RDLObtained
+//} RDLState;
+
+class Console;
+class ConsoleVRDPServer;
+
+DECLCALLBACK(int) USBClientResponseCallback (void *pv, uint32_t u32ClientId, uint8_t code, const void *pvRet, uint32_t cbRet);
+
+
+/* How many remote devices can be attached to a remote client.
+ * Normally a client computer has 2-8 physical USB ports, so 16 devices
+ * should be usually enough.
+ */
+#define VRDP_MAX_USB_DEVICES_PER_CLIENT (16)
+
+class RemoteUSBBackendListable
+{
+    public:
+        RemoteUSBBackendListable *pNext;
+        RemoteUSBBackendListable *pPrev;
+
+        RemoteUSBBackendListable() : pNext (NULL), pPrev (NULL) {};
+};
+
+class RemoteUSBBackend: public RemoteUSBBackendListable
+{
+    public:
+        RemoteUSBBackend(Console *console, ConsoleVRDPServer *server, uint32_t u32ClientId);
+        ~RemoteUSBBackend();
+
+        uint32_t ClientId (void) { return mu32ClientId; }
+
+        void AddRef (void);
+        void Release (void);
+
+        REMOTEUSBCALLBACK *GetBackendCallbackPointer (void) { return &mCallback; }
+
+        void NotifyDelete (void);
+
+        void PollRemoteDevices (void);
+
+    public: /* Functions for internal use. */
+        ConsoleVRDPServer *VRDPServer (void) { return mServer; };
+
+        bool pollingEnabledURB (void) { return mfPollURB; }
+
+        int saveDeviceList (const void *pvList, uint32_t cbList);
+
+        int negotiateResponse (const VRDEUSBREQNEGOTIATERET *pret, uint32_t cbRet);
+
+        int reapURB (const void *pvBody, uint32_t cbBody);
+
+        void request (void);
+        void release (void);
+
+        PREMOTEUSBDEVICE deviceFromId (VRDEUSBDEVID id);
+
+        void addDevice (PREMOTEUSBDEVICE pDevice);
+        void removeDevice (PREMOTEUSBDEVICE pDevice);
+
+        bool addUUID (const Guid *pUuid);
+        bool findUUID (const Guid *pUuid);
+        void removeUUID (const Guid *pUuid);
+
+    private:
+        Console *mConsole;
+        ConsoleVRDPServer *mServer;
+
+        int cRefs;
+
+        uint32_t mu32ClientId;
+
+        RTCRITSECT mCritsect;
+
+        REMOTEUSBCALLBACK mCallback;
+
+        bool mfHasDeviceList;
+
+        void *mpvDeviceList;
+        uint32_t mcbDeviceList;
+
+        typedef enum {
+            PollRemoteDevicesStatus_Negotiate,
+            PollRemoteDevicesStatus_WaitNegotiateResponse,
+            PollRemoteDevicesStatus_SendRequest,
+            PollRemoteDevicesStatus_WaitResponse,
+            PollRemoteDevicesStatus_Dereferenced
+        } PollRemoteDevicesStatus;
+
+        PollRemoteDevicesStatus menmPollRemoteDevicesStatus;
+
+        bool mfPollURB;
+
+        PREMOTEUSBDEVICE mpDevices;
+
+        bool mfWillBeDeleted;
+
+        Guid aGuids[VRDP_MAX_USB_DEVICES_PER_CLIENT];
+
+        /* VRDP_USB_VERSION_2: the client version. */
+        uint32_t mClientVersion;
+
+        /* VRDP_USB_VERSION_3: the client sends VRDE_USB_REQ_DEVICE_LIST_EXT_RET. */
+        bool mfDescExt;
+};
+
+#endif /* !MAIN_INCLUDED_RemoteUSBBackend_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/RemoteUSBDeviceImpl.h b/src/VBox/Main/include/RemoteUSBDeviceImpl.h
new file mode 100644
index 00000000..b6d801a1
--- /dev/null
+++ b/src/VBox/Main/include/RemoteUSBDeviceImpl.h
@@ -0,0 +1,136 @@
+/* $Id: RemoteUSBDeviceImpl.h $ */
+
+/** @file
+ *
+ * VirtualBox IHostUSBDevice COM interface implementation
+ * for remote (VRDP) USB devices
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_RemoteUSBDeviceImpl_h
+#define MAIN_INCLUDED_RemoteUSBDeviceImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "HostUSBDeviceWrap.h"
+
+struct _VRDEUSBDEVICEDESC;
+typedef _VRDEUSBDEVICEDESC VRDEUSBDEVICEDESC;
+
+class ATL_NO_VTABLE RemoteUSBDevice :
+    public HostUSBDeviceWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(RemoteUSBDevice)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(uint32_t u32ClientId, VRDEUSBDEVICEDESC const *pDevDesc, bool fDescExt);
+    void uninit();
+
+    // public methods only for internal purposes
+    bool dirty(void) const { return mData.dirty; }
+    void dirty(bool aDirty) { mData.dirty = aDirty; }
+
+    uint16_t devId(void) const { return mData.devId; }
+    uint32_t clientId(void) { return mData.clientId; }
+
+    bool captured(void) const { return mData.state == USBDeviceState_Captured; }
+    void captured(bool aCaptured)
+    {
+        if (aCaptured)
+        {
+            Assert(mData.state == USBDeviceState_Available);
+            mData.state = USBDeviceState_Captured;
+        }
+        else
+        {
+            Assert(mData.state == USBDeviceState_Captured);
+            mData.state = USBDeviceState_Available;
+        }
+    }
+
+private:
+
+    // wrapped IUSBDevice properties
+    HRESULT getId(com::Guid &aId);
+    HRESULT getVendorId(USHORT *aVendorId);
+    HRESULT getProductId(USHORT *aProductId);
+    HRESULT getRevision(USHORT *aRevision);
+    HRESULT getManufacturer(com::Utf8Str &aManufacturer);
+    HRESULT getProduct(com::Utf8Str &aProduct);
+    HRESULT getSerialNumber(com::Utf8Str &aSerialNumber);
+    HRESULT getAddress(com::Utf8Str &aAddress);
+    HRESULT getPort(USHORT *aPort);
+    HRESULT getVersion(USHORT *aVersion);
+    HRESULT getPortPath(com::Utf8Str &aAddress);
+    HRESULT getSpeed(USBConnectionSpeed_T *aSpeed);
+    HRESULT getRemote(BOOL *aRemote);
+    HRESULT getBackend(com::Utf8Str &aBackend);
+    HRESULT getDeviceInfo(std::vector<com::Utf8Str> &aInfo);
+
+    // wrapped IHostUSBDevice properties
+    HRESULT getState(USBDeviceState_T *aState);
+
+
+    struct Data
+    {
+        Data() : vendorId(0), productId(0), revision(0), port(0), version(1),
+                 speed(USBConnectionSpeed_Null), dirty(FALSE),
+                 devId(0), clientId(0) {}
+
+        const Guid id;
+
+        const uint16_t vendorId;
+        const uint16_t productId;
+        const uint16_t revision;
+
+        const Utf8Str manufacturer;
+        const Utf8Str product;
+        const Utf8Str serialNumber;
+
+        const Utf8Str address;
+        const Utf8Str backend;
+
+        const uint16_t port;
+        const Utf8Str portPath;
+        const uint16_t version;
+        const USBConnectionSpeed_T speed;
+
+        USBDeviceState_T state;
+        bool dirty;
+
+        const uint16_t devId;
+        const uint32_t clientId;
+    };
+
+    Data mData;
+};
+
+#endif /* !MAIN_INCLUDED_RemoteUSBDeviceImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/SecretKeyStore.h b/src/VBox/Main/include/SecretKeyStore.h
new file mode 100644
index 00000000..faebfe4a
--- /dev/null
+++ b/src/VBox/Main/include/SecretKeyStore.h
@@ -0,0 +1,216 @@
+/* $Id: SecretKeyStore.h $ */
+/** @file
+ * Main - Secret key interface.
+ */
+
+/*
+ * Copyright (C) 2015-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
+ */
+
+#ifndef MAIN_INCLUDED_SecretKeyStore_h
+#define MAIN_INCLUDED_SecretKeyStore_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "VirtualBoxBase.h"
+#include "VBox/com/array.h"
+
+class SecretKey
+{
+    public:
+
+        /**
+         * Constructor for a secret key.
+         *
+         * @param pbKey                 The key buffer.
+         * @param cbKey                 Size of the key.
+         * @param fKeyBufNonPageable    Flag whether the key buffer should be non pageable.
+         */
+        SecretKey(const uint8_t *pbKey, size_t cbKey, bool fKeyBufNonPageable);
+
+        /**
+         * Secret key destructor.
+         */
+        ~SecretKey();
+
+        /**
+         * Increments the reference counter of the key.
+         *
+         * @returns The new reference count.
+         */
+        uint32_t retain();
+
+        /**
+         * Releases a reference of the key.
+         * If the reference counter reaches 0 the key buffer might be protected
+         * against further access or the data will become scrambled.
+         *
+         * @returns The new reference count.
+         */
+        uint32_t release();
+
+        /**
+         * Returns the reference count of the secret key.
+         */
+        uint32_t refCount();
+
+        /**
+         * Sets the possible number of users for this key.
+         *
+         * @returns VBox status code.
+         * @param   cUsers              The possible number of user for this key.
+         */
+        int setUsers(uint32_t cUsers);
+
+        /**
+         * Returns the possible amount of users.
+         *
+         * @returns Possible amount of users.
+         */
+        uint32_t getUsers();
+
+        /**
+         * Sets the remove on suspend flag.
+         *
+         * @returns VBox status code.
+         * @param   fRemoveOnSuspend    Flag whether to remove the key on host suspend.
+         */
+        int setRemoveOnSuspend(bool fRemoveOnSuspend);
+
+        /**
+         * Returns whether the key should be destroyed on suspend.
+         */
+        bool getRemoveOnSuspend();
+
+        /**
+         * Returns the buffer to the key.
+         */
+        const void *getKeyBuffer();
+
+        /**
+         * Returns the size of the key.
+         */
+        size_t getKeySize();
+
+    private:
+        /** Reference counter of the key. */
+        volatile uint32_t m_cRefs;
+        /** Key material. */
+        uint8_t          *m_pbKey;
+        /** Size of the key in bytes. */
+        size_t            m_cbKey;
+        /** Flag whether to remove the key on suspend. */
+        bool              m_fRemoveOnSuspend;
+        /** Number of entities which will use this key. */
+        uint32_t          m_cUsers;
+};
+
+class SecretKeyStore
+{
+    public:
+
+        typedef std::map<com::Utf8Str, SecretKey *> SecretKeyMap;
+
+        /**
+         * Constructor for a secret key store.
+         *
+         * @param fKeyBufNonPageable    Flag whether the key buffer is required to
+         *                              be non pageable.
+         */
+        SecretKeyStore(bool fKeyBufNonPageable);
+
+        /**
+         * Destructor of a secret key store. This will free all stored secret keys
+         * inluding the key buffers. Make sure there no one accesses one of the keys
+         * stored.
+         */
+        ~SecretKeyStore();
+
+        /**
+         * Add a secret key to the store.
+         *
+         * @returns VBox status code.
+         * @param   strKeyId            The key identifier.
+         * @param   pbKey               The key to store.
+         * @param   cbKey               Size of the key.
+         */
+        int addSecretKey(const com::Utf8Str &strKeyId, const uint8_t *pbKey, size_t cbKey);
+
+        /**
+         * Deletes a key from the key store associated with the given identifier.
+         *
+         * @returns VBox status code.
+         * @param   strKeyId            The key identifier.
+         */
+        int deleteSecretKey(const com::Utf8Str &strKeyId);
+
+        /**
+         * Returns the secret key object associated with the given identifier.
+         * This increments the reference counter of the secret key object.
+         *
+         * @returns VBox status code.
+         * @param   strKeyId            The key identifier.
+         * @param   ppKey               Where to store the secret key object on success.
+         */
+        int retainSecretKey(const com::Utf8Str &strKeyId, SecretKey **ppKey);
+
+        /**
+         * Releases a reference to the secret key object.
+         *
+         * @returns VBox status code.
+         * @param   strKeyId            The key identifier.
+         */
+        int releaseSecretKey(const com::Utf8Str &strKeyId);
+
+        /**
+         * Deletes all secret keys from the key store.
+         *
+         * @returns VBox status code.
+         * @param   fSuspend           Flag whether to delete only keys which are
+         *                             marked for deletion during a suspend.
+         * @param   fForce             Flag whether to force deletion if some keys
+         *                             are still in use. Otherwise an error is returned.
+         */
+        int deleteAllSecretKeys(bool fSuspend, bool fForce);
+
+        /**
+         * Iterators for enumerating keys
+         */
+        SecretKeyMap::iterator begin()
+        {
+            return m_mapSecretKeys.begin();
+        }
+
+        SecretKeyMap::iterator end()
+        {
+            return m_mapSecretKeys.end();
+        }
+
+    private:
+
+        /** The map to map key identifers to secret keys. */
+        SecretKeyMap m_mapSecretKeys;
+        /** Flag whether key buffers should be non pagable. */
+        bool         m_fKeyBufNonPageable;
+};
+
+#endif /* !MAIN_INCLUDED_SecretKeyStore_h */
diff --git a/src/VBox/Main/include/SerialPortImpl.h b/src/VBox/Main/include/SerialPortImpl.h
new file mode 100644
index 00000000..631410a3
--- /dev/null
+++ b/src/VBox/Main/include/SerialPortImpl.h
@@ -0,0 +1,102 @@
+/* $Id: SerialPortImpl.h $ */
+
+/** @file
+ *
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_SerialPortImpl_h
+#define MAIN_INCLUDED_SerialPortImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "SerialPortWrap.h"
+
+class GuestOSType;
+
+namespace settings
+{
+    struct SerialPort;
+}
+
+class ATL_NO_VTABLE SerialPort :
+    public SerialPortWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(SerialPort)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Machine *aParent, ULONG aSlot);
+    HRESULT init(Machine *aParent, SerialPort *aThat);
+    HRESULT initCopy(Machine *parent, SerialPort *aThat);
+    void uninit();
+
+    // public methods only for internal purposes
+    HRESULT i_loadSettings(const settings::SerialPort &data);
+    HRESULT i_saveSettings(settings::SerialPort &data);
+
+    bool i_isModified();
+    void i_rollback();
+    void i_commit();
+    void i_copyFrom(SerialPort *aThat);
+
+    void i_applyDefaults(GuestOSType *aOsType);
+    bool i_hasDefaults();
+
+    // public methods for internal purposes only
+    // (ensure there is a caller and a read lock before calling them!)
+
+private:
+
+    HRESULT i_checkSetPath(const Utf8Str &str);
+
+    // Wrapped ISerialPort properties
+    HRESULT getEnabled(BOOL *aEnabled);
+    HRESULT setEnabled(BOOL aEnabled);
+    HRESULT getHostMode(PortMode_T *aHostMode);
+    HRESULT setHostMode(PortMode_T aHostMode);
+    HRESULT getSlot(ULONG *aSlot);
+    HRESULT getIRQ(ULONG *aIRQ);
+    HRESULT setIRQ(ULONG aIRQ);
+    HRESULT getIOBase(ULONG *aIOBase);
+    HRESULT setIOBase(ULONG aIOBase);
+    HRESULT getServer(BOOL *aServer);
+    HRESULT setServer(BOOL aServer);
+    HRESULT getPath(com::Utf8Str &aPath);
+    HRESULT setPath(const com::Utf8Str &aPath);
+    HRESULT getUartType(UartType_T *aUartType);
+    HRESULT setUartType(UartType_T aUartType);
+
+    struct Data;
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_SerialPortImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/SessionImpl.h b/src/VBox/Main/include/SessionImpl.h
new file mode 100644
index 00000000..afa0c7df
--- /dev/null
+++ b/src/VBox/Main/include/SessionImpl.h
@@ -0,0 +1,188 @@
+/* $Id: SessionImpl.h $ */
+/** @file
+ * VBox Client Session COM Class definition
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_SessionImpl_h
+#define MAIN_INCLUDED_SessionImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "SessionWrap.h"
+#include "ConsoleImpl.h"
+
+#ifdef RT_OS_WINDOWS
+# include "win/resource.h"
+#endif
+
+#if defined(RT_OS_WINDOWS) && !RT_MSC_PREREQ(RT_MSC_VER_VC140)
+[threading(free)]
+#endif
+class ATL_NO_VTABLE Session :
+    public SessionWrap
+#ifdef RT_OS_WINDOWS
+    , public ATL::CComCoClass<Session, &CLSID_Session>
+#endif
+{
+public:
+
+    DECLARE_CLASSFACTORY()
+
+    // Do not use any ATL registry support.
+    //DECLARE_REGISTRY_RESOURCEID(IDR_VIRTUALBOX)
+
+    DECLARE_NOT_AGGREGATABLE(Session)
+
+    DECLARE_COMMON_CLASS_METHODS(Session)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializers/uninitializers only for internal purposes
+    HRESULT init();
+    void uninit();
+
+private:
+
+    // Wrapped ISession properties
+    HRESULT getState(SessionState_T *aState);
+    HRESULT getType(SessionType_T *aType);
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT setName(const com::Utf8Str &aName);
+    HRESULT getMachine(ComPtr<IMachine> &aMachine);
+    HRESULT getConsole(ComPtr<IConsole> &aConsole);
+
+    // Wrapped ISession methods
+    HRESULT unlockMachine();
+
+    // Wrapped IInternalSessionControl properties
+    HRESULT getPID(ULONG *aPid);
+    HRESULT getRemoteConsole(ComPtr<IConsole> &aRemoteConsole);
+    HRESULT getNominalState(MachineState_T *aNominalState);
+
+    // Wrapped IInternalSessionControl methods
+#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
+    HRESULT assignMachine(const ComPtr<IMachine> &aMachine,
+                          LockType_T aLockType,
+                          const com::Utf8Str &aTokenId);
+#else
+    HRESULT assignMachine(const ComPtr<IMachine> &aMachine,
+                          LockType_T aLockType,
+                          const ComPtr<IToken> &aToken);
+#endif /* !VBOX_WITH_GENERIC_SESSION_WATCHER */
+    HRESULT assignRemoteMachine(const ComPtr<IMachine> &aMachine,
+                                const ComPtr<IConsole> &aConsole);
+    HRESULT updateMachineState(MachineState_T aMachineState);
+    HRESULT uninitialize();
+    HRESULT onNetworkAdapterChange(const ComPtr<INetworkAdapter> &aNetworkAdapter,
+                                   BOOL aChangeAdapter);
+    HRESULT onAudioAdapterChange(const ComPtr<IAudioAdapter> &aAudioAdapter);
+    HRESULT onHostAudioDeviceChange(const ComPtr<IHostAudioDevice> &aDevice,
+                                    BOOL aNew, AudioDeviceState_T aState,
+                                    const ComPtr<IVirtualBoxErrorInfo> &aErrInfo);
+    HRESULT onSerialPortChange(const ComPtr<ISerialPort> &aSerialPort);
+    HRESULT onParallelPortChange(const ComPtr<IParallelPort> &aParallelPort);
+    HRESULT onStorageControllerChange(const Guid &aMachineId, const com::Utf8Str& aControllerName);
+    HRESULT onMediumChange(const ComPtr<IMediumAttachment> &aMediumAttachment,
+                           BOOL aForce);
+    HRESULT onStorageDeviceChange(const ComPtr<IMediumAttachment> &aMediumAttachment,
+                                  BOOL aRemove,
+                                  BOOL aSilent);
+    HRESULT onVMProcessPriorityChange(VMProcPriority_T priority);
+    HRESULT onClipboardModeChange(ClipboardMode_T aClipboardMode);
+    HRESULT onClipboardFileTransferModeChange(BOOL aEnabled);
+    HRESULT onDnDModeChange(DnDMode_T aDndMode);
+    HRESULT onCPUChange(ULONG aCpu,
+                        BOOL aAdd);
+    HRESULT onCPUExecutionCapChange(ULONG aExecutionCap);
+    HRESULT onVRDEServerChange(BOOL aRestart);
+    HRESULT onRecordingChange(BOOL aEnable);
+    HRESULT onUSBControllerChange();
+    HRESULT onSharedFolderChange(BOOL aGlobal);
+    HRESULT onGuestDebugControlChange(const ComPtr<IGuestDebugControl> &aGuestDebugControl);
+    HRESULT onUSBDeviceAttach(const ComPtr<IUSBDevice> &aDevice,
+                              const ComPtr<IVirtualBoxErrorInfo> &aError,
+                              ULONG aMaskedInterfaces,
+                              const com::Utf8Str &aCaptureFilename);
+    HRESULT onUSBDeviceDetach(const com::Guid &aId,
+                              const ComPtr<IVirtualBoxErrorInfo> &aError);
+    HRESULT onShowWindow(BOOL aCheck,
+                         BOOL *aCanShow,
+                         LONG64 *aWinId);
+    HRESULT onBandwidthGroupChange(const ComPtr<IBandwidthGroup> &aBandwidthGroup);
+    HRESULT accessGuestProperty(const com::Utf8Str &aName,
+                                const com::Utf8Str &aValue,
+                                const com::Utf8Str &aFlags,
+                                ULONG aAccessMode,
+                                com::Utf8Str &aRetValue,
+                                LONG64 *aRetTimestamp,
+                                com::Utf8Str &aRetFlags);
+    HRESULT enumerateGuestProperties(const com::Utf8Str &aPatterns,
+                                     std::vector<com::Utf8Str> &aKeys,
+                                     std::vector<com::Utf8Str> &aValues,
+                                     std::vector<LONG64> &aTimestamps,
+                                     std::vector<com::Utf8Str> &aFlags);
+    HRESULT onlineMergeMedium(const ComPtr<IMediumAttachment> &aMediumAttachment,
+                              ULONG aSourceIdx,
+                              ULONG aTargetIdx,
+                              const ComPtr<IProgress> &aProgress);
+    HRESULT reconfigureMediumAttachments(const std::vector<ComPtr<IMediumAttachment> > &aAttachments);
+    HRESULT enableVMMStatistics(BOOL aEnable);
+    HRESULT pauseWithReason(Reason_T aReason);
+    HRESULT resumeWithReason(Reason_T aReason);
+    HRESULT saveStateWithReason(Reason_T aReason,
+                                const ComPtr<IProgress> &aProgress,
+                                const ComPtr<ISnapshot> &aSnapshot,
+                                const Utf8Str &aStateFilePath,
+                                BOOL aPauseVM,
+                                BOOL *aLeftPaused);
+    HRESULT cancelSaveStateWithReason();
+
+
+    HRESULT i_unlockMachine(bool aFinalRelease, bool aFromServer, AutoWriteLock &aLockW);
+
+    SessionState_T mState;
+    SessionType_T mType;
+    Utf8Str mName;
+
+    ComPtr<IInternalMachineControl> mControl;
+
+#ifndef VBOX_COM_INPROC_API_CLIENT
+    ComObjPtr<Console> mConsole;
+#endif
+
+    ComPtr<IMachine> mRemoteMachine;
+    ComPtr<IConsole> mRemoteConsole;
+
+    ComPtr<IVirtualBox> mVirtualBox;
+
+    class ClientTokenHolder;
+
+    ClientTokenHolder *mClientTokenHolder;
+};
+
+#endif /* !MAIN_INCLUDED_SessionImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/SharedFolderImpl.h b/src/VBox/Main/include/SharedFolderImpl.h
new file mode 100644
index 00000000..cdb19fc2
--- /dev/null
+++ b/src/VBox/Main/include/SharedFolderImpl.h
@@ -0,0 +1,125 @@
+/* $Id: SharedFolderImpl.h $ */
+/** @file
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2022 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
+ */
+
+#ifndef MAIN_INCLUDED_SharedFolderImpl_h
+#define MAIN_INCLUDED_SharedFolderImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "SharedFolderWrap.h"
+#include <VBox/shflsvc.h>
+
+class Console;
+
+class ATL_NO_VTABLE SharedFolder :
+    public SharedFolderWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS (SharedFolder)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Machine *aMachine, const com::Utf8Str &aName, const com::Utf8Str &aHostPath,
+                 bool aWritable, bool aAutoMount, const com::Utf8Str &aAutoMountPoint, bool fFailOnError);
+    HRESULT initCopy(Machine *aMachine, SharedFolder *aThat);
+//    HRESULT init(Console *aConsole, const com::Utf8Str &aName, const com::Utf8Str &aHostPath,
+//                 bool aWritable, bool aAutoMount, const com::Utf8Str &aAutoMountPoint, bool fFailOnError);
+//     HRESULT init(VirtualBox *aVirtualBox, const Utf8Str &aName, const Utf8Str &aHostPath,
+//                  bool aWritable, const com::Utf8Str &aAutoMountPoint, bool aAutoMount, bool fFailOnError);
+    void uninit();
+
+    // public methods for internal purposes only
+    // (ensure there is a caller and a read lock before calling them!)
+
+    /**
+     * Public internal method. Returns the shared folder's name. Needs caller! Locking not necessary.
+     * @return
+     */
+    const Utf8Str &i_getName() const;
+
+    /**
+     * Public internal method. Returns the shared folder's host path. Needs caller! Locking not necessary.
+     * @return
+     */
+    const Utf8Str &i_getHostPath() const;
+
+    /**
+     * Public internal method. Returns true if the shared folder is writable. Needs caller and locking!
+     * @return
+     */
+    bool i_isWritable() const;
+
+    /**
+     * Public internal method. Returns true if the shared folder is auto-mounted. Needs caller and locking!
+     * @return
+     */
+    bool i_isAutoMounted() const;
+
+    /**
+     * Public internal method for getting the auto mount point.
+     */
+    const Utf8Str &i_getAutoMountPoint() const;
+
+protected:
+
+    HRESULT i_protectedInit(VirtualBoxBase *aParent,
+                            const Utf8Str &aName,
+                            const Utf8Str &aHostPath,
+                            bool aWritable,
+                            bool aAutoMount,
+                            const com::Utf8Str &aAutoMountPoint,
+                            bool fFailOnError);
+private:
+
+    // wrapped ISharedFolder properies.
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT getHostPath(com::Utf8Str &aHostPath);
+    HRESULT getAccessible(BOOL *aAccessible);
+    HRESULT getWritable(BOOL *aWritable);
+    HRESULT setWritable(BOOL aWritable);
+    HRESULT getAutoMount(BOOL *aAutoMount);
+    HRESULT setAutoMount(BOOL aAutoMount);
+    HRESULT getAutoMountPoint(com::Utf8Str &aAutoMountPoint);
+    HRESULT setAutoMountPoint(com::Utf8Str const &aAutoMountPoint);
+    HRESULT getLastAccessError(com::Utf8Str &aLastAccessError);
+
+    VirtualBoxBase * const mParent;
+
+    /* weak parents (only one of them is not null) */
+    Machine        * const mMachine;
+    VirtualBox     * const mVirtualBox;
+
+    struct Data;            // opaque data struct, defined in MachineSharedFolderImpl.cpp
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_SharedFolderImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/SnapshotImpl.h b/src/VBox/Main/include/SnapshotImpl.h
new file mode 100644
index 00000000..59b8ea7c
--- /dev/null
+++ b/src/VBox/Main/include/SnapshotImpl.h
@@ -0,0 +1,142 @@
+/* $Id: SnapshotImpl.h $ */
+/** @file
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_SnapshotImpl_h
+#define MAIN_INCLUDED_SnapshotImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "SnapshotWrap.h"
+
+class SnapshotMachine;
+
+namespace settings
+{
+    struct Snapshot;
+}
+
+class ATL_NO_VTABLE Snapshot :
+    public SnapshotWrap
+{
+public:
+    DECLARE_COMMON_CLASS_METHODS(Snapshot)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer only for internal purposes
+    HRESULT init(VirtualBox *aVirtualBox,
+                 const Guid &aId,
+                 const com::Utf8Str &aName,
+                 const com::Utf8Str &aDescription,
+                 const RTTIMESPEC &aTimeStamp,
+                 SnapshotMachine *aMachine,
+                 Snapshot *aParent);
+    void uninit();
+
+    void i_beginSnapshotDelete();
+
+    void i_deparent();
+
+    // public methods only for internal purposes
+
+    /**
+     * Override of the default locking class to be used for validating lock
+     * order with the standard member lock handle.
+     */
+    virtual VBoxLockingClass getLockingClass() const
+    {
+        return LOCKCLASS_SNAPSHOTOBJECT;
+    }
+
+    const ComObjPtr<Snapshot>& i_getParent() const;
+    const ComObjPtr<Snapshot> i_getFirstChild() const;
+
+    const Utf8Str& i_getStateFilePath() const;
+
+    uint32_t i_getDepth();
+
+    ULONG i_getChildrenCount();
+    ULONG i_getAllChildrenCount();
+
+    const ComObjPtr<SnapshotMachine>& i_getSnapshotMachine() const;
+
+    Guid i_getId() const;
+    const Utf8Str& i_getName() const;
+    RTTIMESPEC i_getTimeStamp() const;
+
+    ComObjPtr<Snapshot> i_findChildOrSelf(IN_GUID aId);
+    ComObjPtr<Snapshot> i_findChildOrSelf(const com::Utf8Str &aName);
+
+    void i_updateSavedStatePaths(const Utf8Str &strOldPath,
+                                 const Utf8Str &strNewPath);
+    void i_updateSavedStatePathsImpl(const Utf8Str &strOldPath,
+                                     const Utf8Str &strNewPath);
+
+    bool i_sharesSavedStateFile(const Utf8Str &strPath,
+                                Snapshot *pSnapshotToIgnore);
+
+    void i_updateNVRAMPaths(const Utf8Str &strOldPath,
+                            const Utf8Str &strNewPath);
+    void i_updateNVRAMPathsImpl(const Utf8Str &strOldPath,
+                                const Utf8Str &strNewPath);
+
+    HRESULT i_saveSnapshotOne(settings::Snapshot &data) const;
+    HRESULT i_saveSnapshot(settings::Snapshot &data) const;
+
+    HRESULT i_uninitAll(AutoWriteLock &writeLock,
+                        CleanupMode_T cleanupMode,
+                        MediaList &llMedia,
+                        std::list<Utf8Str> &llFilenames);
+
+
+private:
+
+    struct Data;            // opaque, defined in SnapshotImpl.cpp
+
+    // wrapped ISnapshot properties
+    HRESULT getId(com::Guid &aId);
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT setName(const com::Utf8Str &aName);
+    HRESULT getDescription(com::Utf8Str &aDescription);
+    HRESULT setDescription(const com::Utf8Str &aDescription);
+    HRESULT getTimeStamp(LONG64 *aTimeStamp);
+    HRESULT getOnline(BOOL *aOnline);
+    HRESULT getMachine(ComPtr<IMachine> &aMachine);
+    HRESULT getParent(ComPtr<ISnapshot> &aParent);
+    HRESULT getChildren(std::vector<ComPtr<ISnapshot> > &aChildren);
+
+    // wrapped ISnapshot methods
+    HRESULT getChildrenCount(ULONG *aChildrenCount);
+
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_SnapshotImpl_h */
+
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/StorageControllerImpl.h b/src/VBox/Main/include/StorageControllerImpl.h
new file mode 100644
index 00000000..d069aea6
--- /dev/null
+++ b/src/VBox/Main/include/StorageControllerImpl.h
@@ -0,0 +1,107 @@
+/* $Id: StorageControllerImpl.h $ */
+
+/** @file
+ *
+ * VBox StorageController COM Class declaration.
+ */
+
+/*
+ * Copyright (C) 2008-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
+ */
+
+#ifndef MAIN_INCLUDED_StorageControllerImpl_h
+#define MAIN_INCLUDED_StorageControllerImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+#include "StorageControllerWrap.h"
+
+class ATL_NO_VTABLE StorageController :
+    public StorageControllerWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(StorageController)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Machine *aParent,
+                 const com::Utf8Str &aName,
+                 StorageBus_T aBus,
+                 ULONG aInstance,
+                 bool fBootable);
+    HRESULT init(Machine *aParent,
+                 StorageController *aThat,
+                 bool aReshare = false);
+    HRESULT initCopy(Machine *aParent,
+                     StorageController *aThat);
+    void uninit();
+
+    // public methods only for internal purposes
+    const Utf8Str &i_getName() const;
+    StorageControllerType_T i_getControllerType() const;
+    StorageBus_T i_getStorageBus() const;
+    ULONG i_getInstance() const;
+    bool i_getBootable() const;
+    HRESULT i_checkPortAndDeviceValid(LONG aControllerPort,
+                                      LONG aDevice);
+    void i_setBootable(BOOL fBootable);
+    void i_rollback();
+    void i_commit();
+
+    // public methods for internal purposes only
+    // (ensure there is a caller and a read lock before calling them!)
+
+    void i_unshare();
+
+    /** @note this doesn't require a read lock since mParent is constant. */
+    Machine* i_getMachine();
+    ComObjPtr<StorageController> i_getPeer();
+
+private:
+
+    // Wrapped IStorageController properties
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT setName(const com::Utf8Str &aName);
+    HRESULT getMaxDevicesPerPortCount(ULONG *aMaxDevicesPerPortCount);
+    HRESULT getMinPortCount(ULONG *aMinPortCount);
+    HRESULT getMaxPortCount(ULONG *aMaxPortCount);
+    HRESULT getInstance(ULONG *aInstance);
+    HRESULT setInstance(ULONG aInstance);
+    HRESULT getPortCount(ULONG *aPortCount);
+    HRESULT setPortCount(ULONG aPortCount);
+    HRESULT getBus(StorageBus_T *aBus);
+    HRESULT getControllerType(StorageControllerType_T *aControllerType);
+    HRESULT setControllerType(StorageControllerType_T aControllerType);
+    HRESULT getUseHostIOCache(BOOL *aUseHostIOCache);
+    HRESULT setUseHostIOCache(BOOL aUseHostIOCache);
+    HRESULT getBootable(BOOL *aBootable);
+
+    void i_printList();
+
+    struct Data;
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_StorageControllerImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/SystemPropertiesImpl.h b/src/VBox/Main/include/SystemPropertiesImpl.h
new file mode 100644
index 00000000..0216d06f
--- /dev/null
+++ b/src/VBox/Main/include/SystemPropertiesImpl.h
@@ -0,0 +1,220 @@
+/* $Id: SystemPropertiesImpl.h $ */
+
+/** @file
+ *
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_SystemPropertiesImpl_h
+#define MAIN_INCLUDED_SystemPropertiesImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "MediumFormatImpl.h"
+#include "SystemPropertiesWrap.h"
+
+class CPUProfile;
+
+namespace settings
+{
+    struct SystemProperties;
+}
+
+class ATL_NO_VTABLE SystemProperties :
+    public SystemPropertiesWrap
+{
+public:
+    typedef std::list<ComObjPtr<MediumFormat> > MediumFormatList;
+    typedef std::list<ComObjPtr<CPUProfile> > CPUProfileList_T;
+
+    DECLARE_COMMON_CLASS_METHODS(SystemProperties)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(VirtualBox *aParent);
+    void uninit();
+
+    // public methods for internal purposes only
+    // (ensure there is a caller and a read lock before calling them!)
+    HRESULT i_loadSettings(const settings::SystemProperties &data);
+    HRESULT i_saveSettings(settings::SystemProperties &data);
+
+    ComObjPtr<MediumFormat> i_mediumFormat(const Utf8Str &aFormat);
+    ComObjPtr<MediumFormat> i_mediumFormatFromExtension(const Utf8Str &aExt);
+
+    int i_loadVDPlugin(const char *pszPluginLibrary);
+    int i_unloadVDPlugin(const char *pszPluginLibrary);
+
+    HRESULT i_getDefaultAdditionsISO(com::Utf8Str &aDefaultAdditionsISO);
+
+private:
+
+    // wrapped ISystemProperties properties
+    HRESULT getMinGuestRAM(ULONG *aMinGuestRAM) RT_OVERRIDE;
+    HRESULT getMaxGuestRAM(ULONG *aMaxGuestRAM) RT_OVERRIDE;
+    HRESULT getMinGuestVRAM(ULONG *aMinGuestVRAM) RT_OVERRIDE;
+    HRESULT getMaxGuestVRAM(ULONG *aMaxGuestVRAM) RT_OVERRIDE;
+    HRESULT getMinGuestCPUCount(ULONG *aMinGuestCPUCount) RT_OVERRIDE;
+    HRESULT getMaxGuestCPUCount(ULONG *aMaxGuestCPUCount) RT_OVERRIDE;
+    HRESULT getMaxGuestMonitors(ULONG *aMaxGuestMonitors) RT_OVERRIDE;
+    HRESULT getInfoVDSize(LONG64 *aInfoVDSize) RT_OVERRIDE;
+    HRESULT getSerialPortCount(ULONG *aSerialPortCount) RT_OVERRIDE;
+    HRESULT getParallelPortCount(ULONG *aParallelPortCount) RT_OVERRIDE;
+    HRESULT getMaxBootPosition(ULONG *aMaxBootPosition) RT_OVERRIDE;
+    HRESULT getRawModeSupported(BOOL *aRawModeSupported) RT_OVERRIDE;
+    HRESULT getExclusiveHwVirt(BOOL *aExclusiveHwVirt) RT_OVERRIDE;
+    HRESULT setExclusiveHwVirt(BOOL aExclusiveHwVirt) RT_OVERRIDE;
+    HRESULT getDefaultMachineFolder(com::Utf8Str &aDefaultMachineFolder) RT_OVERRIDE;
+    HRESULT setDefaultMachineFolder(const com::Utf8Str &aDefaultMachineFolder) RT_OVERRIDE;
+    HRESULT getLoggingLevel(com::Utf8Str &aLoggingLevel) RT_OVERRIDE;
+    HRESULT setLoggingLevel(const com::Utf8Str &aLoggingLevel) RT_OVERRIDE;
+    HRESULT getMediumFormats(std::vector<ComPtr<IMediumFormat> > &aMediumFormats) RT_OVERRIDE;
+    HRESULT getDefaultHardDiskFormat(com::Utf8Str &aDefaultHardDiskFormat) RT_OVERRIDE;
+    HRESULT setDefaultHardDiskFormat(const com::Utf8Str &aDefaultHardDiskFormat) RT_OVERRIDE;
+    HRESULT getFreeDiskSpaceWarning(LONG64 *aFreeDiskSpaceWarning) RT_OVERRIDE;
+    HRESULT setFreeDiskSpaceWarning(LONG64 aFreeDiskSpaceWarning) RT_OVERRIDE;
+    HRESULT getFreeDiskSpacePercentWarning(ULONG *aFreeDiskSpacePercentWarning) RT_OVERRIDE;
+    HRESULT setFreeDiskSpacePercentWarning(ULONG aFreeDiskSpacePercentWarning) RT_OVERRIDE;
+    HRESULT getFreeDiskSpaceError(LONG64 *aFreeDiskSpaceError) RT_OVERRIDE;
+    HRESULT setFreeDiskSpaceError(LONG64 aFreeDiskSpaceError) RT_OVERRIDE;
+    HRESULT getFreeDiskSpacePercentError(ULONG *aFreeDiskSpacePercentError) RT_OVERRIDE;
+    HRESULT setFreeDiskSpacePercentError(ULONG aFreeDiskSpacePercentError) RT_OVERRIDE;
+    HRESULT getVRDEAuthLibrary(com::Utf8Str &aVRDEAuthLibrary) RT_OVERRIDE;
+    HRESULT setVRDEAuthLibrary(const com::Utf8Str &aVRDEAuthLibrary) RT_OVERRIDE;
+    HRESULT getWebServiceAuthLibrary(com::Utf8Str &aWebServiceAuthLibrary) RT_OVERRIDE;
+    HRESULT setWebServiceAuthLibrary(const com::Utf8Str &aWebServiceAuthLibrary) RT_OVERRIDE;
+    HRESULT getDefaultVRDEExtPack(com::Utf8Str &aDefaultVRDEExtPack) RT_OVERRIDE;
+    HRESULT setDefaultVRDEExtPack(const com::Utf8Str &aDefaultVRDEExtPack) RT_OVERRIDE;
+    HRESULT getDefaultCryptoExtPack(com::Utf8Str &aDefaultCryptoExtPack) RT_OVERRIDE;
+    HRESULT setDefaultCryptoExtPack(const com::Utf8Str &aDefaultCryptoExtPack) RT_OVERRIDE;
+    HRESULT getLogHistoryCount(ULONG *aLogHistoryCount) RT_OVERRIDE;
+    HRESULT setLogHistoryCount(ULONG aLogHistoryCount) RT_OVERRIDE;
+    HRESULT getDefaultAudioDriver(AudioDriverType_T *aDefaultAudioDriver) RT_OVERRIDE;
+    HRESULT getAutostartDatabasePath(com::Utf8Str &aAutostartDatabasePath) RT_OVERRIDE;
+    HRESULT setAutostartDatabasePath(const com::Utf8Str &aAutostartDatabasePath) RT_OVERRIDE;
+    HRESULT getDefaultAdditionsISO(com::Utf8Str &aDefaultAdditionsISO) RT_OVERRIDE;
+    HRESULT setDefaultAdditionsISO(const com::Utf8Str &aDefaultAdditionsISO) RT_OVERRIDE;
+    HRESULT getDefaultFrontend(com::Utf8Str &aDefaultFrontend) RT_OVERRIDE;
+    HRESULT setDefaultFrontend(const com::Utf8Str &aDefaultFrontend) RT_OVERRIDE;
+    HRESULT getScreenShotFormats(std::vector<BitmapFormat_T> &aScreenShotFormats) RT_OVERRIDE;
+    HRESULT getProxyMode(ProxyMode_T *pProxyMode) RT_OVERRIDE;
+    HRESULT setProxyMode(ProxyMode_T aProxyMode) RT_OVERRIDE;
+    HRESULT getProxyURL(com::Utf8Str &aProxyURL) RT_OVERRIDE;
+    HRESULT setProxyURL(const com::Utf8Str &aProxyURL) RT_OVERRIDE;
+    HRESULT getSupportedParavirtProviders(std::vector<ParavirtProvider_T> &aSupportedParavirtProviders) RT_OVERRIDE;
+    HRESULT getSupportedClipboardModes(std::vector<ClipboardMode_T> &aSupportedClipboardModes) RT_OVERRIDE;
+    HRESULT getSupportedDnDModes(std::vector<DnDMode_T> &aSupportedDnDModes) RT_OVERRIDE;
+    HRESULT getSupportedFirmwareTypes(std::vector<FirmwareType_T> &aSupportedFirmwareTypes) RT_OVERRIDE;
+    HRESULT getSupportedPointingHIDTypes(std::vector<PointingHIDType_T> &aSupportedPointingHIDTypes) RT_OVERRIDE;
+    HRESULT getSupportedKeyboardHIDTypes(std::vector<KeyboardHIDType_T> &aSupportedKeyboardHIDTypes) RT_OVERRIDE;
+    HRESULT getSupportedVFSTypes(std::vector<VFSType_T> &aSupportedVFSTypes) RT_OVERRIDE;
+    HRESULT getSupportedImportOptions(std::vector<ImportOptions_T> &aSupportedImportOptions) RT_OVERRIDE;
+    HRESULT getSupportedExportOptions(std::vector<ExportOptions_T> &aSupportedExportOptions) RT_OVERRIDE;
+    HRESULT getSupportedRecordingFeatures(std::vector<RecordingFeature_T> &aSupportedRecordingFeatures) RT_OVERRIDE;
+    HRESULT getSupportedRecordingAudioCodecs(std::vector<RecordingAudioCodec_T> &aSupportedRecordingAudioCodecs) RT_OVERRIDE;
+    HRESULT getSupportedRecordingVideoCodecs(std::vector<RecordingVideoCodec_T> &aSupportedRecordingVideoCodecs) RT_OVERRIDE;
+    HRESULT getSupportedRecordingVSModes(std::vector<RecordingVideoScalingMode_T> &aSupportedRecordingVideoScalingModes) RT_OVERRIDE;
+    HRESULT getSupportedRecordingARCModes(std::vector<RecordingRateControlMode_T> &aSupportedRecordingAudioRateControlModes) RT_OVERRIDE;
+    HRESULT getSupportedRecordingVRCModes(std::vector<RecordingRateControlMode_T> &aSupportedRecordingVideoRateControlModes) RT_OVERRIDE;
+    HRESULT getSupportedGraphicsControllerTypes(std::vector<GraphicsControllerType_T> &aSupportedGraphicsControllerTypes) RT_OVERRIDE;
+    HRESULT getSupportedCloneOptions(std::vector<CloneOptions_T> &aSupportedCloneOptions) RT_OVERRIDE;
+    HRESULT getSupportedAutostopTypes(std::vector<AutostopType_T> &aSupportedAutostopTypes) RT_OVERRIDE;
+    HRESULT getSupportedVMProcPriorities(std::vector<VMProcPriority_T> &aSupportedVMProcPriorities) RT_OVERRIDE;
+    HRESULT getSupportedNetworkAttachmentTypes(std::vector<NetworkAttachmentType_T> &aSupportedNetworkAttachmentTypes) RT_OVERRIDE;
+    HRESULT getSupportedNetworkAdapterTypes(std::vector<NetworkAdapterType_T> &aSupportedNetworkAdapterTypes) RT_OVERRIDE;
+    HRESULT getSupportedPortModes(std::vector<PortMode_T> &aSupportedPortModes) RT_OVERRIDE;
+    HRESULT getSupportedUartTypes(std::vector<UartType_T> &aSupportedUartTypes) RT_OVERRIDE;
+    HRESULT getSupportedUSBControllerTypes(std::vector<USBControllerType_T> &aSupportedUSBControllerTypes) RT_OVERRIDE;
+    HRESULT getSupportedAudioDriverTypes(std::vector<AudioDriverType_T> &aSupportedAudioDriverTypes) RT_OVERRIDE;
+    HRESULT getSupportedAudioControllerTypes(std::vector<AudioControllerType_T> &aSupportedAudioControllerTypes) RT_OVERRIDE;
+    HRESULT getSupportedStorageBuses(std::vector<StorageBus_T> &aSupportedStorageBuses) RT_OVERRIDE;
+    HRESULT getSupportedStorageControllerTypes(std::vector<StorageControllerType_T> &aSupportedStorageControllerTypes) RT_OVERRIDE;
+    HRESULT getSupportedChipsetTypes(std::vector<ChipsetType_T> &aSupportedChipsetTypes) RT_OVERRIDE;
+    HRESULT getSupportedIommuTypes(std::vector<IommuType_T> &aSupportedIommuTypes) RT_OVERRIDE;
+    HRESULT getSupportedTpmTypes(std::vector<TpmType_T> &aSupportedTpmTypes) RT_OVERRIDE;
+    HRESULT getLanguageId(com::Utf8Str &aLanguageId) RT_OVERRIDE;
+    HRESULT setLanguageId(const com::Utf8Str &aLanguageId) RT_OVERRIDE;
+
+    // wrapped ISystemProperties methods
+    HRESULT getMaxNetworkAdapters(ChipsetType_T aChipset,
+                                  ULONG *aMaxNetworkAdapters) RT_OVERRIDE;
+    HRESULT getMaxNetworkAdaptersOfType(ChipsetType_T aChipset,
+                                        NetworkAttachmentType_T aType,
+                                        ULONG *aMaxNetworkAdapters) RT_OVERRIDE;
+    HRESULT getMaxDevicesPerPortForStorageBus(StorageBus_T aBus,
+                                              ULONG *aMaxDevicesPerPort) RT_OVERRIDE;
+    HRESULT getMinPortCountForStorageBus(StorageBus_T aBus,
+                                         ULONG *aMinPortCount) RT_OVERRIDE;
+    HRESULT getMaxPortCountForStorageBus(StorageBus_T aBus,
+                                         ULONG *aMaxPortCount) RT_OVERRIDE;
+    HRESULT getMaxInstancesOfStorageBus(ChipsetType_T aChipset,
+                                        StorageBus_T aBus,
+                                        ULONG *aMaxInstances) RT_OVERRIDE;
+    HRESULT getDeviceTypesForStorageBus(StorageBus_T aBus,
+                                        std::vector<DeviceType_T> &aDeviceTypes) RT_OVERRIDE;
+    HRESULT getStorageBusForStorageControllerType(StorageControllerType_T aStorageControllerType,
+                                                  StorageBus_T *aStorageBus) RT_OVERRIDE;
+    HRESULT getStorageControllerTypesForStorageBus(StorageBus_T aStorageBus,
+                                                   std::vector<StorageControllerType_T> &aStorageControllerTypes) RT_OVERRIDE;
+    HRESULT getDefaultIoCacheSettingForStorageController(StorageControllerType_T aControllerType,
+                                                         BOOL *aEnabled) RT_OVERRIDE;
+    HRESULT getStorageControllerHotplugCapable(StorageControllerType_T aControllerType,
+                                               BOOL *aHotplugCapable) RT_OVERRIDE;
+    HRESULT getMaxInstancesOfUSBControllerType(ChipsetType_T aChipset,
+                                               USBControllerType_T aType,
+                                               ULONG *aMaxInstances) RT_OVERRIDE;
+    HRESULT getCPUProfiles(CPUArchitecture_T aArchitecture, const com::Utf8Str &aNamePattern,
+                           std::vector<ComPtr<ICPUProfile> > &aProfiles) RT_OVERRIDE;
+
+    HRESULT i_getUserHomeDirectory(Utf8Str &strPath);
+    HRESULT i_setDefaultMachineFolder(const Utf8Str &strPath);
+    HRESULT i_setLoggingLevel(const com::Utf8Str &aLoggingLevel);
+    HRESULT i_setDefaultHardDiskFormat(const com::Utf8Str &aFormat);
+    HRESULT i_setVRDEAuthLibrary(const com::Utf8Str &aPath);
+
+    HRESULT i_setWebServiceAuthLibrary(const com::Utf8Str &aPath);
+    HRESULT i_setDefaultVRDEExtPack(const com::Utf8Str &aExtPack);
+    HRESULT i_setDefaultCryptoExtPack(const com::Utf8Str &aExtPack);
+    HRESULT i_setAutostartDatabasePath(const com::Utf8Str &aPath);
+    HRESULT i_setDefaultAdditionsISO(const com::Utf8Str &aPath);
+    HRESULT i_setDefaultFrontend(const com::Utf8Str &aDefaultFrontend);
+
+    VirtualBox * const  mParent;
+
+    settings::SystemProperties *m;
+
+    MediumFormatList m_llMediumFormats;
+
+    bool                m_fLoadedX86CPUProfiles;    /**< Set if we've loaded the x86 and AMD64 CPU profiles. */
+    CPUProfileList_T    m_llCPUProfiles;            /**< List of loaded CPU profiles. */
+
+    friend class VirtualBox;
+};
+
+#endif /* !MAIN_INCLUDED_SystemPropertiesImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/TextScript.h b/src/VBox/Main/include/TextScript.h
new file mode 100644
index 00000000..39fe92d6
--- /dev/null
+++ b/src/VBox/Main/include/TextScript.h
@@ -0,0 +1,251 @@
+/* $Id: TextScript.h $ */
+/** @file
+ * Classes for reading/parsing/saving text scripts (unattended installation, ++).
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_TextScript_h
+#define MAIN_INCLUDED_TextScript_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "VirtualBoxBase.h"
+#include <iprt/cpp/utils.h>
+#include <vector>
+
+
+/**
+ * Base class for all the script readers/editors.
+ *
+ * @todo get rid of this silly bugger.
+ */
+class AbstractScript
+    : public RTCNonCopyable
+{
+protected:
+    /** For setting errors.
+     * Yeah, class isn't entirely abstract now.  */
+    VirtualBoxBase *mpSetError;
+
+private: /* no default constructors for children. */
+    AbstractScript() {}
+
+public:
+    DECLARE_TRANSLATE_METHODS(AbstractScript)
+
+    AbstractScript(VirtualBoxBase *pSetError) : mpSetError(pSetError) {}
+    virtual ~AbstractScript() {}
+
+    /**
+     * Read a script from a file
+     */
+    virtual HRESULT read(const Utf8Str &rStrFilename) = 0;
+
+    /**
+     * Read a script from a VFS file handle.
+     */
+    virtual HRESULT readFromHandle(RTVFSFILE hVfsFile, const char *pszFilename) = 0;
+
+    /**
+     * Parse the script
+     */
+    virtual HRESULT parse() = 0;
+
+    /**
+     * Save a script to a string.
+     *
+     * This is used by save() and later others to deloy the script.
+     */
+    virtual HRESULT saveToString(Utf8Str &rStrDst) = 0;
+
+    /**
+     * Save a script to a file.
+     * @param   rStrPath        Where to save the script.  This normally points to a
+     *                          file, but in a number of child use cases it's
+     *                          actually giving a directory to put the script in
+     *                          using the default deloyment filename.  One day we
+     *                          might make the caller do this path joining.
+     * @param   fOverwrite      Whether to overwrite the file or not.
+     */
+    virtual HRESULT save(const Utf8Str &rStrPath, bool fOverwrite) = 0;
+
+    /**
+     * Path where an actual script with user's data is located
+     */
+    virtual const Utf8Str &getActualScriptPath() const = 0;
+};
+
+/**
+ * Base class for text based script readers/editors.
+ *
+ * This deals with reading the file into a string data member, writing it back
+ * out to a file, and remember the filenames.
+ */
+class BaseTextScript : public AbstractScript
+{
+protected:
+    const char * const mpszDefaultTemplateFilename; /**< The default template filename.  Can be empty. */
+    const char * const mpszDefaultFilename;         /**< Filename to use when someone calls save() with a directory path.  Can be NULL. */
+    RTCString   mStrScriptFullContent;  /**< Raw text file content.  Produced by read() and typically only used by parse(). */
+    Utf8Str     mStrOriginalPath;       /**< Path where an original script is located (set by read()). */
+    Utf8Str     mStrSavedPath;          /**< Path where an saved script with user's data is located (set by save()). */
+
+public:
+    DECLARE_TRANSLATE_METHODS(BaseTextScript)
+
+    BaseTextScript(VirtualBoxBase *pSetError, const char *pszDefaultTemplateFilename, const char *pszDefaultFilename)
+        : AbstractScript(pSetError)
+        , mpszDefaultTemplateFilename(pszDefaultTemplateFilename)
+        , mpszDefaultFilename(pszDefaultFilename)
+    { }
+    virtual ~BaseTextScript() {}
+
+    HRESULT read(const Utf8Str &rStrFilename);
+    HRESULT readFromHandle(RTVFSFILE hVfsFile, const char *pszFilename);
+    HRESULT save(const Utf8Str &rStrFilename, bool fOverwrite);
+
+    /**
+     * Gets the default filename for this class of scripts (empty if none).
+     *
+     * @note Just the filename, no path.
+     */
+    const char *getDefaultFilename() const
+    {
+        return mpszDefaultFilename;
+    }
+
+    /**
+     * Gets the default template filename for this class of scripts (empty if none).
+     *
+     * @note Just the filename, no path.
+     */
+    const char *getDefaultTemplateFilename() const
+    {
+        return mpszDefaultTemplateFilename;
+    }
+
+    /**
+     * Path to the file we last saved the script as.
+     */
+    const Utf8Str &getActualScriptPath() const
+    {
+        return mStrSavedPath;
+    }
+
+    /**
+     * Path where an original script is located
+     */
+    const Utf8Str &getOriginalScriptPath() const
+    {
+        return mStrOriginalPath;
+    }
+};
+
+
+/**
+ * Generic line based text script editor.
+ *
+ * This is used for editing isolinux configuratin files among other things.
+ */
+class GeneralTextScript : public BaseTextScript
+{
+protected:
+    RTCList<RTCString>  mScriptContentByLines; /**< Content index by line. This contains the edited version. */
+    bool                mfDataParsed;          /**< Indicates whether the script has been parse() yet.  */
+
+public:
+    DECLARE_TRANSLATE_METHODS(GeneralTextScript)
+
+    GeneralTextScript(VirtualBoxBase *pSetError, const char *pszDefaultTemplateFilename = NULL, const char *pszDefaultFilename = NULL)
+        : BaseTextScript(pSetError, pszDefaultTemplateFilename, pszDefaultFilename), mfDataParsed(false)
+    {}
+    virtual ~GeneralTextScript() {}
+
+    HRESULT parse();
+    HRESULT saveToString(Utf8Str &rStrDst);
+
+    //////////////////New functions//////////////////////////////
+
+    bool isDataParsed() const
+    {
+        return mfDataParsed;
+    }
+
+    /**
+     * Returns the actual size of script in lines
+     */
+    size_t getLineNumbersOfScript() const
+    {
+        return mScriptContentByLines.size();
+    }
+
+    /**
+     * Gets a read-only reference to the given line, returning Utf8Str::Empty if
+     * idxLine is out of range.
+     *
+     * @returns Line string reference or Utf8Str::Empty.
+     * @param   idxLine     The line number.
+     *
+     * @todo    RTCList doesn't allow this method to be const.
+     */
+    RTCString const &getContentOfLine(size_t idxLine);
+
+    /**
+     * Set new content of line
+     */
+    HRESULT setContentOfLine(size_t idxLine, const Utf8Str &newContent);
+
+    /**
+     * Find a substring in the script
+     * Returns a list with the found lines
+     * @throws std::bad_alloc
+     */
+    std::vector<size_t> findTemplate(const Utf8Str &rStrNeedle, RTCString::CaseSensitivity enmCase = RTCString::CaseSensitive);
+
+    /**
+     * In line @a idxLine replace the first occurence of @a rStrNeedle with
+     * @a rStrRelacement.
+     */
+    HRESULT findAndReplace(size_t idxLine, const Utf8Str &rStrNeedle, const Utf8Str &rStrReplacement);
+
+    /**
+     * Append a string into the end of the given line.
+     */
+    HRESULT appendToLine(size_t idxLine, const Utf8Str &rStrToAppend);
+
+    /**
+     * Prepend a string in the beginning of the given line.
+     */
+    HRESULT prependToLine(size_t idxLine, const Utf8Str &rStrToPrepend);
+
+    /**
+     * Append a new line at the end of the list of line.
+     */
+    HRESULT appendLine(const Utf8Str &rStrLineToAppend);
+    //////////////////New functions//////////////////////////////
+};
+
+
+#endif /* !MAIN_INCLUDED_TextScript_h */
diff --git a/src/VBox/Main/include/ThreadTask.h b/src/VBox/Main/include/ThreadTask.h
new file mode 100644
index 00000000..3fbcdd10
--- /dev/null
+++ b/src/VBox/Main/include/ThreadTask.h
@@ -0,0 +1,78 @@
+/** @file
+ * VirtualBox ThreadTask class definition
+ */
+
+/*
+ * Copyright (C) 2015-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
+ */
+
+#ifndef MAIN_INCLUDED_ThreadTask_h
+#define MAIN_INCLUDED_ThreadTask_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "VBox/com/string.h"
+
+/**
+ * The class ThreadVoidData is used as a base class for any data which we want to pass into a thread
+ */
+struct ThreadVoidData
+{
+public:
+    ThreadVoidData() { }
+    virtual ~ThreadVoidData() { }
+};
+
+
+class ThreadTask
+{
+public:
+    ThreadTask(const Utf8Str &t)
+        : m_strTaskName(t)
+        , mAsync(false)
+    { }
+
+    virtual ~ThreadTask()
+    { }
+
+    HRESULT createThread(void);
+    HRESULT createThreadWithType(RTTHREADTYPE enmType);
+
+    inline Utf8Str getTaskName() const { return m_strTaskName; }
+    bool isAsync() { return mAsync; }
+
+protected:
+    HRESULT createThreadInternal(RTTHREADTYPE enmType);
+    static DECLCALLBACK(int) taskHandlerThreadProc(RTTHREAD thread, void *pvUser);
+
+    ThreadTask() : m_strTaskName("GenericTask")
+    { }
+
+    Utf8Str m_strTaskName;
+    bool mAsync;
+
+private:
+    virtual void handler() = 0;
+};
+
+#endif /* !MAIN_INCLUDED_ThreadTask_h */
+
diff --git a/src/VBox/Main/include/TokenImpl.h b/src/VBox/Main/include/TokenImpl.h
new file mode 100644
index 00000000..d08491cf
--- /dev/null
+++ b/src/VBox/Main/include/TokenImpl.h
@@ -0,0 +1,118 @@
+/* $Id: TokenImpl.h $ */
+/** @file
+ * Token COM class implementations - MachineToken and MediumLockToken
+ */
+
+/*
+ * Copyright (C) 2013-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
+ */
+
+#ifndef MAIN_INCLUDED_TokenImpl_h
+#define MAIN_INCLUDED_TokenImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "TokenWrap.h"
+#include "MachineImpl.h"
+
+
+/**
+ * The MachineToken class automates cleanup of a SessionMachine object.
+ */
+class ATL_NO_VTABLE MachineToken :
+    public TokenWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(MachineToken)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(const ComObjPtr<SessionMachine> &pSessionMachine);
+    void uninit(bool fAbandon);
+
+private:
+
+    // wrapped IToken methods
+    HRESULT abandon(AutoCaller &aAutoCaller);
+    HRESULT dummy();
+
+    // data
+    struct Data
+    {
+        Data()
+        {
+        }
+
+        ComObjPtr<SessionMachine> pSessionMachine;
+    };
+
+    Data m;
+};
+
+
+class Medium;
+
+/**
+ * The MediumLockToken class automates cleanup of a Medium lock.
+ */
+class ATL_NO_VTABLE MediumLockToken :
+    public TokenWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(MediumLockToken)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(const ComObjPtr<Medium> &pMedium, bool fWrite);
+    void uninit();
+
+private:
+
+    // wrapped IToken methods
+    HRESULT abandon(AutoCaller &aAutoCaller);
+    HRESULT dummy();
+
+    // data
+    struct Data
+    {
+        Data() :
+            fWrite(false)
+        {
+        }
+
+        ComObjPtr<Medium> pMedium;
+        bool fWrite;
+    };
+
+    Data m;
+};
+
+
+#endif /* !MAIN_INCLUDED_TokenImpl_h */
+
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/TrustAnchorsAndCerts.h b/src/VBox/Main/include/TrustAnchorsAndCerts.h
new file mode 100644
index 00000000..b828c179
--- /dev/null
+++ b/src/VBox/Main/include/TrustAnchorsAndCerts.h
@@ -0,0 +1,53 @@
+/* $Id: TrustAnchorsAndCerts.h $ */
+/** @file
+ * Main - Collection of trust anchors and certificates included in VBoxSVC.
+ */
+
+/*
+ * Copyright (C) 2021-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
+ */
+
+#ifndef MAIN_INCLUDED_TrustAnchorsAndCerts_h
+#define MAIN_INCLUDED_TrustAnchorsAndCerts_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/cdefs.h>
+
+RT_C_DECLS_BEGIN
+
+extern const unsigned char g_abUefiMicrosoftKek[];
+extern const unsigned g_cbUefiMicrosoftKek;
+
+extern const unsigned char g_abUefiMicrosoftCa[];
+extern const unsigned g_cbUefiMicrosoftCa;
+
+extern const unsigned char g_abUefiMicrosoftProPca[];
+extern const unsigned g_cbUefiMicrosoftProPca;
+
+extern const unsigned char g_abUefiOracleDefPk[];
+extern const unsigned g_cbUefiOracleDefPk;
+
+RT_C_DECLS_END
+
+#endif /* !MAIN_INCLUDED_TrustAnchorsAndCerts_h */
+
diff --git a/src/VBox/Main/include/TrustedPlatformModuleImpl.h b/src/VBox/Main/include/TrustedPlatformModuleImpl.h
new file mode 100644
index 00000000..dbe8b9a3
--- /dev/null
+++ b/src/VBox/Main/include/TrustedPlatformModuleImpl.h
@@ -0,0 +1,84 @@
+/* $Id: TrustedPlatformModuleImpl.h $ */
+
+/** @file
+ *
+ * VirtualBox COM class implementation - Machine Trusted Platform Module settings.
+ */
+
+/*
+ * Copyright (C) 2021-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
+ */
+
+#ifndef MAIN_INCLUDED_TrustedPlatformModuleImpl_h
+#define MAIN_INCLUDED_TrustedPlatformModuleImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "TrustedPlatformModuleWrap.h"
+
+class GuestOSType;
+
+namespace settings
+{
+    struct TpmSettings;
+}
+
+class ATL_NO_VTABLE TrustedPlatformModule :
+    public TrustedPlatformModuleWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(TrustedPlatformModule)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Machine *parent);
+    HRESULT init(Machine *parent, TrustedPlatformModule *that);
+    HRESULT initCopy(Machine *parent, TrustedPlatformModule *that);
+    void uninit();
+
+    // public methods for internal purposes only
+    HRESULT i_loadSettings(const settings::TpmSettings &data);
+    HRESULT i_saveSettings(settings::TpmSettings &data);
+
+    void i_rollback();
+    void i_commit();
+    void i_copyFrom(TrustedPlatformModule *aThat);
+    void i_applyDefaults(GuestOSType *aOsType);
+
+private:
+
+    // wrapped ITrustedPlatformModule properties
+    HRESULT getType(TpmType_T *aType);
+    HRESULT setType(TpmType_T aType);
+    HRESULT getLocation(com::Utf8Str &location);
+    HRESULT setLocation(const com::Utf8Str &location);
+
+    struct Data;
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_TrustedPlatformModuleImpl_h */
+
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/USBControllerImpl.h b/src/VBox/Main/include/USBControllerImpl.h
new file mode 100644
index 00000000..85ad14b6
--- /dev/null
+++ b/src/VBox/Main/include/USBControllerImpl.h
@@ -0,0 +1,88 @@
+/* $Id: USBControllerImpl.h $ */
+
+/** @file
+ *
+ * VBox USBController COM Class declaration.
+ */
+
+/*
+ * Copyright (C) 2005-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
+ */
+
+#ifndef MAIN_INCLUDED_USBControllerImpl_h
+#define MAIN_INCLUDED_USBControllerImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "USBControllerWrap.h"
+
+class HostUSBDevice;
+class USBDeviceFilter;
+
+namespace settings
+{
+    struct USBController;
+}
+
+class ATL_NO_VTABLE USBController :
+    public USBControllerWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(USBController)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Machine *aParent, const com::Utf8Str &aName, USBControllerType_T enmType);
+    HRESULT init(Machine *aParent, USBController *aThat, bool fReshare = false);
+    HRESULT initCopy(Machine *aParent, USBController *aThat);
+    void uninit();
+
+    // public methods only for internal purposes
+    void i_rollback();
+    void i_commit();
+    void i_copyFrom(USBController *aThat);
+    void i_unshare();
+
+    ComObjPtr<USBController> i_getPeer();
+    const Utf8Str &i_getName() const;
+    const USBControllerType_T &i_getControllerType() const;
+
+private:
+
+    // wrapped IUSBController properties
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT setName(const com::Utf8Str &aName);
+    HRESULT getType(USBControllerType_T *aType);
+    HRESULT setType(USBControllerType_T aType);
+    HRESULT getUSBStandard(USHORT *aUSBStandard);
+
+    void printList();
+
+    struct Data;
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_USBControllerImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/USBDeviceFilterImpl.h b/src/VBox/Main/include/USBDeviceFilterImpl.h
new file mode 100644
index 00000000..7514b480
--- /dev/null
+++ b/src/VBox/Main/include/USBDeviceFilterImpl.h
@@ -0,0 +1,240 @@
+/* $Id: USBDeviceFilterImpl.h $ */
+/** @file
+ * Declaration of USBDeviceFilter and HostUSBDeviceFilter.
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_USBDeviceFilterImpl_h
+#define MAIN_INCLUDED_USBDeviceFilterImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/settings.h>
+#include "Matching.h"
+#include <VBox/usbfilter.h>
+#include "USBDeviceFilterWrap.h"
+
+class USBDeviceFilters;
+class Host;
+namespace settings
+{
+    struct USBDeviceFilter;
+}
+
+// USBDeviceFilter
+////////////////////////////////////////////////////////////////////////////////
+
+class ATL_NO_VTABLE USBDeviceFilter :
+    public USBDeviceFilterWrap
+{
+public:
+
+    struct BackupableUSBDeviceFilterData
+    {
+        typedef matching::Matchable <matching::ParsedBoolFilter> BOOLFilter;
+
+        BackupableUSBDeviceFilterData() : mId (NULL) {}
+        BackupableUSBDeviceFilterData(const BackupableUSBDeviceFilterData &aThat) :
+            mRemote(aThat.mRemote),  mId(aThat.mId)
+        {
+            mData.strName = aThat.mData.strName;
+            mData.fActive = aThat.mData.fActive;
+            mData.ulMaskedInterfaces = aThat.mData.ulMaskedInterfaces;
+            USBFilterClone(&mUSBFilter, &aThat.mUSBFilter);
+        }
+
+        /** Remote or local matching criterion. */
+        BOOLFilter mRemote;
+
+        /** The filter data blob. */
+        USBFILTER mUSBFilter;
+
+        /** Arbitrary ID field (not used by the class itself) */
+        void *mId;
+
+        settings::USBDeviceFilter mData;
+    };
+
+    DECLARE_COMMON_CLASS_METHODS(USBDeviceFilter)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(USBDeviceFilters *aParent,
+                 const settings::USBDeviceFilter &data);
+    HRESULT init(USBDeviceFilters *aParent, IN_BSTR aName);
+    HRESULT init(USBDeviceFilters *aParent, USBDeviceFilter *aThat,
+                 bool aReshare = false);
+    HRESULT initCopy(USBDeviceFilters *aParent, USBDeviceFilter *aThat);
+    void uninit();
+
+    // public methods only for internal purposes
+    bool i_isModified();
+    void i_rollback();
+    void i_commit();
+
+    void unshare();
+
+    // public methods for internal purposes only
+    // (ensure there is a caller and a read lock before calling them!)
+    void *& i_getId() { return bd->mId; }
+    const BackupableUSBDeviceFilterData& i_getData() { return *bd.data(); }
+    ComObjPtr<USBDeviceFilter> i_peer() { return mPeer; }
+
+    // tr() wants to belong to a class it seems, thus this one here.
+    static HRESULT i_usbFilterFieldFromString(PUSBFILTER aFilter,
+                                              USBFILTERIDX aIdx,
+                                              const Utf8Str &aValue,
+                                              Utf8Str &aErrStr);
+
+    static const char* i_describeUSBFilterIdx(USBFILTERIDX aIdx);
+
+private:
+
+    // wrapped IUSBDeviceFilter properties
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT setName(const com::Utf8Str &aName);
+    HRESULT getActive(BOOL *aActive);
+    HRESULT setActive(BOOL aActive);
+    HRESULT getVendorId(com::Utf8Str &aVendorId);
+    HRESULT setVendorId(const com::Utf8Str &aVendorId);
+    HRESULT getProductId(com::Utf8Str &aProductId);
+    HRESULT setProductId(const com::Utf8Str &aProductId);
+    HRESULT getRevision(com::Utf8Str &aRevision);
+    HRESULT setRevision(const com::Utf8Str &aRevision);
+    HRESULT getManufacturer(com::Utf8Str &aManufacturer);
+    HRESULT setManufacturer(const com::Utf8Str &aManufacturer);
+    HRESULT getProduct(com::Utf8Str &aProduct);
+    HRESULT setProduct(const com::Utf8Str &aProduct);
+    HRESULT getSerialNumber(com::Utf8Str &aSerialNumber);
+    HRESULT setSerialNumber(const com::Utf8Str &aSerialNumber);
+    HRESULT getPort(com::Utf8Str &aPort);
+    HRESULT setPort(const com::Utf8Str &aPort);
+    HRESULT getRemote(com::Utf8Str &aRemote);
+    HRESULT setRemote(const com::Utf8Str &aRemote);
+    HRESULT getMaskedInterfaces(ULONG *aMaskedInterfaces);
+    HRESULT setMaskedInterfaces(ULONG aMaskedInterfaces);
+
+    // wrapped IUSBDeviceFilter methods
+    HRESULT i_usbFilterFieldGetter(USBFILTERIDX aIdx, com::Utf8Str &aStr);
+    HRESULT i_usbFilterFieldSetter(USBFILTERIDX aIdx, const com::Utf8Str &strNew);
+
+    USBDeviceFilters * const     mParent;
+    USBDeviceFilter  * const     mPeer;
+
+    Backupable<BackupableUSBDeviceFilterData> bd;
+
+    bool m_fModified;
+
+    /** Used externally to indicate this filter is in the list
+        (not touched by the class itself except that in init()/uninit()) */
+    bool mInList;
+
+    friend class USBDeviceFilters;
+};
+#include "HostUSBDeviceFilterWrap.h"
+
+// HostUSBDeviceFilter
+////////////////////////////////////////////////////////////////////////////////
+
+class ATL_NO_VTABLE HostUSBDeviceFilter :
+    public HostUSBDeviceFilterWrap
+{
+public:
+
+    struct BackupableUSBDeviceFilterData : public USBDeviceFilter::BackupableUSBDeviceFilterData
+    {
+        BackupableUSBDeviceFilterData() {}
+    };
+
+    DECLARE_COMMON_CLASS_METHODS (HostUSBDeviceFilter)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Host *aParent,
+                 const settings::USBDeviceFilter &data);
+    HRESULT init(Host *aParent, IN_BSTR aName);
+    void uninit();
+
+    // public methods for internal purposes only
+    // (ensure there is a caller and a read lock before calling them!)
+    void i_saveSettings(settings::USBDeviceFilter &data);
+
+    void*& i_getId() { return bd.data()->mId; }
+
+    const BackupableUSBDeviceFilterData& i_getData() { return *bd.data(); }
+
+    // util::Lockable interface
+    RWLockHandle *lockHandle() const;
+
+private:
+
+    // wrapped IHostUSBDeviceFilter properties
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT setName(const com::Utf8Str &aName);
+    HRESULT getActive(BOOL *aActive);
+    HRESULT setActive(BOOL aActive);
+    HRESULT getVendorId(com::Utf8Str &aVendorId);
+    HRESULT setVendorId(const com::Utf8Str &aVendorId);
+    HRESULT getProductId(com::Utf8Str &aProductId);
+    HRESULT setProductId(const com::Utf8Str &aProductId);
+    HRESULT getRevision(com::Utf8Str &aRevision);
+    HRESULT setRevision(const com::Utf8Str &aRevision);
+    HRESULT getManufacturer(com::Utf8Str &aManufacturer);
+    HRESULT setManufacturer(const com::Utf8Str &aManufacturer);
+    HRESULT getProduct(com::Utf8Str &aProduct);
+    HRESULT setProduct(const com::Utf8Str &aProduct);
+    HRESULT getSerialNumber(com::Utf8Str &aSerialNumber);
+    HRESULT setSerialNumber(const com::Utf8Str &aSerialNumber);
+    HRESULT getPort(com::Utf8Str &aPort);
+    HRESULT setPort(const com::Utf8Str &aPort);
+    HRESULT getRemote(com::Utf8Str &aRemote);
+    HRESULT setRemote(const com::Utf8Str &aRemote);
+    HRESULT getMaskedInterfaces(ULONG *aMaskedInterfaces);
+    HRESULT setMaskedInterfaces(ULONG aMaskedInterfaces);
+
+    // wrapped IHostUSBDeviceFilter properties
+    HRESULT getAction(USBDeviceFilterAction_T *aAction);
+    HRESULT setAction(USBDeviceFilterAction_T aAction);
+
+    HRESULT i_usbFilterFieldGetter(USBFILTERIDX aIdx, com::Utf8Str &aStr);
+    HRESULT i_usbFilterFieldSetter(USBFILTERIDX aIdx, const com::Utf8Str &aStr);
+
+    Host * const        mParent;
+
+    Backupable<BackupableUSBDeviceFilterData>    bd;
+
+    /** Used externally to indicate this filter is in the list
+        (not touched by the class itself except that in init()/uninit()) */
+    bool mInList;
+
+    friend class Host;
+};
+
+#endif /* !MAIN_INCLUDED_USBDeviceFilterImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/USBDeviceFiltersImpl.h b/src/VBox/Main/include/USBDeviceFiltersImpl.h
new file mode 100644
index 00000000..b82c7523
--- /dev/null
+++ b/src/VBox/Main/include/USBDeviceFiltersImpl.h
@@ -0,0 +1,97 @@
+/* $Id: USBDeviceFiltersImpl.h $ */
+/** @file
+ * VBox USBDeviceFilters COM Class declaration.
+ */
+
+/*
+ * Copyright (C) 2013-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
+ */
+
+#ifndef MAIN_INCLUDED_USBDeviceFiltersImpl_h
+#define MAIN_INCLUDED_USBDeviceFiltersImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "USBDeviceFiltersWrap.h"
+
+class HostUSBDevice;
+class USBDeviceFilter;
+
+namespace settings
+{
+    struct USB;
+}
+
+class ATL_NO_VTABLE USBDeviceFilters :
+    public USBDeviceFiltersWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(USBDeviceFilters)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Machine *aParent);
+    HRESULT init(Machine *aParent, USBDeviceFilters *aThat);
+    HRESULT initCopy(Machine *aParent, USBDeviceFilters *aThat);
+    void uninit();
+
+    // public methods only for internal purposes
+    HRESULT i_loadSettings(const settings::USB &data);
+    HRESULT i_saveSettings(settings::USB &data);
+
+    void i_rollback();
+    void i_commit();
+    void i_copyFrom(USBDeviceFilters *aThat);
+
+#ifdef VBOX_WITH_USB
+    HRESULT i_onDeviceFilterChange(USBDeviceFilter *aFilter,
+                                   BOOL aActiveChanged = FALSE);
+    bool i_hasMatchingFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs);
+    bool i_hasMatchingFilter(IUSBDevice *aUSBDevice, ULONG *aMaskedIfs);
+    HRESULT i_notifyProxy(bool aInsertFilters);
+#endif /* VBOX_WITH_USB */
+
+    // public methods for internal purposes only
+    // (ensure there is a caller and a read lock before calling them!)
+    Machine* i_getMachine();
+
+private:
+
+    // Wrapped IUSBDeviceFilters attributes
+    HRESULT getDeviceFilters(std::vector<ComPtr<IUSBDeviceFilter> > &aDeviceFilters);
+
+    // wrapped IUSBDeviceFilters methods
+    HRESULT createDeviceFilter(const com::Utf8Str &aName,
+                               ComPtr<IUSBDeviceFilter> &aFilter);
+    HRESULT insertDeviceFilter(ULONG aPosition,
+                               const ComPtr<IUSBDeviceFilter> &aFilter);
+    HRESULT removeDeviceFilter(ULONG aPosition,
+                               ComPtr<IUSBDeviceFilter> &aFilter);
+    struct Data;
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_USBDeviceFiltersImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/USBDeviceImpl.h b/src/VBox/Main/include/USBDeviceImpl.h
new file mode 100644
index 00000000..84e378ca
--- /dev/null
+++ b/src/VBox/Main/include/USBDeviceImpl.h
@@ -0,0 +1,118 @@
+/* $Id: USBDeviceImpl.h $ */
+/** @file
+ * Header file for the OUSBDevice (IUSBDevice) class, VBoxC.
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_USBDeviceImpl_h
+#define MAIN_INCLUDED_USBDeviceImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "USBDeviceWrap.h"
+
+/**
+ * Object class used for maintaining devices attached to a USB controller.
+ * Generally this contains much less information.
+ */
+class ATL_NO_VTABLE OUSBDevice :
+    public USBDeviceWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(OUSBDevice)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(IUSBDevice *a_pUSBDevice);
+    void uninit();
+
+    // public methods only for internal purposes
+    const Guid &i_id() const { return mData.id; }
+
+private:
+
+    // Wrapped IUSBDevice properties
+    HRESULT getId(com::Guid &aId);
+    HRESULT getVendorId(USHORT *aVendorId);
+    HRESULT getProductId(USHORT *aProductId);
+    HRESULT getRevision(USHORT *aRevision);
+    HRESULT getManufacturer(com::Utf8Str &aManufacturer);
+    HRESULT getProduct(com::Utf8Str &aProduct);
+    HRESULT getSerialNumber(com::Utf8Str &aSerialNumber);
+    HRESULT getAddress(com::Utf8Str &aAddress);
+    HRESULT getPort(USHORT *aPort);
+    HRESULT getPortPath(com::Utf8Str &aPortPath);
+    HRESULT getVersion(USHORT *aVersion);
+    HRESULT getSpeed(USBConnectionSpeed_T *aSpeed);
+    HRESULT getRemote(BOOL *aRemote);
+    HRESULT getBackend(com::Utf8Str &aBackend);
+    HRESULT getDeviceInfo(std::vector<com::Utf8Str> &aInfo);
+
+    struct Data
+    {
+        Data() : vendorId(0), productId(0), revision(0), port(0),
+                 version(1), speed(USBConnectionSpeed_Null),
+                 remote(FALSE) {}
+
+        /** The UUID of this device. */
+        const Guid id;
+
+        /** The vendor id of this USB device. */
+        const USHORT vendorId;
+        /** The product id of this USB device. */
+        const USHORT productId;
+        /** The product revision number of this USB device.
+         * (high byte = integer; low byte = decimal) */
+        const USHORT revision;
+        /** The Manufacturer string. (Quite possibly NULL.) */
+        const com::Utf8Str manufacturer;
+        /** The Product string. (Quite possibly NULL.) */
+        const com::Utf8Str product;
+        /** The SerialNumber string. (Quite possibly NULL.) */
+        const com::Utf8Str serialNumber;
+        /** The host specific address of the device. */
+        const com::Utf8Str address;
+        /** The device specific backend. */
+        const com::Utf8Str backend;
+        /** The host port number. */
+        const USHORT port;
+        /** The host port path. */
+        const com::Utf8Str portPath;
+        /** The major USB version number of the device. */
+        const USHORT version;
+        /** The speed at which the device is communicating. */
+        const USBConnectionSpeed_T speed;
+        /** Remote (VRDP) or local device. */
+        const BOOL remote;
+    };
+
+    Data mData;
+};
+
+#endif /* !MAIN_INCLUDED_USBDeviceImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/USBGetDevices.h b/src/VBox/Main/include/USBGetDevices.h
new file mode 100644
index 00000000..d4bcfbdc
--- /dev/null
+++ b/src/VBox/Main/include/USBGetDevices.h
@@ -0,0 +1,114 @@
+/* $Id: USBGetDevices.h $ */
+/** @file
+ * VirtualBox Linux host USB device enumeration.
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_USBGetDevices_h
+#define MAIN_INCLUDED_USBGetDevices_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/usb.h>
+#include <iprt/mem.h>
+#include <iprt/string.h>
+
+/**
+ * Free all the members of a USB device created by the Linux enumeration code.
+ *
+ * @note This duplicates a USBProxyService method which we needed access too
+ *       without pulling in the rest of the proxy service code.
+ *
+ * @param   pDevice     Pointer to the device.
+ */
+DECLINLINE(void) deviceFreeMembers(PUSBDEVICE pDevice)
+{
+    RTStrFree((char *)pDevice->pszManufacturer);
+    pDevice->pszManufacturer = NULL;
+    RTStrFree((char *)pDevice->pszProduct);
+    pDevice->pszProduct = NULL;
+    RTStrFree((char *)pDevice->pszSerialNumber);
+    pDevice->pszSerialNumber = NULL;
+
+    RTStrFree((char *)pDevice->pszAddress);
+    pDevice->pszAddress = NULL;
+}
+
+/**
+ * Free one USB device created by the Linux enumeration code.
+ *
+ * @note This duplicates a USBProxyService method which we needed access too
+ *       without pulling in the rest of the proxy service code.
+ *
+ * @param   pDevice     Pointer to the device. NULL is OK.
+ */
+DECLINLINE(void) deviceFree(PUSBDEVICE pDevice)
+{
+    if (pDevice)
+    {
+        deviceFreeMembers(pDevice);
+        RTMemFree(pDevice);
+    }
+}
+
+/**
+ * Free a linked list of USB devices created by the Linux enumeration code.
+ * @param  ppHead  Pointer to the first device in the linked list
+ */
+DECLINLINE(void) deviceListFree(PUSBDEVICE *ppHead)
+{
+    PUSBDEVICE pHead = *ppHead;
+    while (pHead)
+    {
+        PUSBDEVICE pNext = pHead->pNext;
+        deviceFree(pHead);
+        pHead = pNext;
+    }
+    *ppHead = NULL;
+}
+
+RT_C_DECLS_BEGIN
+
+extern bool USBProxyLinuxCheckDeviceRoot(const char *pcszRoot, bool fIsDeviceNodes);
+
+#ifdef UNIT_TEST
+void TestUSBSetupInit(const char *pcszUsbfsRoot, bool fUsbfsAccessible,
+                      const char *pcszDevicesRoot, bool fDevicesAccessible,
+                      int vrcMethodInitResult);
+void TestUSBSetEnv(const char *pcszEnvUsb, const char *pcszEnvUsbRoot);
+#endif
+
+extern int USBProxyLinuxChooseMethod(bool *pfUsingUsbfsDevices, const char **ppcszDevicesRoot);
+#ifdef UNIT_TEST
+extern void TestUSBSetAvailableUsbfsDevices(const char **pacszDeviceAddresses);
+extern void TestUSBSetAccessibleFiles(const char **pacszAccessibleFiles);
+#endif
+
+extern PUSBDEVICE USBProxyLinuxGetDevices(const char *pcszDevicesRoot, bool fUseSysfs);
+
+RT_C_DECLS_END
+
+#endif /* !MAIN_INCLUDED_USBGetDevices_h */
+
diff --git a/src/VBox/Main/include/USBIdDatabase.h b/src/VBox/Main/include/USBIdDatabase.h
new file mode 100644
index 00000000..b739a017
--- /dev/null
+++ b/src/VBox/Main/include/USBIdDatabase.h
@@ -0,0 +1,226 @@
+/* $Id: USBIdDatabase.h $ */
+/** @file
+ * USB device vendor and product ID database.
+ */
+
+/*
+ * Copyright (C) 2015-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
+ */
+
+#ifndef MAIN_INCLUDED_USBIdDatabase_h
+#define MAIN_INCLUDED_USBIdDatabase_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/assert.h>
+#include <iprt/stdint.h>
+#include <iprt/cpp/ministring.h>
+#include <iprt/bldprog-strtab.h>
+
+
+/** Saves a few bytes (~25%) on strings.  */
+#define USB_ID_DATABASE_WITH_COMPRESSION
+
+/** Max string length. */
+#define USB_ID_DATABASE_MAX_STRING      _1K
+
+
+AssertCompileSize(RTBLDPROGSTRREF, sizeof(uint32_t));
+
+
+/**
+ * Elements of product table.
+ */
+typedef struct USBIDDBPROD
+{
+    /** Product ID. */
+    uint16_t idProduct;
+} USBIDDBPROD;
+AssertCompileSize(USBIDDBPROD, sizeof(uint16_t));
+
+
+/**
+ * Element of vendor table.
+ */
+typedef struct USBIDDBVENDOR
+{
+    /** Vendor ID. */
+    uint16_t idVendor;
+    /** Index of the first product. */
+    uint16_t iProduct;
+    /** Number of products. */
+    uint16_t cProducts;
+} USBIDDBVENDOR;
+AssertCompileSize(USBIDDBVENDOR, sizeof(uint16_t) * 3);
+
+
+/**
+ * Wrapper for static array of Aliases.
+ */
+class USBIdDatabase
+{
+public: // For assertions and statis in the generator.
+    /** The compressed string table.   */
+    static RTBLDPROGSTRTAB const s_StrTab;
+
+    /** Number of vendors in the two parallel arrays.   */
+    static const size_t          s_cVendors;
+    /** Vendor IDs lookup table. */
+    static const USBIDDBVENDOR   s_aVendors[];
+    /** Vendor names table running parallel to s_aVendors. */
+    static const RTBLDPROGSTRREF s_aVendorNames[];
+
+    /** Number of products in the two parallel arrays. */
+    static const size_t          s_cProducts;
+    /** Vendor+Product keys for lookup purposes. */
+    static const USBIDDBPROD     s_aProducts[];
+    /** Product names table running parallel to s_aProducts. */
+    static const RTBLDPROGSTRREF s_aProductNames[];
+
+public:
+    static RTCString returnString(PCRTBLDPROGSTRREF pStr)
+    {
+        char szTmp[USB_ID_DATABASE_MAX_STRING * 2];
+        ssize_t cchTmp = RTBldProgStrTabQueryString(&s_StrTab, pStr->off, pStr->cch, szTmp, sizeof(szTmp));
+        return RTCString(szTmp, (size_t)RT_MAX(cchTmp, 0));
+    }
+
+private:
+    /**
+     * Performs a binary lookup of @a idVendor.
+     *
+     * @returns The index in the vendor tables, UINT32_MAX if not found.
+     * @param   idVendor        The vendor ID.
+     */
+    static uint32_t lookupVendor(uint16_t idVendor)
+    {
+        size_t iEnd   = s_cVendors;
+        if (iEnd)
+        {
+            size_t iStart = 0;
+            for (;;)
+            {
+                size_t idx = iStart + (iEnd - iStart) / 2;
+                if (s_aVendors[idx].idVendor < idVendor)
+                {
+                    idx++;
+                    if (idx < iEnd)
+                        iStart = idx;
+                    else
+                        break;
+                }
+                else if (s_aVendors[idx].idVendor > idVendor)
+                {
+                    if (idx != iStart)
+                        iEnd = idx;
+                    else
+                        break;
+                }
+                else
+                    return (uint32_t)idx;
+            }
+        }
+        return UINT32_MAX;
+    }
+
+    /**
+     * Performs a binary lookup of @a idProduct.
+     *
+     * @returns The index in the product tables, UINT32_MAX if not found.
+     * @param   idProduct       The product ID.
+     * @param   iStart          The index of the first entry for the vendor.
+     * @param   iEnd            The index of after the last entry.
+     */
+    static uint32_t lookupProduct(uint16_t idProduct, size_t iStart, size_t iEnd)
+    {
+        if (iStart < iEnd)
+        {
+            for (;;)
+            {
+                size_t idx = iStart + (iEnd - iStart) / 2;
+                if (s_aProducts[idx].idProduct < idProduct)
+                {
+                    idx++;
+                    if (idx < iEnd)
+                        iStart = idx;
+                    else
+                        break;
+                }
+                else if (s_aProducts[idx].idProduct > idProduct)
+                {
+                    if (idx != iStart)
+                        iEnd = idx;
+                    else
+                        break;
+                }
+                else
+                    return (uint32_t)idx;
+            }
+        }
+        return UINT32_MAX;
+    }
+
+
+public:
+    static RTCString findProduct(uint16_t idVendor, uint16_t idProduct)
+    {
+        uint32_t idxVendor = lookupVendor(idVendor);
+        if (idxVendor != UINT32_MAX)
+        {
+            uint32_t idxProduct = lookupProduct(idProduct, s_aVendors[idxVendor].iProduct,
+                                                s_aVendors[idxVendor].iProduct + s_aVendors[idxVendor].cProducts);
+            if (idxProduct != UINT32_MAX)
+                return returnString(&s_aProductNames[idxProduct]);
+        }
+        return RTCString();
+    }
+
+    static RTCString findVendor(uint16_t idVendor)
+    {
+        uint32_t idxVendor = lookupVendor(idVendor);
+        if (idxVendor != UINT32_MAX)
+            return returnString(&s_aVendorNames[idxVendor]);
+        return RTCString();
+    }
+
+    static RTCString findVendorAndProduct(uint16_t idVendor, uint16_t idProduct, RTCString *pstrProduct)
+    {
+        uint32_t idxVendor = lookupVendor(idVendor);
+        if (idxVendor != UINT32_MAX)
+        {
+            uint32_t idxProduct = lookupProduct(idProduct, s_aVendors[idxVendor].iProduct,
+                                                s_aVendors[idxVendor].iProduct + s_aVendors[idxVendor].cProducts);
+            if (idxProduct != UINT32_MAX)
+                *pstrProduct = returnString(&s_aProductNames[idxProduct]);
+            else
+                pstrProduct->setNull();
+            return returnString(&s_aVendorNames[idxVendor]);
+        }
+        pstrProduct->setNull();
+        return RTCString();
+    }
+
+};
+
+
+#endif /* !MAIN_INCLUDED_USBIdDatabase_h */
+
diff --git a/src/VBox/Main/include/USBProxyBackend.h b/src/VBox/Main/include/USBProxyBackend.h
new file mode 100644
index 00000000..540f4d14
--- /dev/null
+++ b/src/VBox/Main/include/USBProxyBackend.h
@@ -0,0 +1,448 @@
+/* $Id: USBProxyBackend.h $ */
+/** @file
+ * VirtualBox USB Proxy Backend (base) class.
+ */
+
+/*
+ * Copyright (C) 2005-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
+ */
+
+#ifndef MAIN_INCLUDED_USBProxyBackend_h
+#define MAIN_INCLUDED_USBProxyBackend_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/usb.h>
+#include <VBox/usbfilter.h>
+
+#include <iprt/socket.h>
+#include <iprt/poll.h>
+#include <iprt/semaphore.h>
+#include <iprt/cpp/utils.h>
+
+#include "VirtualBoxBase.h"
+#include "VirtualBoxImpl.h"
+#include "HostUSBDeviceImpl.h"
+#include "USBProxyBackendWrap.h"
+class USBProxyService;
+
+/**
+ * Base class for the USB Proxy Backend.
+ */
+class ATL_NO_VTABLE USBProxyBackend
+    : public USBProxyBackendWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(USBProxyBackend)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    virtual int init(USBProxyService *pUsbProxyService, const com::Utf8Str &strId,
+                     const com::Utf8Str &strAddress, bool fLoadingSettings);
+    virtual void uninit();
+
+    bool isActive(void);
+    const com::Utf8Str &i_getId();
+    const com::Utf8Str &i_getAddress();
+    virtual const com::Utf8Str &i_getBackend();
+    uint32_t i_getRefCount();
+
+    virtual bool i_isDevReEnumerationRequired();
+
+    /** @name Interface for the USBController and the Host object.
+     * @{ */
+    virtual void *insertFilter(PCUSBFILTER aFilter);
+    virtual void removeFilter(void *aId);
+    /** @} */
+
+    /** @name Interfaces for the HostUSBDevice
+     * @{ */
+    virtual int captureDevice(HostUSBDevice *aDevice);
+    virtual void captureDeviceCompleted(HostUSBDevice *aDevice, bool aSuccess);
+    virtual int releaseDevice(HostUSBDevice *aDevice);
+    virtual void releaseDeviceCompleted(HostUSBDevice *aDevice, bool aSuccess);
+    /** @} */
+
+    static void freeDevice(PUSBDEVICE pDevice);
+
+protected:
+    int start(void);
+    int stop(void);
+    virtual void serviceThreadInit(void);
+    virtual void serviceThreadTerm(void);
+
+    virtual int wait(RTMSINTERVAL aMillies);
+    virtual int interruptWait(void);
+    virtual PUSBDEVICE getDevices(void);
+    uint32_t incRef();
+    uint32_t decRef();
+
+    static HRESULT setError(HRESULT aResultCode, const char *aText, ...);
+
+    static void initFilterFromDevice(PUSBFILTER aFilter, HostUSBDevice *aDevice);
+    static void freeDeviceMembers(PUSBDEVICE pDevice);
+
+    /**
+     * Backend specific callback when a device was added.
+     * (Currently only Linux uses it to adjust the udev polling).
+     */
+    virtual void deviceAdded(ComObjPtr<HostUSBDevice> &aDevice, PUSBDEVICE pDev);
+    virtual bool isFakeUpdateRequired();
+
+private:
+
+    // wrapped IUSBProxyBackend properties
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT getType(com::Utf8Str &aType);
+
+    static DECLCALLBACK(int) serviceThread(RTTHREAD Thread, void *pvUser);
+
+    void updateDeviceList(PUSBDEVICE pDevices);
+
+protected:
+    /** Pointer to the owning USB Proxy Service object. */
+    USBProxyService   *m_pUsbProxyService;
+    /** Thread handle of the service thread. */
+    RTTHREAD           mThread;
+    /** Flag which stop() sets to cause serviceThread to return. */
+    bool volatile      mTerminate;
+    /** Id of the instance. */
+    const com::Utf8Str m_strId;
+    /** Address of the instance. */
+    const com::Utf8Str m_strAddress;
+    /** Backend identifier as used in the settings. */
+    const com::Utf8Str m_strBackend;
+    /** Reference counter which prevents the backend instance from being removed. */
+    uint32_t           m_cRefs;
+    /** List of smart HostUSBDevice pointers. */
+    typedef std::list<ComObjPtr<HostUSBDevice> > HostUSBDeviceList;
+    /** List of the known USB devices for this backend. */
+    HostUSBDeviceList  m_llDevices;
+};
+
+
+# if defined(RT_OS_DARWIN) || defined(DOXYGEN_RUNNING)
+#  include <VBox/param.h>
+#  undef PAGE_SHIFT
+#  undef PAGE_SIZE
+#  define OSType Carbon_OSType
+#  include <Carbon/Carbon.h>
+#  undef OSType
+#  undef PVM
+
+/**
+ * The Darwin hosted USB Proxy Backend.
+ */
+class USBProxyBackendDarwin : public USBProxyBackend
+{
+public:
+    DECLARE_COMMON_CLASS_METHODS(USBProxyBackendDarwin)
+
+    int init(USBProxyService *pUsbProxyService, const com::Utf8Str &strId,
+             const com::Utf8Str &strAddress, bool fLoadingSettings);
+    void uninit();
+
+    virtual int captureDevice(HostUSBDevice *aDevice);
+    virtual int releaseDevice(HostUSBDevice *aDevice);
+
+protected:
+    virtual int wait(RTMSINTERVAL aMillies);
+    virtual int interruptWait (void);
+    virtual PUSBDEVICE getDevices (void);
+    virtual void serviceThreadInit (void);
+    virtual void serviceThreadTerm (void);
+    virtual bool isFakeUpdateRequired();
+
+private:
+    /** Reference to the runloop of the service thread.
+     * This is NULL if the service thread isn't running. */
+    CFRunLoopRef mServiceRunLoopRef;
+    /** The opaque value returned by DarwinSubscribeUSBNotifications. */
+    void *mNotifyOpaque;
+    /** A hack to work around the problem with the usb device enumeration
+     * not including newly attached devices. */
+    bool mWaitABitNextTime;
+};
+# endif /* RT_OS_DARWIN */
+
+
+# if defined(RT_OS_LINUX) || defined(DOXYGEN_RUNNING)
+#  include <stdio.h>
+#  ifdef VBOX_USB_WITH_SYSFS
+#   include <HostHardwareLinux.h>
+#  endif
+
+/**
+ * The Linux hosted USB Proxy Backend.
+ */
+class USBProxyBackendLinux: public USBProxyBackend
+{
+public:
+    DECLARE_COMMON_CLASS_METHODS(USBProxyBackendLinux)
+
+    int init(USBProxyService *pUsbProxyService, const com::Utf8Str &strId,
+             const com::Utf8Str &strAddress, bool fLoadingSettings);
+    void uninit();
+
+    virtual int captureDevice(HostUSBDevice *aDevice);
+    virtual int releaseDevice(HostUSBDevice *aDevice);
+
+protected:
+    int initUsbfs(void);
+    int initSysfs(void);
+    void doUsbfsCleanupAsNeeded(void);
+    virtual int wait(RTMSINTERVAL aMillies);
+    virtual int interruptWait(void);
+    virtual PUSBDEVICE getDevices(void);
+    virtual void deviceAdded(ComObjPtr<HostUSBDevice> &aDevice, PUSBDEVICE aUSBDevice);
+    virtual bool isFakeUpdateRequired();
+
+private:
+    int waitUsbfs(RTMSINTERVAL aMillies);
+    int waitSysfs(RTMSINTERVAL aMillies);
+
+private:
+    /** File handle to the '/proc/bus/usb/devices' file. */
+    RTFILE mhFile;
+    /** Pipe used to interrupt wait(), the read end. */
+    RTPIPE mhWakeupPipeR;
+    /** Pipe used to interrupt wait(), the write end. */
+    RTPIPE mhWakeupPipeW;
+    /** The root of usbfs. */
+    Utf8Str mDevicesRoot;
+    /** Whether we're using \<mUsbfsRoot\>/devices or /sys/whatever. */
+    bool mUsingUsbfsDevices;
+    /** Number of 500ms polls left to do. See usbDeterminState for details. */
+    unsigned mUdevPolls;
+#  ifdef VBOX_USB_WITH_SYSFS
+    /** Object used for polling for hotplug events from hal. */
+    VBoxMainHotplugWaiter *mpWaiter;
+#  endif
+};
+# endif /* RT_OS_LINUX */
+
+
+# if defined(RT_OS_OS2) || defined(DOXYGEN_RUNNING)
+#  include <usbcalls.h>
+
+/**
+ * The Linux hosted USB Proxy Backend.
+ */
+class USBProxyBackendOs2 : public USBProxyBackend
+{
+public:
+    DECLARE_COMMON_CLASS_METHODS(USBProxyBackendOs2)
+
+    virtual int captureDevice(HostUSBDevice *aDevice);
+    virtual int releaseDevice(HostUSBDevice *aDevice);
+
+protected:
+    virtual int wait(RTMSINTERVAL aMillies);
+    virtual int interruptWait(void);
+    virtual PUSBDEVICE getDevices(void);
+    int addDeviceToChain(PUSBDEVICE pDev, PUSBDEVICE *ppFirst, PUSBDEVICE **pppNext, int rc);
+
+private:
+    /** The notification event semaphore */
+    HEV mhev;
+    /** The notification id. */
+    USBNOTIFY mNotifyId;
+    /** The usbcalls.dll handle. */
+    HMODULE mhmod;
+    /** UsbRegisterChangeNotification */
+    APIRET (APIENTRY *mpfnUsbRegisterChangeNotification)(PUSBNOTIFY, HEV, HEV);
+    /** UsbDeregisterNotification */
+    APIRET (APIENTRY *mpfnUsbDeregisterNotification)(USBNOTIFY);
+    /** UsbQueryNumberDevices */
+    APIRET (APIENTRY *mpfnUsbQueryNumberDevices)(PULONG);
+    /** UsbQueryDeviceReport */
+    APIRET (APIENTRY *mpfnUsbQueryDeviceReport)(ULONG, PULONG, PVOID);
+};
+# endif /* RT_OS_OS2 */
+
+
+# if defined(RT_OS_SOLARIS) || defined(DOXYGEN_RUNNING)
+#  include <libdevinfo.h>
+
+/**
+ * The Solaris hosted USB Proxy Backend.
+ */
+class USBProxyBackendSolaris : public USBProxyBackend
+{
+public:
+    DECLARE_COMMON_CLASS_METHODS(USBProxyBackendSolaris)
+
+    int init(USBProxyService *pUsbProxyService, const com::Utf8Str &strId,
+             const com::Utf8Str &strAddress, bool fLoadingSettings);
+    void uninit();
+
+    virtual void *insertFilter (PCUSBFILTER aFilter);
+    virtual void removeFilter (void *aID);
+
+    virtual int captureDevice(HostUSBDevice *aDevice);
+    virtual int releaseDevice(HostUSBDevice *aDevice);
+    virtual void captureDeviceCompleted(HostUSBDevice *aDevice, bool aSuccess);
+    virtual void releaseDeviceCompleted(HostUSBDevice *aDevice, bool aSuccess);
+
+    virtual bool i_isDevReEnumerationRequired();
+
+protected:
+    virtual int wait(RTMSINTERVAL aMillies);
+    virtual int interruptWait(void);
+    virtual PUSBDEVICE getDevices(void);
+
+private:
+    RTSEMEVENT mNotifyEventSem;
+    /** Whether we've successfully initialized the USBLib and should call USBLibTerm in the destructor. */
+    bool mUSBLibInitialized;
+};
+#endif  /* RT_OS_SOLARIS */
+
+
+# if defined(RT_OS_WINDOWS) || defined(DOXYGEN_RUNNING)
+/**
+ * The Windows hosted USB Proxy Backend.
+ */
+class USBProxyBackendWindows : public USBProxyBackend
+{
+public:
+    DECLARE_COMMON_CLASS_METHODS(USBProxyBackendWindows)
+
+    int init(USBProxyService *pUsbProxyService, const com::Utf8Str &strId,
+             const com::Utf8Str &strAddress, bool fLoadingSettings);
+    void uninit();
+
+    virtual void *insertFilter (PCUSBFILTER aFilter);
+    virtual void removeFilter (void *aID);
+
+    virtual int captureDevice(HostUSBDevice *aDevice);
+    virtual int releaseDevice(HostUSBDevice *aDevice);
+
+    virtual bool i_isDevReEnumerationRequired();
+
+protected:
+    virtual int wait(RTMSINTERVAL aMillies);
+    virtual int interruptWait(void);
+    virtual PUSBDEVICE getDevices(void);
+
+private:
+
+    HANDLE mhEventInterrupt;
+};
+# endif /* RT_OS_WINDOWS */
+
+# if defined(RT_OS_FREEBSD) || defined(DOXYGEN_RUNNING)
+/**
+ * The FreeBSD hosted USB Proxy Backend.
+ */
+class USBProxyBackendFreeBSD : public USBProxyBackend
+{
+public:
+    DECLARE_COMMON_CLASS_METHODS(USBProxyBackendFreeBSD)
+
+    int init(USBProxyService *pUsbProxyService, const com::Utf8Str &strId,
+             const com::Utf8Str &strAddress, bool fLoadingSettings);
+    void uninit();
+
+    virtual int captureDevice(HostUSBDevice *aDevice);
+    virtual int releaseDevice(HostUSBDevice *aDevice);
+
+protected:
+    int initUsbfs(void);
+    int initSysfs(void);
+    virtual int wait(RTMSINTERVAL aMillies);
+    virtual int interruptWait(void);
+    virtual PUSBDEVICE getDevices(void);
+    int addDeviceToChain(PUSBDEVICE pDev, PUSBDEVICE *ppFirst, PUSBDEVICE **pppNext, int rc);
+    virtual bool isFakeUpdateRequired();
+
+private:
+    RTSEMEVENT mNotifyEventSem;
+};
+# endif /* RT_OS_FREEBSD */
+
+/**
+ * USB/IP Proxy receive state.
+ */
+typedef enum USBIPRECVSTATE
+{
+    /** Invalid state. */
+    kUsbIpRecvState_Invalid = 0,
+    /** There is no request waiting for an answer. */
+    kUsbIpRecvState_None,
+    /** Waiting for the complete reception of UsbIpRetDevList. */
+    kUsbIpRecvState_Hdr,
+    /** Waiting for the complete reception of a UsbIpExportedDevice structure. */
+    kUsbIpRecvState_ExportedDevice,
+    /** Waiting for a complete reception of a UsbIpDeviceInterface structure to skip. */
+    kUsbIpRecvState_DeviceInterface,
+    /** 32bit hack. */
+    kUsbIpRecvState_32Bit_Hack = 0x7fffffff
+} USBIPRECVSTATE;
+/** Pointer to a USB/IP receive state enum. */
+typedef USBIPRECVSTATE *PUSBIPRECVSTATE;
+
+struct UsbIpExportedDevice;
+
+/**
+ * The USB/IP Proxy Backend.
+ */
+class USBProxyBackendUsbIp: public USBProxyBackend
+{
+public:
+    DECLARE_COMMON_CLASS_METHODS(USBProxyBackendUsbIp)
+
+    int init(USBProxyService *pUsbProxyService, const com::Utf8Str &strId,
+             const com::Utf8Str &strAddress, bool fLoadingSettings);
+    void uninit();
+
+    virtual int captureDevice(HostUSBDevice *aDevice);
+    virtual int releaseDevice(HostUSBDevice *aDevice);
+
+protected:
+    virtual int wait(RTMSINTERVAL aMillies);
+    virtual int interruptWait(void);
+    virtual PUSBDEVICE getDevices(void);
+    virtual bool isFakeUpdateRequired();
+
+private:
+    int  updateDeviceList(bool *pfDeviceListChanged);
+    bool hasDevListChanged(PUSBDEVICE pDevices);
+    void freeDeviceList(PUSBDEVICE pHead);
+    void resetRecvState();
+    int  reconnect();
+    void disconnect();
+    int  startListExportedDevicesReq();
+    void advanceState(USBIPRECVSTATE enmRecvState);
+    int  receiveData();
+    int  processData();
+    int  addDeviceToList(UsbIpExportedDevice *pDev);
+
+    struct Data;            // opaque data struct, defined in USBProxyBackendUsbIp.cpp
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_USBProxyBackend_h */
+
diff --git a/src/VBox/Main/include/USBProxyService.h b/src/VBox/Main/include/USBProxyService.h
new file mode 100644
index 00000000..f73bec85
--- /dev/null
+++ b/src/VBox/Main/include/USBProxyService.h
@@ -0,0 +1,147 @@
+/* $Id: USBProxyService.h $ */
+/** @file
+ * VirtualBox USB Proxy Service (base) class.
+ */
+
+/*
+ * Copyright (C) 2005-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
+ */
+
+#ifndef MAIN_INCLUDED_USBProxyService_h
+#define MAIN_INCLUDED_USBProxyService_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/usb.h>
+#include <VBox/usbfilter.h>
+
+#include "VirtualBoxBase.h"
+#include "VirtualBoxImpl.h"
+#include "HostUSBDeviceImpl.h"
+#include "USBProxyBackend.h"
+
+class Host;
+
+namespace settings
+{
+    struct USBDeviceSource;
+    typedef std::list<USBDeviceSource> USBDeviceSourcesList;
+}
+
+
+/**
+ * Base class for the USB Proxy service.
+ */
+class USBProxyService
+    : public Lockable
+{
+public:
+    DECLARE_TRANSLATE_METHODS(USBProxyService)
+
+    USBProxyService(Host *aHost);
+    virtual HRESULT init(void);
+    virtual ~USBProxyService();
+
+    /**
+     * Override of the default locking class to be used for validating lock
+     * order with the standard member lock handle.
+     */
+    virtual VBoxLockingClass getLockingClass() const
+    {
+        // the USB proxy service uses the Host object lock, so return the
+        // same locking class as the host
+        return LOCKCLASS_HOSTOBJECT;
+    }
+
+    void uninit(void);
+
+    bool isActive(void);
+    int getLastError(void);
+
+    RWLockHandle *lockHandle() const;
+
+    /** @name Interface for the USBController and the Host object.
+     * @{ */
+    void *insertFilter(PCUSBFILTER aFilter);
+    void removeFilter(void *aId);
+    /** @} */
+
+    /** @name Host Interfaces
+     * @{ */
+    HRESULT getDeviceCollection(std::vector<ComPtr<IHostUSBDevice> > &aUSBDevices);
+    HRESULT addUSBDeviceSource(const com::Utf8Str &aBackend, const com::Utf8Str &aId, const com::Utf8Str &aAddress,
+                               const std::vector<com::Utf8Str> &aPropertyNames, const std::vector<com::Utf8Str> &aPropertyValues);
+    HRESULT removeUSBDeviceSource(const com::Utf8Str &aId);
+    /** @} */
+
+    /** @name SessionMachine Interfaces
+     * @{ */
+    HRESULT captureDeviceForVM(SessionMachine *aMachine, IN_GUID aId, const com::Utf8Str &aCaptureFilename);
+    HRESULT detachDeviceFromVM(SessionMachine *aMachine, IN_GUID aId, bool aDone);
+    HRESULT autoCaptureDevicesForVM(SessionMachine *aMachine);
+    HRESULT detachAllDevicesFromVM(SessionMachine *aMachine, bool aDone, bool aAbnormal);
+    /** @} */
+
+    typedef std::list< ComObjPtr<HostUSBDeviceFilter> > USBDeviceFilterList;
+
+    HRESULT i_loadSettings(const settings::USBDeviceSourcesList &llUSBDeviceSources);
+    HRESULT i_saveSettings(settings::USBDeviceSourcesList &llUSBDeviceSources);
+
+    void i_deviceAdded(ComObjPtr<HostUSBDevice> &aDevice, PUSBDEVICE aUSBDevice);
+    void i_deviceRemoved(ComObjPtr<HostUSBDevice> &aDevice);
+    void i_updateDeviceState(ComObjPtr<HostUSBDevice> &aDevice, PUSBDEVICE aUSBDevice, bool fFakeUpdate);
+
+protected:
+    ComObjPtr<HostUSBDevice> findDeviceById(IN_GUID aId);
+
+    static HRESULT setError(HRESULT aResultCode, const char *aText, ...);
+
+    USBProxyBackend *findUsbProxyBackendById(const com::Utf8Str &strId);
+
+    HRESULT createUSBDeviceSource(const com::Utf8Str &aBackend, const com::Utf8Str &aId,
+                                  const com::Utf8Str &aAddress, const std::vector<com::Utf8Str> &aPropertyNames,
+                                  const std::vector<com::Utf8Str> &aPropertyValues, bool fLoadingSettings);
+
+private:
+
+    HRESULT runAllFiltersOnDevice(ComObjPtr<HostUSBDevice> &aDevice,
+                                  SessionMachinesList &llOpenedMachines,
+                                  SessionMachine *aIgnoreMachine);
+    bool runMachineFilters(SessionMachine *aMachine, ComObjPtr<HostUSBDevice> &aDevice);
+
+    void deviceChanged(ComObjPtr<HostUSBDevice> &aDevice, bool fRunFilters, SessionMachine *aIgnoreMachine);
+
+    /** Pointer to the Host object. */
+    Host *mHost;
+    /** List of smart HostUSBDevice pointers. */
+    typedef std::list<ComObjPtr<HostUSBDevice> > HostUSBDeviceList;
+    /** List of the known USB devices. */
+    HostUSBDeviceList mDevices;
+    /** List of USBProxyBackend pointers. */
+    typedef std::list<ComObjPtr<USBProxyBackend> > USBProxyBackendList;
+    /** List of active USB backends. */
+    USBProxyBackendList mBackends;
+    int                 mLastError;
+};
+
+#endif /* !MAIN_INCLUDED_USBProxyService_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/UefiVariableStoreImpl.h b/src/VBox/Main/include/UefiVariableStoreImpl.h
new file mode 100644
index 00000000..a77bdfa0
--- /dev/null
+++ b/src/VBox/Main/include/UefiVariableStoreImpl.h
@@ -0,0 +1,105 @@
+/* $Id: UefiVariableStoreImpl.h $ */
+/** @file
+ * VirtualBox COM UEFI variable store class implementation
+ */
+
+/*
+ * Copyright (C) 2021-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
+ */
+
+#ifndef MAIN_INCLUDED_UefiVariableStoreImpl_h
+#define MAIN_INCLUDED_UefiVariableStoreImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "UefiVariableStoreWrap.h"
+#include <iprt/types.h>
+
+#include <iprt/formats/efi-common.h>
+
+class NvramStore;
+class Machine;
+
+class ATL_NO_VTABLE UefiVariableStore :
+    public UefiVariableStoreWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(UefiVariableStore)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(NvramStore *aParent, Machine *pMachine);
+    void uninit();
+
+    // public methods for internal purposes only
+
+private:
+
+    // Wrapped NVRAM store properties
+    HRESULT getSecureBootEnabled(BOOL *pfEnabled);
+    HRESULT setSecureBootEnabled(BOOL fEnabled);
+
+    // Wrapped NVRAM store members
+    HRESULT addVariable(const com::Utf8Str &aName, const com::Guid &aOwnerUuid, const std::vector<UefiVariableAttributes_T> &aAttributes,
+                        const std::vector<BYTE> &aData);
+    HRESULT deleteVariable(const com::Utf8Str &aName, const com::Guid &aOwnerUuid);
+    HRESULT changeVariable(const com::Utf8Str &aName, const std::vector<BYTE> &aData);
+    HRESULT queryVariableByName(const com::Utf8Str &aName, com::Guid &aOwnerUuid, std::vector<UefiVariableAttributes_T> &aAttributes,
+                                std::vector<BYTE> &aData);
+    HRESULT queryVariables(std::vector<com::Utf8Str> &aNames, std::vector<com::Guid> &aOwnerUuids);
+    HRESULT enrollOraclePlatformKey(void);
+    HRESULT enrollPlatformKey(const std::vector<BYTE> &aData, const com::Guid &aOwnerUuid);
+    HRESULT addKek(const std::vector<BYTE> &aData, const com::Guid &aOwnerUuid, SignatureType_T enmSignatureType);
+    HRESULT addSignatureToDb(const std::vector<BYTE> &aData, const com::Guid &aOwnerUuid, SignatureType_T enmSignatureType);
+    HRESULT addSignatureToDbx(const std::vector<BYTE> &aData, const com::Guid &aOwnerUuid, SignatureType_T enmSignatureType);
+    HRESULT enrollDefaultMsSignatures(void);
+    HRESULT addSignatureToMok(const std::vector<BYTE> &aData, const com::Guid &aOwnerUuid, SignatureType_T enmSignatureType);
+
+    int i_uefiVarStoreSetVarAttr(const char *pszVar, uint32_t fAttr);
+    int i_uefiVarStoreQueryVarAttr(const char *pszVar, uint32_t *pfAttr);
+    int i_uefiVarStoreQueryVarSz(const char *pszVar, uint64_t *pcbVar);
+    int i_uefiVarStoreQueryVarOwnerUuid(const char *pszVar, PRTUUID pUuid);
+    uint32_t i_uefiVarAttrToMask(const std::vector<UefiVariableAttributes_T> &aAttributes);
+    void i_uefiAttrMaskToVec(uint32_t fAttr, std::vector<UefiVariableAttributes_T> &aAttributes);
+
+    HRESULT i_retainUefiVariableStore(bool fReadonly);
+    HRESULT i_releaseUefiVariableStore(void);
+
+    HRESULT i_uefiVarStoreAddVar(PCEFI_GUID pGuid, const char *pszVar, uint32_t fAttr, PRTVFSFILE phVfsFile);
+    HRESULT i_uefiVarStoreOpenVar(const char *pszVar, PRTVFSFILE phVfsFile);
+    HRESULT i_uefiVarStoreSetVar(PCEFI_GUID pGuid, const char *pszVar, uint32_t fAttr, const void *pvData, size_t cbData);
+    HRESULT i_uefiVarStoreQueryVar(const char *pszVar, void *pvData, size_t cbData);
+    HRESULT i_uefiSigDbAddSig(RTEFISIGDB hEfiSigDb, const void *pvData, size_t cbData, const com::Guid &aOwnerUuid, SignatureType_T enmSignatureType);
+    HRESULT i_uefiVarStoreAddSignatureToDbVec(PCEFI_GUID pGuid, const char *pszDb, const std::vector<BYTE> &aData,
+                                              const com::Guid &aOwnerUuid, SignatureType_T enmSignatureType, bool fRuntime = true);
+    HRESULT i_uefiVarStoreAddSignatureToDb(PCEFI_GUID pGuid, const char *pszDb, const void *pvData, size_t cbData,
+                                           const com::Guid &aOwnerUuid, SignatureType_T enmSignatureType, bool fRuntime = true);
+
+    struct Data;            // opaque data struct, defined in UefiVariableStoreImpl.cpp
+    Data *m;
+};
+
+#endif /* !MAIN_INCLUDED_UefiVariableStoreImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/UnattendedImpl.h b/src/VBox/Main/include/UnattendedImpl.h
new file mode 100644
index 00000000..de78c2bf
--- /dev/null
+++ b/src/VBox/Main/include/UnattendedImpl.h
@@ -0,0 +1,318 @@
+/* $Id: UnattendedImpl.h $ */
+/** @file
+ * Unattended class header
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_UnattendedImpl_h
+#define MAIN_INCLUDED_UnattendedImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/ostypes.h>
+#include <iprt/time.h>
+#include "UnattendedWrap.h"
+
+/* Forward declarations. */
+class UnattendedInstaller;
+struct UnattendedInstallationDisk;
+struct ControllerSlot;
+
+/**
+ * A data type to store image data which is read from intall.wim file.
+ * Currently relevant only for Windows OSs.
+ */
+struct WIMImage
+{
+    Utf8Str  mName;
+    Utf8Str  mVersion;
+    Utf8Str  mArch;
+    Utf8Str  mFlavor;
+    RTCList<RTCString, RTCString *> mLanguages;
+    Utf8Str  mDefaultLanguage;
+    uint32_t mImageIndex;
+    VBOXOSTYPE mOSType;
+    WIMImage() : mImageIndex(0), mOSType(VBOXOSTYPE_Unknown) { }
+    const Utf8Str &formatName(Utf8Str &r_strName) const;
+    VBOXOSTYPE mEnmOsType;
+};
+
+/**
+ * Class implementing the IUnattended interface.
+ *
+ * This class is instantiated on the request by IMachine::getUnattended.
+ */
+class ATL_NO_VTABLE Unattended
+    : public UnattendedWrap
+{
+public:
+    DECLARE_COMMON_CLASS_METHODS(Unattended)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT initUnattended(VirtualBox *aParent);
+    void uninit();
+
+    // public methods for internal purposes
+    Utf8Str const &i_getIsoPath() const;
+    Utf8Str const &i_getUser() const;
+    Utf8Str const &i_getPassword() const;
+    Utf8Str const &i_getFullUserName() const;
+    Utf8Str const &i_getProductKey() const;
+    Utf8Str const &i_getProxy() const;
+    Utf8Str const &i_getAdditionsIsoPath() const;
+    bool           i_getInstallGuestAdditions() const;
+    Utf8Str const &i_getValidationKitIsoPath() const;
+    bool           i_getInstallTestExecService() const;
+    Utf8Str const &i_getTimeZone() const;
+    PCRTTIMEZONEINFO i_getTimeZoneInfo() const;
+    Utf8Str const &i_getLocale() const;
+    Utf8Str const &i_getLanguage() const;
+    Utf8Str const &i_getCountry() const;
+    bool           i_isMinimalInstallation() const;
+    Utf8Str const &i_getHostname() const;
+    Utf8Str const &i_getAuxiliaryBasePath() const;
+    ULONG          i_getImageIndex() const;
+    Utf8Str const &i_getScriptTemplatePath() const;
+    Utf8Str const &i_getPostInstallScriptTemplatePath() const;
+    Utf8Str const &i_getPostInstallCommand() const;
+    /** The directory where the unattended install config and script is
+     * located, from the perspective of the running unattended install. */
+    Utf8Str const &i_getAuxiliaryInstallDir() const;
+    Utf8Str const &i_getExtraInstallKernelParameters() const;
+
+    bool           i_isRtcUsingUtc() const;
+    bool           i_isGuestOs64Bit() const;
+    bool           i_isFirmwareEFI() const;
+    Utf8Str const &i_getDetectedOSVersion();
+    bool           i_getAvoidUpdatesOverNetwork() const;
+
+private:
+    ComPtr<VirtualBox> const mParent;       /**< Strong reference to the parent object (VirtualBox/IMachine). */
+    ComPtr<Machine> mMachine;               /**< Strong reference to the machine object (Machine/IMachine). */
+    Guid            mMachineUuid;           /**< The machine UUID. */
+    RTNATIVETHREAD  mhThreadReconfigureVM;  /**< Set when reconfigureVM is running. */
+    Utf8Str         mStrGuestOsTypeId;      /**< Guest OS type ID (set by prepare). */
+    bool            mfRtcUseUtc;            /**< Copy of IMachine::RTCUseUTC (locking reasons). */
+    bool            mfGuestOs64Bit;         /**< 64-bit (true) or 32-bit guest OS (set by prepare). */
+    FirmwareType_T  menmFirmwareType;       /**< Firmware type BIOS/EFI (set by prepare). */
+    UnattendedInstaller *mpInstaller;       /**< The installer instance (set by prepare, deleted by done). */
+
+    /** @name Values of the IUnattended attributes.
+     * @{ */
+    Utf8Str         mStrUser;
+    Utf8Str         mStrPassword;
+    Utf8Str         mStrFullUserName;
+    Utf8Str         mStrProductKey;
+    Utf8Str         mStrIsoPath;
+    Utf8Str         mStrAdditionsIsoPath;
+    bool            mfInstallGuestAdditions;
+    bool            mfInstallTestExecService;
+    Utf8Str         mStrValidationKitIsoPath;
+    Utf8Str         mStrTimeZone;
+    PCRTTIMEZONEINFO mpTimeZoneInfo;
+    Utf8Str         mStrLocale;
+    Utf8Str         mStrLanguage;           /**< (only relevant for windows at the moment) */
+    Utf8Str         mStrCountry;
+    RTCList<RTCString, RTCString *> mPackageSelectionAdjustments;
+    Utf8Str         mStrHostname;
+    Utf8Str         mStrAuxiliaryBasePath;
+    bool            mfIsDefaultAuxiliaryBasePath;
+    ULONG           midxImage;
+    Utf8Str         mStrScriptTemplatePath;
+    Utf8Str         mStrPostInstallScriptTemplatePath;
+    Utf8Str         mStrPostInstallCommand;
+    Utf8Str         mStrExtraInstallKernelParameters;
+    Utf8Str         mStrProxy;
+
+    bool            mfDoneDetectIsoOS;         /**< Set by detectIsoOS(), cleared by setIsoPath(). */
+    Utf8Str         mStrDetectedOSTypeId;
+    Utf8Str         mStrDetectedOSVersion;
+    Utf8Str         mStrDetectedOSFlavor;
+    VBOXOSTYPE      mEnmOsType;
+    RTCList<RTCString, RTCString *> mDetectedOSLanguages; /**< (only relevant for windows at the moment) */
+    Utf8Str         mStrDetectedOSHints;
+    RTCList<WIMImage> mDetectedImages;
+    bool            mfAvoidUpdatesOverNetwork;
+    /** @} */
+
+    // wrapped IUnattended functions:
+
+    /**
+     * Checks what mStrIsoPath points to and sets the detectedOS* properties.
+     */
+    HRESULT detectIsoOS();
+
+    /**
+     * Prepare any data, environment, etc.
+     */
+    HRESULT prepare();
+
+    /**
+     * Prepare installation ISO/floppy.
+     */
+    HRESULT constructMedia();
+
+    /**
+     * Prepare a VM to run an unattended installation
+     */
+    HRESULT reconfigureVM();
+
+    /**
+     * Done with all media construction and VM configuration and stuff.
+     */
+    HRESULT done();
+
+    // wrapped IUnattended attributes:
+    HRESULT getIsoPath(com::Utf8Str &isoPath);
+    HRESULT setIsoPath(const com::Utf8Str &isoPath);
+    HRESULT getUser(com::Utf8Str &user);
+    HRESULT setUser(const com::Utf8Str &user);
+    HRESULT getPassword(com::Utf8Str &password);
+    HRESULT setPassword(const com::Utf8Str &password);
+    HRESULT getFullUserName(com::Utf8Str &user);
+    HRESULT setFullUserName(const com::Utf8Str &user);
+    HRESULT getProductKey(com::Utf8Str &productKey);
+    HRESULT setProductKey(const com::Utf8Str &productKey);
+    HRESULT getAdditionsIsoPath(com::Utf8Str &additionsIsoPath);
+    HRESULT setAdditionsIsoPath(const com::Utf8Str &additionsIsoPath);
+    HRESULT getInstallGuestAdditions(BOOL *installGuestAdditions);
+    HRESULT setInstallGuestAdditions(BOOL installGuestAdditions);
+    HRESULT getValidationKitIsoPath(com::Utf8Str &aValidationKitIsoPath);
+    HRESULT setValidationKitIsoPath(const com::Utf8Str &aValidationKitIsoPath);
+    HRESULT getInstallTestExecService(BOOL *aInstallTestExecService);
+    HRESULT setInstallTestExecService(BOOL aInstallTestExecService);
+    HRESULT getTimeZone(com::Utf8Str &aTimezone);
+    HRESULT setTimeZone(const com::Utf8Str &aTimezone);
+    HRESULT getLocale(com::Utf8Str &aLocale);
+    HRESULT setLocale(const com::Utf8Str &aLocale);
+    HRESULT getLanguage(com::Utf8Str &aLanguage);
+    HRESULT setLanguage(const com::Utf8Str &aLanguage);
+    HRESULT getCountry(com::Utf8Str &aCountry);
+    HRESULT setCountry(const com::Utf8Str &aCountry);
+    HRESULT getProxy(com::Utf8Str &aProxy);
+    HRESULT setProxy(const com::Utf8Str &aProxy);
+    HRESULT getPackageSelectionAdjustments(com::Utf8Str &aPackageSelectionAdjustments);
+    HRESULT setPackageSelectionAdjustments(const com::Utf8Str &aPackageSelectionAdjustments);
+    HRESULT getHostname(com::Utf8Str &aHostname);
+    HRESULT setHostname(const com::Utf8Str &aHostname);
+    HRESULT getAuxiliaryBasePath(com::Utf8Str &aAuxiliaryBasePath);
+    HRESULT setAuxiliaryBasePath(const com::Utf8Str &aAuxiliaryBasePath);
+    HRESULT getImageIndex(ULONG *index);
+    HRESULT setImageIndex(ULONG index);
+    HRESULT getMachine(ComPtr<IMachine> &aMachine);
+    HRESULT setMachine(const ComPtr<IMachine> &aMachine);
+    HRESULT getScriptTemplatePath(com::Utf8Str &aScriptTemplatePath);
+    HRESULT setScriptTemplatePath(const com::Utf8Str &aScriptTemplatePath);
+    HRESULT getPostInstallScriptTemplatePath(com::Utf8Str &aPostInstallScriptTemplatePath);
+    HRESULT setPostInstallScriptTemplatePath(const com::Utf8Str &aPostInstallScriptTemplatePath);
+    HRESULT getPostInstallCommand(com::Utf8Str &aPostInstallCommand);
+    HRESULT setPostInstallCommand(const com::Utf8Str &aPostInstallCommand);
+    HRESULT getExtraInstallKernelParameters(com::Utf8Str &aExtraInstallKernelParameters);
+    HRESULT setExtraInstallKernelParameters(const com::Utf8Str &aExtraInstallKernelParameters);
+    HRESULT getDetectedOSTypeId(com::Utf8Str &aDetectedOSTypeId);
+    HRESULT getDetectedOSVersion(com::Utf8Str &aDetectedOSVersion);
+    HRESULT getDetectedOSLanguages(com::Utf8Str &aDetectedOSLanguages);
+    HRESULT getDetectedOSFlavor(com::Utf8Str &aDetectedOSFlavor);
+    HRESULT getDetectedOSHints(com::Utf8Str &aDetectedOSHints);
+    HRESULT getDetectedImageNames(std::vector<com::Utf8Str> &aDetectedImageNames);
+    HRESULT getDetectedImageIndices(std::vector<ULONG> &aDetectedImageIndices);
+    HRESULT getIsUnattendedInstallSupported(BOOL *aIsUnattendedInstallSupported);
+    HRESULT getAvoidUpdatesOverNetwork(BOOL *aAvoidUpdatesOverNetwork);
+    HRESULT setAvoidUpdatesOverNetwork(BOOL aAvoidUpdatesOverNetwork);
+    //internal functions
+
+    /**
+     * Worker for detectIsoOs().
+     *
+     * @returns COM status code.
+     * @retval  S_OK if detected.
+     * @retval  S_FALSE if not detected.
+     *
+     * @param   hVfsIso     The ISO file system handle.
+     */
+    HRESULT i_innerDetectIsoOS(RTVFS hVfsIso);
+    typedef union DETECTBUFFER
+    {
+        char        sz[4096];
+        char        ach[4096];
+        uint8_t     ab[4096];
+        uint32_t    au32[1024];
+    } DETECTBUFFER;
+    HRESULT i_innerDetectIsoOSWindows(RTVFS hVfsIso, DETECTBUFFER *puBuf);
+    HRESULT i_innerDetectIsoOSLinux(RTVFS hVfsIso, DETECTBUFFER *puBuf);
+    HRESULT i_innerDetectIsoOSLinuxFedora(RTVFS hVfsIso, DETECTBUFFER *puBuf, char *pszVolId);
+    HRESULT i_innerDetectIsoOSOs2(RTVFS hVfsIso, DETECTBUFFER *puBuf);
+    HRESULT i_innerDetectIsoOSFreeBsd(RTVFS hVfsIso, DETECTBUFFER *puBuf);
+
+    /**
+     * Worker for reconfigureVM().
+     * The caller makes sure to close the session whatever happens.
+     */
+    HRESULT i_innerReconfigureVM(AutoMultiWriteLock2 &rAutoLock, StorageBus_T enmRecommendedStorageBus,
+                                 ComPtr<IMachine> const &rPtrSessionMachine);
+    HRESULT i_reconfigureFloppy(com::SafeIfaceArray<IStorageController> &rControllers,
+                                std::vector<UnattendedInstallationDisk> &rVecInstallatationDisks,
+                                ComPtr<IMachine> const &rPtrSessionMachine,
+                                AutoMultiWriteLock2 &rAutoLock);
+    HRESULT i_reconfigureIsos(com::SafeIfaceArray<IStorageController> &rControllers,
+                              std::vector<UnattendedInstallationDisk> &rVecInstallatationDisks,
+                              ComPtr<IMachine> const &rPtrSessionMachine,
+                              AutoMultiWriteLock2 &rAutoLock, StorageBus_T enmRecommendedStorageBus);
+
+    /**
+     * Adds all free slots on the controller to @a rOutput.
+     */
+    HRESULT i_findOrCreateNeededFreeSlots(const Utf8Str &rStrControllerName, StorageBus_T enmStorageBus,
+                                          ComPtr<IMachine> const &rPtrSessionMachine, uint32_t cSlotsNeeded,
+                                          std::list<ControllerSlot> &rDvdSlots);
+
+    /**
+     * Attach to VM a disk
+     */
+    HRESULT i_attachImage(UnattendedInstallationDisk const *pImage, ComPtr<IMachine> const &rPtrSessionMachine,
+                          AutoMultiWriteLock2 &rLock);
+
+    /*
+     * Wrapper functions
+     */
+
+    /**
+     * Check whether guest is 64bit platform or not
+     */
+    bool i_isGuestOSArchX64(Utf8Str const &rStrGuestOsTypeId);
+
+    /**
+     * Updates the detected attributes when the image index or image list changes.
+     *
+     * @returns true if we've got all necessary stuff for a successful detection.
+     */
+    bool i_updateDetectedAttributeForImage(WIMImage const &rImage);
+
+};
+
+#endif /* !MAIN_INCLUDED_UnattendedImpl_h */
diff --git a/src/VBox/Main/include/UnattendedInstaller.h b/src/VBox/Main/include/UnattendedInstaller.h
new file mode 100644
index 00000000..536bdcc9
--- /dev/null
+++ b/src/VBox/Main/include/UnattendedInstaller.h
@@ -0,0 +1,932 @@
+/* $Id: UnattendedInstaller.h $ */
+/** @file
+ * UnattendedInstaller class header
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_UnattendedInstaller_h
+#define MAIN_INCLUDED_UnattendedInstaller_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "UnattendedScript.h"
+
+/* Forward declarations */
+class Unattended;
+class UnattendedInstaller;
+class BaseTextScript;
+
+
+/**
+ * The abstract UnattendedInstaller class declaration
+ *
+ * The class is intended to service a new VM that this VM will be able to
+ * execute an unattended installation
+ */
+class UnattendedInstaller : public RTCNonCopyable
+{
+/*data*/
+protected:
+    /** Main unattended installation script. */
+    UnattendedScriptTemplate    mMainScript;
+    /** Full path to the main template file (set by initInstaller). */
+    Utf8Str                     mStrMainScriptTemplate;
+
+    /** Post installation (shell) script. */
+    UnattendedScriptTemplate    mPostScript;
+    /** Full path to the post template file (set by initInstaller). */
+    Utf8Str                     mStrPostScriptTemplate;
+
+    /** Pointer to the parent object.
+     * We use this for setting errors and querying attributes. */
+    Unattended                 *mpParent;
+    /** The path of the extra ISO image we create (set by initInstaller).
+     * This is only valid when isAdditionsIsoNeeded() returns true. */
+    Utf8Str                     mStrAuxiliaryIsoFilePath;
+    /** The path of the extra floppy image we create (set by initInstaller)
+     * This is only valid when isAdditionsFloppyNeeded() returns true. */
+    Utf8Str                     mStrAuxiliaryFloppyFilePath;
+    /** The boot device. */
+    DeviceType_T const          meBootDevice;
+    /** Default extra install kernel parameters (set by constructor).
+     * This can be overridden by the extraInstallKernelParameters attribute of
+     * IUnattended. */
+    Utf8Str                     mStrDefaultExtraInstallKernelParameters;
+    /** The directory of the post install script in the unattended install
+     * environment, i.e. when it gets started by the unattended installer
+     * of the respective guest OS. */
+    Utf8Str                     mStrAuxiliaryInstallDir;
+
+private:
+    UnattendedInstaller(); /* no default constructors */
+
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedInstaller)
+
+    /**
+     * Regular constructor.
+     *
+     * @param   pParent                     The parent object.  Used for setting
+     *                                      errors and querying attributes.
+     * @param   pszMainScriptTemplateName   The name of the template file (no path)
+     *                                      for the main unattended installer
+     *                                      script.
+     * @param   pszPostScriptTemplateName   The name of the template file (no path)
+     *                                      for the post installation script.
+     * @param   pszMainScriptFilename       The main unattended installer script
+     *                                      filename (on aux media).
+     * @param   pszPostScriptFilename       The post installation script filename
+     *                                      (on aux media).
+     * @param   enmBootDevice               The boot device type.
+     */
+    UnattendedInstaller(Unattended *pParent,
+                        const char *pszMainScriptTemplateName, const char *pszPostScriptTemplateName,
+                        const char *pszMainScriptFilename,     const char *pszPostScriptFilename,
+                        DeviceType_T enmBootDevice = DeviceType_DVD);
+    virtual ~UnattendedInstaller();
+
+    /**
+     * Instantiates the appropriate child class.
+     *
+     * @returns Pointer to the new instance, NULL if no appropriate installer.
+     * @param   enmDetectedOSType       The detected guest OS type value.
+     * @param   strDetectedOSType       The detected guest OS type string
+     * @param   strDetectedOSVersion    The detected guest OS version.
+     * @param   strDetectedOSFlavor     The detected guest OS flavor.
+     * @param   strDetectedOSHints      Hints about the detected guest OS.
+     * @param   pParent                 The parent object.  Used for setting errors
+     *                                  and querying attributes.
+     * @throws  std::bad_alloc
+     */
+    static UnattendedInstaller *createInstance(VBOXOSTYPE enmDetectedOSType, const Utf8Str &strDetectedOSType,
+                                               const Utf8Str &strDetectedOSVersion, const Utf8Str &strDetectedOSFlavor,
+                                               const Utf8Str &strDetectedOSHints, Unattended *pParent);
+
+    /**
+     * Initialize the installer.
+     *
+     * @note This is called immediately after instantiation and the caller will
+     *       always destroy the unattended installer instance on failure, so it
+     *       is not necessary to keep track of whether this succeeded or not.
+     */
+    virtual HRESULT initInstaller();
+
+#if 0 /* These are now in the AUX VISO. */
+    /**
+     * Whether the VBox Guest Additions ISO is needed or not.
+     *
+     * The default implementation always returns false when a VISO is used, see
+     * UnattendedInstaller::addFilesToAuxVisoVectors.
+     */
+    virtual bool isAdditionsIsoNeeded() const;
+
+    /**
+     * Whether the VBox validation kit ISO is needed or not.
+     *
+     * The default implementation always returns false when a VISO is used, see
+     * UnattendedInstaller::addFilesToAuxVisoVectors.
+     */
+    virtual bool isValidationKitIsoNeeded() const;
+#endif
+
+    /**
+     * Indicates whether an original installation ISO is needed or not.
+     */
+    virtual bool isOriginalIsoNeeded() const        { return true; }
+
+    /**
+     * Indicates whether a floppy image is needed or not.
+     */
+    virtual bool isAuxiliaryFloppyNeeded() const    { return false; }
+
+    /**
+     * Indicates whether an additional or replacement ISO image is needed or not.
+     */
+    virtual bool isAuxiliaryIsoNeeded() const;
+
+    /**
+     * Indicates whether we should boot from the auxiliary ISO image.
+     *
+     * Will boot from installation ISO if false.
+     */
+    virtual bool bootFromAuxiliaryIso() const       { return isAuxiliaryIsoNeeded(); }
+
+    /**
+     * Indicates whether a the auxiliary ISO is a .viso-file rather than an
+     * .iso-file.
+     *
+     * Different worker methods are used depending on the return value.  A
+     * .viso-file is generally only used when the installation media needs to
+     * be remastered with small changes and additions.
+     */
+    virtual bool isAuxiliaryIsoIsVISO() const       { return true; }
+
+    /*
+     * Getters
+     */
+    DeviceType_T   getBootableDeviceType() const        { return meBootDevice; }
+    const Utf8Str &getTemplateFilePath() const          { return mStrMainScriptTemplate; }
+    const Utf8Str &getPostTemplateFilePath() const      { return mStrPostScriptTemplate; }
+    const Utf8Str &getAuxiliaryIsoFilePath() const      { return mStrAuxiliaryIsoFilePath; }
+    const Utf8Str &getAuxiliaryFloppyFilePath() const   { return mStrAuxiliaryFloppyFilePath; }
+    const Utf8Str &getDefaultExtraInstallKernelParameters() const { return mStrDefaultExtraInstallKernelParameters; }
+    const Utf8Str &getAuxiliaryInstallDir() const       { return mStrAuxiliaryInstallDir; }
+
+    /*
+     * Setters
+     */
+    void setTemplatePath(const Utf8Str& data); /**< @todo r=bird: This is confusing as heck. Dir for a while, then it's a file. Not a comment about it. Brilliant. */
+
+    /**
+     * Prepares the unattended scripts, does all but write them to the installation
+     * media.
+     */
+    HRESULT prepareUnattendedScripts();
+
+    /**
+     * Prepares the media - floppy image, ISO image.
+     *
+     * This method calls prepareAuxFloppyImage() and prepareAuxIsoImage(), child
+     * classes may override these methods or methods they call.
+     *
+     * @returns COM status code.
+     * @param   fOverwrite      Whether to overwrite media files or fail if they
+     *                          already exist.
+     */
+    HRESULT prepareMedia(bool fOverwrite = true);
+
+protected:
+    /**
+     * Prepares (creates) the auxiliary floppy image.
+     *
+     * This is called by the base class prepareMedia() when
+     * isAuxiliaryFloppyNeeded() is true. The base class implementation puts the
+     * edited unattended script onto it.
+     */
+    HRESULT prepareAuxFloppyImage(bool fOverwrite);
+
+    /**
+     * Creates and formats (FAT12) a floppy image.
+     *
+     * This can be overridden to do more preparation work or/and create a different
+     * sized floppy.
+     *
+     * @returns COM status code.
+     * @param   pszFilename     The path to the image file.
+     * @param   fOverwrite      Whether to overwrite the file.
+     * @param   phVfsFile       Where to return a read-writable handle to the newly
+     *                          created image.
+     */
+    virtual HRESULT newAuxFloppyImage(const char *pszFilename, bool fOverwrite, PRTVFSFILE phVfsFile);
+
+    /**
+     * Copies files to the auxiliary floppy image.
+     *
+     * The base class implementation copies the main and post scripts to the root of
+     * the floppy using the default script names.  Child classes may override this
+     * to add additional or different files.
+     *
+     * @returns COM status code.
+     * @param   hVfs            The floppy image VFS handle.
+     */
+    virtual HRESULT copyFilesToAuxFloppyImage(RTVFS hVfs);
+
+    /**
+     * Adds the given script to the root of the floppy image under the default
+     * script filename.
+     *
+     * @returns COM status code.
+     * @param   pEditor         The script to add.
+     * @param   hVfs            The VFS to add it to.
+     */
+    HRESULT addScriptToFloppyImage(BaseTextScript *pEditor, RTVFS hVfs);
+
+    /**
+     * Copy an arbritrary file onto the floopy image.
+     *
+     * @returns COM status code.
+     * @param   hVfs            The VFS to add it to.
+     * @param   pszSrc          The source filename.
+     * @param   pszDst          The destination filename (on @a hVfs).
+     */
+    HRESULT addFileToFloppyImage(RTVFS hVfs, const char *pszSrc, const char *pszDst);
+
+    /**
+     * Prepares (creates) the auxiliary ISO image.
+     *
+     * This is called by the base class prepareMedia() when isAuxiliaryIsoNeeded()
+     * is true.  The base class implementation puts the edited unattended script
+     * onto it.
+     */
+    virtual HRESULT prepareAuxIsoImage(bool fOverwrite);
+
+    /**
+     * Opens the installation ISO image.
+     *
+     * @returns COM status code.
+     * @param   phVfsIso        Where to return the VFS handle for the ISO.
+     * @param   fFlags          RTFSISO9660_F_XXX flags to pass to the
+     *                          RTFsIso9660VolOpen API.
+     */
+    virtual HRESULT openInstallIsoImage(PRTVFS phVfsIso, uint32_t fFlags = 0);
+
+    /**
+     * Creates and configures the ISO maker instance.
+     *
+     * This can be overridden to set configure options.
+     *
+     * @returns COM status code.
+     * @param   phIsoMaker      Where to return the ISO maker.
+     */
+    virtual HRESULT newAuxIsoImageMaker(PRTFSISOMAKER phIsoMaker);
+
+    /**
+     * Adds files to the auxiliary ISO image maker.
+     *
+     * The base class implementation copies just the mMainScript and mPostScript
+     * files to root directory using the default filenames.
+     *
+     * @returns COM status code.
+     * @param   hIsoMaker       The ISO maker handle.
+     * @param   hVfsOrgIso      The VFS handle to the original ISO in case files
+     *                          needs to be added from it.
+     */
+    virtual HRESULT addFilesToAuxIsoImageMaker(RTFSISOMAKER hIsoMaker, RTVFS hVfsOrgIso);
+
+    /**
+     * Adds the given script to the ISO maker.
+     *
+     * @returns COM status code.
+     * @param   pEditor         The script to add.
+     * @param   hIsoMaker       The ISO maker to add it to.
+     * @param   pszDstFilename  The file name (w/ path) to add it under.  If NULL,
+     *                          the default script filename is used to add it to the
+     *                          root.
+     */
+    HRESULT addScriptToIsoMaker(BaseTextScript *pEditor, RTFSISOMAKER hIsoMaker, const char *pszDstFilename = NULL);
+
+    /**
+     * Writes the ISO image to disk.
+     *
+     * @returns COM status code.
+     * @param   hIsoMaker       The ISO maker handle.
+     * @param   pszFilename     The filename.
+     * @param   fOverwrite      Whether to overwrite the destination file or not.
+     */
+    HRESULT finalizeAuxIsoImage(RTFSISOMAKER hIsoMaker, const char *pszFilename, bool fOverwrite);
+
+    /**
+     * Adds files to the .viso-file vectors.
+     *
+     * The base class implementation adds the script from mAlg, additions ISO
+     * content to '/vboxadditions', and validation kit ISO to '/vboxvalidationkit'.
+     *
+     * @returns COM status code.
+     * @param   rVecArgs        The ISO maker argument list that will be turned into
+     *                          a .viso-file.
+     * @param   rVecFiles       The list of files we've created.  This is for
+     *                          cleaning up at the end.
+     * @param   hVfsOrgIso      The VFS handle to the original ISO in case files
+     *                          needs to be added from it.
+     * @param   fOverwrite      Whether to overwrite files or not.
+     */
+    virtual HRESULT addFilesToAuxVisoVectors(RTCList<RTCString> &rVecArgs, RTCList<RTCString> &rVecFiles,
+                                             RTVFS hVfsOrgIso, bool fOverwrite);
+
+    /**
+     * Saves the given script to disk and adds it to the .viso-file vectors.
+     *
+     * @returns COM status code.
+     * @param   pEditor         The script to add.
+     * @param   rVecArgs        The ISO maker argument list that will be turned into
+     *                          a .viso-file.
+     * @param   rVecFiles       The list of files we've created.  This is for
+     *                          cleaning up at the end.
+     * @param   fOverwrite      Whether to overwrite files or not.
+     */
+    HRESULT addScriptToVisoVectors(BaseTextScript *pEditor, RTCList<RTCString> &rVecArgs,
+                                   RTCList<RTCString> &rVecFiles, bool fOverwrite);
+
+    /**
+     * Writes out the .viso-file to disk.
+     *
+     * @returns COM status code.
+     * @param   rVecArgs        The ISO maker argument list to write out.
+     * @param   pszFilename     The filename.
+     * @param   fOverwrite      Whether to overwrite the destination file or not.
+     */
+    HRESULT finalizeAuxVisoFile(RTCList<RTCString> const &rVecArgs, const char *pszFilename, bool fOverwrite);
+
+    /**
+     * Loads @a pszFilename from @a hVfsOrgIso into @a pEditor and parses it.
+     *
+     * @returns COM status code.
+     * @param   hVfsOrgIso      The handle to the original installation ISO.
+     * @param   pszFilename     The filename to open and load from the ISO.
+     * @param   pEditor         The editor instance to load the file into and
+     *                          do the parseing with.
+     */
+    HRESULT loadAndParseFileFromIso(RTVFS hVfsOrgIso, const char *pszFilename, AbstractScript *pEditor);
+};
+
+
+/**
+ * Windows installer, for versions up to xp 64 / w2k3.
+ */
+class UnattendedWindowsSifInstaller : public UnattendedInstaller
+{
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedWindowsSifInstaller)
+
+    UnattendedWindowsSifInstaller(Unattended *pParent)
+        : UnattendedInstaller(pParent,
+                              "win_nt5_unattended.sif", "win_postinstall.cmd",
+                              "WINNT.SIF",              "VBOXPOST.CMD")
+    {
+        Assert(isOriginalIsoNeeded()); Assert(isAuxiliaryFloppyNeeded()); Assert(isAuxiliaryIsoIsVISO()); Assert(!bootFromAuxiliaryIso());
+        mStrAuxiliaryInstallDir = "A:\\";
+    }
+    ~UnattendedWindowsSifInstaller()        {}
+
+    bool isAuxiliaryFloppyNeeded() const    { return true; }
+    bool bootFromAuxiliaryIso() const       { return false; }
+
+};
+
+/**
+ * Windows installer, for versions starting with Vista.
+ */
+class UnattendedWindowsXmlInstaller : public UnattendedInstaller
+{
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedWindowsXmlInstaller)
+
+    UnattendedWindowsXmlInstaller(Unattended *pParent)
+        : UnattendedInstaller(pParent,
+                              "win_nt6_unattended.xml", "win_postinstall.cmd",
+                              "autounattend.xml",       "VBOXPOST.CMD")
+    {
+        Assert(isOriginalIsoNeeded()); Assert(isAuxiliaryFloppyNeeded() || isAuxiliaryIsoNeeded()); Assert(isAuxiliaryIsoIsVISO()); Assert(!bootFromAuxiliaryIso());
+        if (isAuxiliaryFloppyNeeded())
+            mStrAuxiliaryInstallDir = "A:\\";
+        else if (bootFromAuxiliaryIso())
+            mStrAuxiliaryInstallDir = "D:\\";
+        else
+            mStrAuxiliaryInstallDir = "E:\\";
+    }
+    ~UnattendedWindowsXmlInstaller()      {}
+
+    bool isAuxiliaryFloppyNeeded() const    { return !mpParent->i_isFirmwareEFI(); }
+    bool isAuxiliaryIsoNeeded() const       { return UnattendedInstaller::isAuxiliaryIsoNeeded() || mpParent->i_isFirmwareEFI(); }
+    bool isAuxiliaryIsoIsVISO() const       { return true; }
+    bool bootFromAuxiliaryIso() const       { return false; }
+};
+
+
+/**
+ * OS/2 installer.
+ */
+class UnattendedOs2Installer : public UnattendedInstaller
+{
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedOs2Installer)
+
+    UnattendedOs2Installer(Unattended *pParent, Utf8Str const &rStrHints);
+    ~UnattendedOs2Installer()                           {}
+
+    /* Remaster original ISO with auxiliary floppy used for el torito floppy emulation: */
+    bool isOriginalIsoNeeded()     const RT_OVERRIDE    { return false; }
+    bool isAuxiliaryFloppyNeeded() const RT_OVERRIDE    { return true; }
+    bool isAuxiliaryIsoNeeded()    const RT_OVERRIDE    { return true; }
+
+protected:
+    HRESULT replaceAuxFloppyImageBootSector(RTVFSFILE hVfsFile) RT_NOEXCEPT;
+    HRESULT newAuxFloppyImage(const char *pszFilename, bool fOverwrite, PRTVFSFILE phVfsFile) RT_OVERRIDE;
+    HRESULT copyFilesToAuxFloppyImage(RTVFS hVfs) RT_OVERRIDE;
+    HRESULT addFilesToAuxVisoVectors(RTCList<RTCString> &rVecArgs, RTCList<RTCString> &rVecFiles,
+                                     RTVFS hVfsOrgIso, bool fOverwrite) RT_OVERRIDE;
+
+    HRESULT splitResponseFile() RT_NOEXCEPT;
+
+    /**
+     * Splits up the given file into sub-files and writes them out with the auxilary
+     * path base as prefix.
+     *
+     * The source file contains @@VBOX_SPLITTER_START[filename]@@ and
+     * @@VBOX_SPLITTER_END[filename]@@  markup that is used to split it up.  Any
+     * text between END and START tags are ignored and can be used for comments.
+     *
+     * @returns COM status code (error info set).
+     * @param   pszFileToSplit      The name of the file to split.
+     * @param   rVecSplitFiles      Vector where names of the sub-files are appended
+     *                              (without any path or prefix).
+     */
+    HRESULT splitFile(const char *pszFileToSplit, RTCList<RTCString> &rVecSplitFiles) RT_NOEXCEPT;
+
+    /**
+     * Splits up the given editor output into sub-files and writes them out with the
+     * auxilary path base as prefix.
+     *
+     * The source file contains @@VBOX_SPLITTER_START[filename]@@ and
+     * @@VBOX_SPLITTER_END[filename]@@  markup that is used to split it up.  Any
+     * text between END and START tags are ignored and can be used for comments.
+     *
+     * @returns COM status code (error info set).
+     * @param   pEditor             The editor which output should be split.
+     * @param   rVecSplitFiles      Vector where names of the sub-files are appended
+     *                              (without any path or prefix).
+     */
+    HRESULT splitFile(BaseTextScript *pEditor, RTCList<RTCString> &rVecSplitFiles) RT_NOEXCEPT;
+
+    HRESULT splitFileInner(const char *pszFileToSplit, RTCList<RTCString> &rVecSplitFiles,
+                           const char *pszSrc, size_t cbLeft) RT_NOEXCEPT;
+
+    static int patchTestCfg(uint8_t *pbFile, size_t cbFile, const char *pszFilename, UnattendedOs2Installer *pThis);
+    static int patchOs2Ldr(uint8_t *pbFile, size_t cbFile, const char *pszFilename, UnattendedOs2Installer *pThis);
+
+    /** The OS2SE20.SRC path ("\\OS2IMAGES"). */
+    Utf8Str mStrOs2Images;
+    /** Files split out from os2_response_files.rsp (bare filenames, no paths). */
+    RTCList<RTCString> mVecSplitFiles;
+};
+
+
+
+/**
+ * Base class for the unattended linux installers.
+ */
+class UnattendedLinuxInstaller : public UnattendedInstaller
+{
+protected:
+    /** Array of linux parameter patterns that should be removed by editIsoLinuxCfg.
+     * The patterns are proceed by RTStrSimplePatternNMatch. */
+    RTCList<RTCString, RTCString *> mArrStrRemoveInstallKernelParameters;
+
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedLinuxInstaller)
+
+    UnattendedLinuxInstaller(Unattended *pParent,
+                             const char *pszMainScriptTemplateName, const char *pszPostScriptTemplateName,
+                             const char *pszMainScriptFilename,     const char *pszPostScriptFilename = "vboxpostinstall.sh")
+        : UnattendedInstaller(pParent,
+                              pszMainScriptTemplateName, pszPostScriptTemplateName,
+                              pszMainScriptFilename,     pszPostScriptFilename) {}
+    ~UnattendedLinuxInstaller() {}
+
+    bool isAuxiliaryIsoNeeded() const       { return true; }
+
+protected:
+    /**
+     * Performs basic edits on a isolinux.cfg file.
+     *
+     * @returns COM status code
+     * @param   pEditor               Editor with the isolinux.cfg file loaded and parsed.
+     */
+    virtual HRESULT editIsoLinuxCfg(GeneralTextScript *pEditor);
+    /**
+     * Performs basic common edits on a isolinux.cfg and menu configuration file(s) (txt.cfg or menu.cfg etc).
+     *
+     * @returns COM status code
+     * @param   pEditor         Editor with the isolinux.cfg file loaded and parsed.
+     */
+    virtual HRESULT editIsoLinuxCommon(GeneralTextScript *pEditor);
+};
+
+
+/**
+ * Debian installer.
+ *
+ * This will remaster the orignal ISO and therefore be producing a .viso-file.
+ */
+class UnattendedDebianInstaller : public UnattendedLinuxInstaller
+{
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedDebianInstaller)
+
+    UnattendedDebianInstaller(Unattended *pParent,
+                              const char *pszMainScriptTemplateName = "debian_preseed.cfg",
+                              const char *pszPostScriptTemplateName = "debian_postinstall.sh",
+                              const char *pszMainScriptFilename     = "preseed.cfg")
+        : UnattendedLinuxInstaller(pParent, pszMainScriptTemplateName, pszPostScriptTemplateName, pszMainScriptFilename)
+    {
+        Assert(!isOriginalIsoNeeded()); Assert(isAuxiliaryIsoNeeded());
+        Assert(!isAuxiliaryFloppyNeeded()); Assert(isAuxiliaryIsoIsVISO());
+        mStrDefaultExtraInstallKernelParameters.setNull();
+        mStrDefaultExtraInstallKernelParameters += " auto=true";
+        mStrDefaultExtraInstallKernelParameters.append(" preseed/file=/cdrom/").append(pszMainScriptFilename);
+        mStrDefaultExtraInstallKernelParameters += " priority=critical";
+        mStrDefaultExtraInstallKernelParameters += " quiet";
+        mStrDefaultExtraInstallKernelParameters += " splash";
+        mStrDefaultExtraInstallKernelParameters += " noprompt";  /* no questions about things like CD/DVD ejections */
+        mStrDefaultExtraInstallKernelParameters += " noshell";   /* No shells on VT1-3 (debian, not ubuntu). */
+        mStrDefaultExtraInstallKernelParameters += " automatic-ubiquity";   // ubiquity
+        // the following can probably go into the preseed.cfg:
+        mStrDefaultExtraInstallKernelParameters.append(" debian-installer/locale=").append(pParent->i_getLocale());
+        mStrDefaultExtraInstallKernelParameters += " keyboard-configuration/layoutcode=us";
+        mStrDefaultExtraInstallKernelParameters += " languagechooser/language-name=English"; /** @todo fixme */
+        mStrDefaultExtraInstallKernelParameters.append(" localechooser/supported-locales=").append(pParent->i_getLocale()).append(".UTF-8");
+        mStrDefaultExtraInstallKernelParameters.append(" countrychooser/shortlist=").append(pParent->i_getCountry()); // ubiquity?
+        mStrDefaultExtraInstallKernelParameters += " --";
+    }
+    ~UnattendedDebianInstaller()            {}
+
+    bool isOriginalIsoNeeded() const        { return false; }
+
+protected:
+    HRESULT addFilesToAuxVisoVectors(RTCList<RTCString> &rVecArgs, RTCList<RTCString> &rVecFiles,
+                                     RTVFS hVfsOrgIso, bool fOverwrite);
+    /**
+     * Performs basic edits on menu configuration file(s) of isolinux (txt.cfg or menu.cfg etc).
+     *
+     * @returns COM status code
+     * @param   pEditor                  Editor with the menu config. file loaded and parsed.
+     */
+    HRESULT editDebianMenuCfg(GeneralTextScript *pEditor);
+    /**
+     * Performs basic edits on grub configuration file (grub.cfg).
+     *
+     * @returns COM status code
+     * @param   pEditor                 Editor with the grub.cfg file loaded and parsed.
+     */
+    HRESULT editDebianGrubCfg(GeneralTextScript *pEditor);
+
+    /**
+     * Performs basic edits on a isolinux.cfg file.
+     *
+     * @returns COM status code
+     * @param   pEditor               Editor with the isolinux.cfg file loaded and parsed.
+     * @param   pszMenuConfigFileName Name of the menu config file to include in isolinux.txt. On Debians (at least)
+                                      it includes the kernel command line with our preseed file and command line argument.
+     */
+    virtual HRESULT editIsoLinuxCfg(GeneralTextScript *pEditor, const char *pszMenuConfigFileName);
+
+private:
+
+    /**
+     * Tries to set label name of a label line.
+     *
+     * @returns                 true if label line is found and label name can be set.
+     * @param   pEditor         Editor with the menu configuration file loaded and parsed.
+     * @param   vecLineNumbers  Indices of the label lines (within pEditor data).
+     * @param   pszKeyWord      The keyword searched within the original label name.
+     * @param   pszNewLabelName The new name of the label.
+     */
+    bool modifyLabelLine(GeneralTextScript *pEditor, const std::vector<size_t> &vecLineNumbers,
+                         const char *pszKeyWord, const char *pszNewLabelName);
+};
+
+
+/**
+ * Ubuntu installer (same as debian, except for the template).
+ */
+class UnattendedUbuntuInstaller : public UnattendedDebianInstaller
+{
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedUbuntuInstaller)
+
+    UnattendedUbuntuInstaller(Unattended *pParent)
+        : UnattendedDebianInstaller(pParent, "ubuntu_preseed.cfg")
+    { Assert(!isOriginalIsoNeeded()); Assert(isAuxiliaryIsoNeeded()); Assert(!isAuxiliaryFloppyNeeded()); Assert(isAuxiliaryIsoIsVISO()); }
+    ~UnattendedUbuntuInstaller() {}
+};
+
+/**
+ * RHEL installer.
+ *
+ * This serves as a base for the kickstart based installers.
+ */
+class UnattendedRhelInstaller : public UnattendedLinuxInstaller
+{
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedRhelInstaller)
+
+    UnattendedRhelInstaller(Unattended *pParent,
+                             const char *pszMainScriptTemplateName,
+                             const char *pszPostScriptTemplateName,
+                             const char *pszMainScriptFilename)
+        : UnattendedLinuxInstaller(pParent, pszMainScriptTemplateName, pszPostScriptTemplateName, pszMainScriptFilename)
+    {}
+    ~UnattendedRhelInstaller() {}
+
+    bool isAuxiliaryIsoIsVISO()             { return true; }
+    bool isOriginalIsoNeeded() const        { return false; }
+
+protected:
+    HRESULT addFilesToAuxVisoVectors(RTCList<RTCString> &rVecArgs, RTCList<RTCString> &rVecFiles,
+                                     RTVFS hVfsOrgIso, bool fOverwrite);
+};
+
+/**
+ * RHEL 6 installer.
+ *
+ */
+class UnattendedRhel6Installer : public UnattendedRhelInstaller
+{
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedRhel6Installer)
+
+    UnattendedRhel6Installer(Unattended *pParent,
+                             const char *pszMainScriptTemplateName = "redhat67_ks.cfg",
+                             const char *pszPostScriptTemplateName = "redhat_postinstall.sh",
+                             const char *pszMainScriptFilename     = "ks.cfg")
+        : UnattendedRhelInstaller(pParent, pszMainScriptTemplateName, pszPostScriptTemplateName, pszMainScriptFilename)
+    {
+        Assert(!isOriginalIsoNeeded()); Assert(isAuxiliaryIsoNeeded());
+        Assert(!isAuxiliaryFloppyNeeded()); Assert(isAuxiliaryIsoIsVISO());
+        mStrDefaultExtraInstallKernelParameters.assign(" ks=cdrom:/").append(pszMainScriptFilename).append(' ');
+        mArrStrRemoveInstallKernelParameters.append("rd.live.check"); /* Disables the checkisomd5 step. Required for VISO. */
+    }
+    ~UnattendedRhel6Installer() {}
+};
+
+/**
+ * RHEL 7 installer (same as RHEL 6).
+ * The class was added for better handling any possible subtle difference between RHEL6 and RHEL7.
+ */
+class UnattendedRhel7Installer : public UnattendedRhel6Installer
+{
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedRhel7Installer)
+
+    UnattendedRhel7Installer(Unattended *pParent)
+        : UnattendedRhel6Installer(pParent)
+    { Assert(!isOriginalIsoNeeded()); Assert(isAuxiliaryIsoNeeded()); Assert(!isAuxiliaryFloppyNeeded()); Assert(isAuxiliaryIsoIsVISO()); }
+
+    UnattendedRhel7Installer(Unattended *pParent,
+                             const char *pszMainScriptTemplateName,
+                             const char *pszPostScriptTemplateName,
+                             const char *pszMainScriptFilename)
+        : UnattendedRhel6Installer(pParent, pszMainScriptTemplateName, pszPostScriptTemplateName, pszMainScriptFilename)
+    { Assert(!isOriginalIsoNeeded()); Assert(isAuxiliaryIsoNeeded()); Assert(!isAuxiliaryFloppyNeeded()); Assert(isAuxiliaryIsoIsVISO()); }
+    ~UnattendedRhel7Installer() {}
+};
+
+
+/**
+ * RHEL 8 installer (same as RHEL 7).
+ * The class was added for better handling any possible subtle difference between RHEL7 and RHEL8.
+ */
+class UnattendedRhel8Installer : public UnattendedRhel7Installer
+{
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedRhel8Installer)
+
+    UnattendedRhel8Installer(Unattended *pParent)
+        : UnattendedRhel7Installer(pParent)
+    { Assert(!isOriginalIsoNeeded()); Assert(isAuxiliaryIsoNeeded()); Assert(!isAuxiliaryFloppyNeeded()); Assert(isAuxiliaryIsoIsVISO()); }
+
+    UnattendedRhel8Installer(Unattended *pParent,
+                             const char *pszMainScriptTemplateName,
+                             const char *pszPostScriptTemplateName,
+                             const char *pszMainScriptFilename)
+        : UnattendedRhel7Installer(pParent, pszMainScriptTemplateName, pszPostScriptTemplateName, pszMainScriptFilename)
+    { Assert(!isOriginalIsoNeeded()); Assert(isAuxiliaryIsoNeeded()); Assert(!isAuxiliaryFloppyNeeded()); Assert(isAuxiliaryIsoIsVISO()); }
+    ~UnattendedRhel8Installer() {}
+};
+
+
+/**
+ * RHEL 5 installer (same as RHEL 6, except for the kickstart template).
+ */
+class UnattendedRhel5Installer : public UnattendedRhel6Installer
+{
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedRhel5Installer)
+
+    UnattendedRhel5Installer(Unattended *pParent) : UnattendedRhel6Installer(pParent, "rhel5_ks.cfg") {}
+    ~UnattendedRhel5Installer() {}
+};
+
+
+/**
+ * RHEL 4 installer (same as RHEL 6, except for the kickstart template).
+ */
+class UnattendedRhel4Installer : public UnattendedRhel6Installer
+{
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedRhel4Installer)
+
+    UnattendedRhel4Installer(Unattended *pParent) : UnattendedRhel6Installer(pParent, "rhel4_ks.cfg") {}
+    ~UnattendedRhel4Installer() {}
+};
+
+
+/**
+ * RHEL 3 installer (same as RHEL 6, except for the kickstart template).
+ */
+class UnattendedRhel3Installer : public UnattendedRhel6Installer
+{
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedRhel3Installer)
+
+    UnattendedRhel3Installer(Unattended *pParent) : UnattendedRhel6Installer(pParent, "rhel3_ks.cfg") {}
+    ~UnattendedRhel3Installer() {}
+};
+
+
+/**
+ * Fedora installer (same as RHEL 6, except for the template).
+ */
+class UnattendedFedoraInstaller : public UnattendedRhel6Installer
+{
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedFedoraInstaller)
+
+    UnattendedFedoraInstaller(Unattended *pParent)
+        : UnattendedRhel6Installer(pParent, "fedora_ks.cfg")
+    { Assert(!isOriginalIsoNeeded()); Assert(isAuxiliaryIsoNeeded()); Assert(!isAuxiliaryFloppyNeeded()); Assert(isAuxiliaryIsoIsVISO()); }
+    ~UnattendedFedoraInstaller() {}
+};
+
+
+/**
+ * Oracle Linux 6 installer. Same as RHEL 6, except for the templates.
+ * The reason of adding new class is to sepatate the RHEL from OL.
+ */
+class UnattendedOracleLinux6Installer : public UnattendedRhel6Installer
+{
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedOracleLinux6Installer)
+
+    UnattendedOracleLinux6Installer(Unattended *pParent,
+                                    const char *pszMainScriptTemplateName = "ol_ks.cfg",
+                                    const char *pszPostScriptTemplateName = "ol_postinstall.sh",
+                                    const char *pszMainScriptFilename = "ks.cfg")
+        : UnattendedRhel6Installer(pParent, pszMainScriptTemplateName, pszPostScriptTemplateName, pszMainScriptFilename)
+    { Assert(!isOriginalIsoNeeded()); Assert(isAuxiliaryIsoNeeded()); Assert(!isAuxiliaryFloppyNeeded()); Assert(isAuxiliaryIsoIsVISO()); }
+    ~UnattendedOracleLinux6Installer() {}
+};
+
+
+/**
+ * Oracle Linux 7 installer. Same as OL 6.
+ * The class was added for better handling any possible subtle difference between OL6 and OL7.
+ */
+class UnattendedOracleLinux7Installer : public UnattendedOracleLinux6Installer
+{
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedOracleLinux7Installer)
+
+    UnattendedOracleLinux7Installer(Unattended *pParent)
+        : UnattendedOracleLinux6Installer(pParent)
+    { Assert(!isOriginalIsoNeeded()); Assert(isAuxiliaryIsoNeeded()); Assert(!isAuxiliaryFloppyNeeded()); Assert(isAuxiliaryIsoIsVISO()); }
+
+    UnattendedOracleLinux7Installer(Unattended *pParent,
+                                    const char *pszMainScriptTemplateName,
+                                    const char *pszPostScriptTemplateName,
+                                    const char *pszMainScriptFilename)
+        : UnattendedOracleLinux6Installer(pParent, pszMainScriptTemplateName, pszPostScriptTemplateName, pszMainScriptFilename)
+    { Assert(!isOriginalIsoNeeded()); Assert(isAuxiliaryIsoNeeded()); Assert(!isAuxiliaryFloppyNeeded()); Assert(isAuxiliaryIsoIsVISO()); }
+    ~UnattendedOracleLinux7Installer() {}
+};
+
+
+/**
+ * Oracle Linux 8 installer. Using a different kickstart file than earlier OL versions.
+ */
+class UnattendedOracleLinux8Installer : public UnattendedOracleLinux7Installer
+{
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedOracleLinux8Installer)
+
+    UnattendedOracleLinux8Installer(Unattended *pParent,
+                                    const char *pszMainScriptTemplateName = "ol8_ks.cfg",
+                                    const char *pszPostScriptTemplateName = "ol_postinstall.sh",
+                                    const char *pszMainScriptFilename = "ks.cfg")
+
+        : UnattendedOracleLinux7Installer(pParent, pszMainScriptTemplateName, pszPostScriptTemplateName, pszMainScriptFilename)
+    { Assert(!isOriginalIsoNeeded()); Assert(isAuxiliaryIsoNeeded()); Assert(!isAuxiliaryFloppyNeeded()); Assert(isAuxiliaryIsoIsVISO()); }
+    ~UnattendedOracleLinux8Installer() {}
+};
+
+/**
+ * Oracle Linux 9 installer.
+ * Uses a different kickstart file since several commands/options are removed in OL9.
+ * See the ol9_ks.cfg file for comments. Also, as of OL9 kernel command argument 'ks' should have
+ * 'inst.' prefix.
+ */
+class UnattendedOracleLinux9Installer : public UnattendedRhelInstaller
+{
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedOracleLinux9Installer)
+
+    UnattendedOracleLinux9Installer(Unattended *pParent,
+                                    const char *pszMainScriptTemplateName = "ol9_ks.cfg",
+                                    const char *pszPostScriptTemplateName = "ol_postinstall.sh",
+                                    const char *pszMainScriptFilename = "ks.cfg")
+        : UnattendedRhelInstaller(pParent, pszMainScriptTemplateName, pszPostScriptTemplateName, pszMainScriptFilename)
+    {
+        Assert(!isOriginalIsoNeeded());
+        Assert(isAuxiliaryIsoNeeded());
+        Assert(!isAuxiliaryFloppyNeeded());
+        Assert(isAuxiliaryIsoIsVISO());
+        mStrDefaultExtraInstallKernelParameters.assign(" inst.ks=cdrom:/").append(pszMainScriptFilename).append(' ');
+        mArrStrRemoveInstallKernelParameters.append("rd.live.check"); /* Disables the checkisomd5 step. Required for VISO. */
+    }
+    ~UnattendedOracleLinux9Installer() {}
+};
+
+
+#if 0 /* fixme */
+/**
+ * SUSE linux installer.
+ *
+ * @todo needs fixing.
+ */
+class UnattendedSuseInstaller : public UnattendedLinuxInstaller
+{
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedSuseInstaller)
+
+    UnattendedSuseInstaller(BaseTextScript *pAlg, Unattended *pParent)
+        : UnattendedLinuxInstaller(pAlg, pParent, "suse_autoinstall.xml")
+    { Assert(isOriginalIsoNeeded()); Assert(isAuxiliaryIsoNeeded()); Assert(!isAuxiliaryFloppyNeeded()); Assert(!isAuxiliaryIsoIsVISO()); }
+    ~UnattendedSuseInstaller() {}
+
+    HRESULT setupScriptOnAuxiliaryCD(const Utf8Str &path);
+};
+#endif
+
+/**
+ * Base class for the unattended FreeBSD installers.
+ */
+class UnattendedFreeBsdInstaller : public UnattendedInstaller
+{
+public:
+    UnattendedFreeBsdInstaller(Unattended *pParent)
+        : UnattendedInstaller(pParent,
+                              "freebsd_installer.cfg", "freebsd_postinstall.sh",
+                              "installerconfig", "vboxpostinstall.sh") {}
+    ~UnattendedFreeBsdInstaller() {}
+
+    bool isAuxiliaryIsoNeeded() const       { return true;  }
+    bool isOriginalIsoNeeded() const        { return false; }
+
+protected:
+    HRESULT addFilesToAuxVisoVectors(RTCList<RTCString> &rVecArgs, RTCList<RTCString> &rVecFiles,
+                                     RTVFS hVfsOrgIso, bool fOverwrite);
+};
+
+#endif /* !MAIN_INCLUDED_UnattendedInstaller_h */
diff --git a/src/VBox/Main/include/UnattendedScript.h b/src/VBox/Main/include/UnattendedScript.h
new file mode 100644
index 00000000..f61821b8
--- /dev/null
+++ b/src/VBox/Main/include/UnattendedScript.h
@@ -0,0 +1,193 @@
+/* $Id: UnattendedScript.h $ */
+/** @file
+ * Classes for reading/parsing/saving scripts for unattended installation.
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_UnattendedScript_h
+#define MAIN_INCLUDED_UnattendedScript_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "TextScript.h"
+#include "iprt/expreval.h"
+
+using namespace xml;
+
+class Unattended;
+
+
+/**
+ * Generic unattended text script template editor.
+ *
+ * This just perform variable replacements, no other editing possible.
+ *
+ * Everything happens during saveToString, parse is a noop.
+ */
+class UnattendedScriptTemplate : public BaseTextScript
+{
+protected:
+    /** Where to get the replacement strings from. */
+    Unattended *mpUnattended;
+
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedScriptTemplate)
+
+    UnattendedScriptTemplate(Unattended *pUnattended, const char *pszDefaultTemplateFilename, const char *pszDefaultFilename);
+    virtual ~UnattendedScriptTemplate()             {}
+
+    HRESULT parse()                                 { return S_OK; }
+    HRESULT saveToString(Utf8Str &rStrDst);
+
+protected:
+    typedef enum
+    {
+        kValueEscaping_None,
+        kValueEscaping_Bourne,
+        kValueEscaping_XML_Element,
+        kValueEscaping_XML_Attribute_Double_Quotes
+    } kEvalEscaping_T;
+
+    /**
+     * Gets the replacement value for the given placeholder.
+     *
+     * @returns COM status code.
+     * @param   pachPlaceholder The placholder string.  Not zero terminated.
+     * @param   cchPlaceholder  The length of the placeholder.
+     * @param   fOutputting     Indicates whether we actually need the correct value
+     *                          or is just syntax checking excluded template parts.
+     * @param   rValue          Where to return the value.
+     */
+    HRESULT getReplacement(const char *pachPlaceholder, size_t cchPlaceholder, bool fOutputting, RTCString &rValue);
+
+    /**
+     * Gets the replacement value for the given expression placeholder
+     * (@@VBOX_INSERT[expr]@@ and friends).
+     *
+     * @returns COM status code.
+     * @param   hEvaluator      The evaluator to use for the expression.
+     * @param   pachPlaceholder The placholder string.  Not zero terminated.
+     * @param   cchPlaceholder  The length of the placeholder.
+     * @param   fOutputting     Indicates whether we actually need the correct value
+     *                          or is just syntax checking excluded template parts.
+     * @param   ppszValue       Where to return the value.  Free by calling
+     *                          RTStrFree.  Set to NULL for empty string.
+     */
+    HRESULT getReplacementForExpr(RTEXPREVAL hEvaluator, const char *pachPlaceholder, size_t cchPlaceholder,
+                                  bool fOutputting, char **ppszValue) RT_NOEXCEPT;
+
+    /**
+     * Resolves a conditional expression.
+     *
+     * @returns COM status code.
+     * @param   hEvaluator      The evaluator to use for the expression.
+     * @param   pachPlaceholder The placholder string.  Not zero terminated.
+     * @param   cchPlaceholder  The length of the placeholder.
+     * @param   pfOutputting    Where to return the result of the conditional. This
+     *                          holds the current outputting state on input in case
+     *                          someone want to sanity check anything.
+     */
+    HRESULT resolveConditionalExpr(RTEXPREVAL hEvaluator, const char *pachPlaceholder, size_t cchPlaceholder,
+                                   bool *pfOutputting) RT_NOEXCEPT;
+
+    /** @callback_method_impl{FNRTEXPREVALQUERYVARIABLE}  */
+    static DECLCALLBACK(int) queryVariableForExpr(const char *pchName, size_t cchName, void *pvUser,
+                                                  char **ppszValue) RT_NOEXCEPT;
+
+    /**
+     * Gets a variable.
+     *
+     * This is used both for getting replacements (@@VBOX_INSERT_XXX@@) and in
+     * expressions (@@VBOX_INSERT[expr]@@, @@VBOX_COND[expr]@@).
+     *
+     * @returns VBox status code.
+     * @retval  VERR_NOT_FOUND if variable does not exist.
+     *
+     * @param   pchName             The variable name.  Not zero terminated.
+     * @param   cchName             The length of the name.
+     * @param   rstrTmp             String object that can be used for keeping the
+     *                              value returned via @a *ppszValue.
+     * @param   ppszValue           If a value is desired, this is where to return
+     *                              it.  This points to a string that should be
+     *                              accessible for a little while after the function
+     *                              returns.  Use @a rstrTmp for storage if
+     *                              necessary.
+     *
+     *                              This will be NULL when called from the 'defined'
+     *                              operator.  In which case no errors should be
+     *                              set.
+     * @throws  std::bad_alloc
+     * @see     FNRTEXPREVALQUERYVARIABLE
+     */
+    virtual int queryVariable(const char *pchName, size_t cchName, Utf8Str &rstrTmp, const char **ppszValue);
+
+    /**
+     * Get the result of a conditional.
+     *
+     * @returns COM status code.
+     * @param   pachPlaceholder     The placholder string.  Not zero terminated.
+     * @param   cchPlaceholder      The length of the placeholder.
+     * @param   pfOutputting        Where to return the result of the conditional.
+     *                              This holds the current outputting state on input
+     *                              in case someone want to sanity check anything.
+     */
+    virtual HRESULT getConditional(const char *pachPlaceholder, size_t cchPlaceholder, bool *pfOutputting);
+};
+
+#if 0 /* convert when we fix SUSE */
+/**
+ * SUSE unattended XML file editor.
+ */
+class UnattendedSUSEXMLScript : public UnattendedXMLScript
+{
+public:
+    DECLARE_TRANSLATE_METHODS(UnattendedSUSEXMLScript)
+
+    UnattendedSUSEXMLScript(VirtualBoxBase *pSetError, const char *pszDefaultFilename = "autoinst.xml")
+        : UnattendedXMLScript(pSetError, pszDefaultFilename) {}
+    ~UnattendedSUSEXMLScript() {}
+
+    HRESULT parse();
+
+protected:
+    HRESULT setFieldInElement(xml::ElementNode *pElement, const DataId enmDataId, const Utf8Str &rStrValue);
+
+private:
+    //////////////////New functions//////////////////////////////
+    /** @throws std::bad_alloc */
+    HRESULT LoopThruSections(const xml::ElementNode *pelmRoot);
+    /** @throws std::bad_alloc */
+    HRESULT HandleUserAccountsSection(const xml::ElementNode *pelmSection);
+    /** @throws std::bad_alloc */
+    Utf8Str createProbableValue(const DataId enmDataId, const xml::ElementNode *pCurElem);
+    /** @throws std::bad_alloc */
+    Utf8Str createProbableUserHomeDir(const xml::ElementNode *pCurElem);
+    //////////////////New functions//////////////////////////////
+};
+#endif
+
+
+#endif /* !MAIN_INCLUDED_UnattendedScript_h */
+
diff --git a/src/VBox/Main/include/UpdateAgentImpl.h b/src/VBox/Main/include/UpdateAgentImpl.h
new file mode 100644
index 00000000..4381c517
--- /dev/null
+++ b/src/VBox/Main/include/UpdateAgentImpl.h
@@ -0,0 +1,220 @@
+/* $Id: UpdateAgentImpl.h $ */
+/** @file
+ * Update agent COM class implementation - Header
+ */
+
+/*
+ * Copyright (C) 2020-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
+ */
+
+#ifndef MAIN_INCLUDED_UpdateAgentImpl_h
+#define MAIN_INCLUDED_UpdateAgentImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/http.h>
+
+#include <VBox/settings.h>
+
+#include "EventImpl.h"
+#include "UpdateAgentWrap.h"
+#include "HostUpdateAgentWrap.h"
+
+class  UpdateAgentTask;
+struct UpdateAgentTaskParms;
+
+struct UpdateAgentTaskResult
+{
+    Utf8Str          strVer;
+    Utf8Str          strWebUrl;
+    Utf8Str          strDownloadUrl;
+    UpdateSeverity_T enmSeverity;
+    Utf8Str          strReleaseNotes;
+};
+
+class UpdateAgentBase
+{
+protected: /* Not directly instancable. */
+
+    UpdateAgentBase()
+        : m_VirtualBox(NULL)
+        , m(new settings::UpdateAgent) { }
+
+    virtual ~UpdateAgentBase() { delete m; }
+
+public:
+
+    /** @name Pure virtual public methods for internal purposes only
+     *        (ensure there is a caller and a read lock before calling them!)
+     * @{ */
+    virtual HRESULT i_loadSettings(const settings::UpdateAgent &data) = 0;
+    virtual HRESULT i_saveSettings(settings::UpdateAgent &data) = 0;
+
+    virtual HRESULT i_setCheckCount(ULONG aCount) = 0;
+    virtual HRESULT i_setLastCheckDate(const com::Utf8Str &aDate) = 0;
+    /** @} */
+
+protected:
+
+    /** @name Pure virtual internal task callbacks.
+     * @{ */
+    friend UpdateAgentTask;
+    virtual DECLCALLBACK(HRESULT) i_checkForUpdateTask(UpdateAgentTask *pTask) = 0;
+    /** @} */
+
+    /** @name Static helper methods.
+     * @{ */
+    static Utf8Str i_getPlatformInfo(void);
+    const char    *i_proxyModeToStr(ProxyMode_T enmMode);
+    bool           i_urlSchemeIsSupported(const Utf8Str &strUrl) const;
+    /** @} */
+
+protected:
+    /** The update agent's event source. */
+    const ComObjPtr<EventSource> m_EventSource;
+    VirtualBox * const           m_VirtualBox;
+
+    /** @name Data members.
+     * @{ */
+    settings::UpdateAgent *m;
+
+    struct Data
+    {
+        UpdateAgentTaskResult              m_lastResult;
+        Utf8Str                            m_strName;
+        /** Vector of update channels this agent supports. */
+        const std::vector<UpdateChannel_T> m_enmChannels;
+        bool                               m_fHidden;
+        UpdateState_T                      m_enmState;
+        uint32_t                           m_uOrder;
+
+        Data(void)
+        {
+            m_fHidden  = true;
+            m_enmState = UpdateState_Invalid;
+            m_uOrder   = UINT32_MAX;
+        }
+    } mData;
+    /** @} */
+};
+
+class ATL_NO_VTABLE UpdateAgent :
+    public UpdateAgentWrap,
+    public UpdateAgentBase
+{
+public:
+    DECLARE_COMMON_CLASS_METHODS(UpdateAgent)
+
+    /** @name COM and internal init/term/mapping cruft.
+     * @{ */
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    HRESULT init(VirtualBox *aVirtualBox);
+    void uninit(void);
+    /** @}  */
+
+    /** @name Public methods for internal purposes only
+     *        (ensure there is a caller and a read lock before calling them!)
+     * @{ */
+    HRESULT i_loadSettings(const settings::UpdateAgent &data);
+    HRESULT i_saveSettings(settings::UpdateAgent &data);
+
+    virtual HRESULT i_setCheckCount(ULONG aCount);
+    virtual HRESULT i_setLastCheckDate(const com::Utf8Str &aDate);
+    /** @} */
+
+protected:
+
+    /** @name Internal helper methods.
+     * @{ */
+    HRESULT i_getProxyMode(ProxyMode_T *aMode);
+    HRESULT i_getProxyURL(com::Utf8Str &aAddress);
+    HRESULT i_configureProxy(RTHTTP hHttp);
+    HRESULT i_commitSettings(AutoWriteLock &aLock);
+    HRESULT i_reportError(int vrc, const char *pcszMsgFmt, ...);
+    /** @}  */
+
+protected:
+    /** @name Wrapped IUpdateAgent attributes and methods.
+     * @{ */
+    HRESULT checkFor(ComPtr<IProgress> &aProgress);
+    HRESULT download(ComPtr<IProgress> &aProgress);
+    HRESULT install(ComPtr<IProgress> &aProgress);
+    HRESULT rollback(void);
+
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
+    HRESULT getOrder(ULONG *aOrder);
+    HRESULT getDependsOn(std::vector<com::Utf8Str> &aDeps);
+    HRESULT getVersion(com::Utf8Str &aVer);
+    HRESULT getDownloadUrl(com::Utf8Str &aUrl);
+    HRESULT getWebUrl(com::Utf8Str &aUrl);
+    HRESULT getReleaseNotes(com::Utf8Str &aRelNotes);
+    HRESULT getEnabled(BOOL *aEnabled);
+    HRESULT setEnabled(BOOL aEnabled);
+    HRESULT getHidden(BOOL *aHidden);
+    HRESULT getState(UpdateState_T *aState);
+    HRESULT getCheckCount(ULONG *aCount);
+    HRESULT getCheckFrequency(ULONG  *aFreqSeconds);
+    HRESULT setCheckFrequency(ULONG aFreqSeconds);
+    HRESULT getChannel(UpdateChannel_T *aChannel);
+    HRESULT setChannel(UpdateChannel_T aChannel);
+    HRESULT getRepositoryURL(com::Utf8Str &aRepo);
+    HRESULT setRepositoryURL(const com::Utf8Str &aRepo);
+    HRESULT getLastCheckDate(com::Utf8Str &aData);
+    HRESULT getIsCheckNeeded(BOOL *aCheckNeeded);
+    HRESULT getSupportedChannels(std::vector<UpdateChannel_T> &aSupportedChannels);
+    /** @} */
+};
+
+/** @todo Put this into an own module, e.g. HostUpdateAgentImpl.[cpp|h]. */
+
+class ATL_NO_VTABLE HostUpdateAgent :
+    public UpdateAgent
+{
+public:
+    /** @name COM and internal init/term/mapping cruft.
+     * @{ */
+    DECLARE_COMMON_CLASS_METHODS(HostUpdateAgent)
+
+    HRESULT init(VirtualBox *aVirtualBox);
+    void    uninit(void);
+
+    HRESULT FinalConstruct(void);
+    void    FinalRelease(void);
+    /** @}  */
+
+private:
+    /** @name Implemented (pure) virtual methods from UpdateAgent.
+     * @{ */
+    HRESULT checkFor(ComPtr<IProgress> &aProgress);
+
+    DECLCALLBACK(HRESULT) i_checkForUpdateTask(UpdateAgentTask *pTask);
+    /** @}  */
+
+    HRESULT i_checkForUpdate(void);
+    HRESULT i_checkForUpdateInner(RTHTTP hHttp, com::Utf8Str const &strUrl, com::Utf8Str const &strUserAgent);
+};
+
+#endif /* !MAIN_INCLUDED_UpdateAgentImpl_h */
+
diff --git a/src/VBox/Main/include/UsbCardReader.h b/src/VBox/Main/include/UsbCardReader.h
new file mode 100644
index 00000000..15dc871f
--- /dev/null
+++ b/src/VBox/Main/include/UsbCardReader.h
@@ -0,0 +1,87 @@
+/* $Id: UsbCardReader.h $ */
+
+/** @file
+ * VirtualBox Driver interface to the virtual Usb Card Reader.
+ */
+
+/*
+ * Copyright (C) 2011-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
+ */
+
+#ifndef MAIN_INCLUDED_UsbCardReader_h
+#define MAIN_INCLUDED_UsbCardReader_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/vmm/pdmcardreaderinfs.h>
+#include <VBox/vmm/pdmdrv.h>
+
+#define USBCARDREADER_OID "46225eac-10c9-4b57-92b6-e59efd48009f"
+
+class Console;
+typedef struct USBCARDREADER USBCARDREADER;
+typedef struct UCRREMOTE UCRREMOTE;
+
+class UsbCardReader
+{
+    public:
+        UsbCardReader(Console *console);
+        virtual ~UsbCardReader();
+
+        static const PDMDRVREG DrvReg;
+        USBCARDREADER *mpDrv;
+
+        Console *getParent(void) { return mParent; }
+
+        int VRDENotify(uint32_t u32Id, void *pvData, uint32_t cbData);
+        int VRDEResponse(int rcRequest, void *pvUser, uint32_t u32Function, void *pvData, uint32_t cbData);
+
+        int EstablishContext(USBCARDREADER *pDrv);
+        int ReleaseContext(USBCARDREADER *pDrv);
+        int GetStatusChange(USBCARDREADER *pDrv, void *pvUser, uint32_t u32Timeout,
+                            PDMICARDREADER_READERSTATE *paReaderStats, uint32_t cReaderStats);
+        int Connect(USBCARDREADER *pDrv, void *pvUser, const char *pszReaderName,
+                    uint32_t u32ShareMode, uint32_t u32PreferredProtocols);
+        int Disconnect(USBCARDREADER *pDrv, void *pvUser, uint32_t u32Mode);
+        int Status(USBCARDREADER *pDrv, void *pvUser);
+        int Transmit(USBCARDREADER *pDrv, void *pvUser, PDMICARDREADER_IO_REQUEST *pioSendRequest,
+                     uint8_t *pu8SendBuffer, uint32_t cbSendBuffer, uint32_t cbRecvBuffer);
+        int Control(USBCARDREADER *pDrv, void *pvUser, uint32_t u32ControlCode,
+                    uint8_t *pu8InBuffer, uint32_t cbInBuffer, uint32_t cbOutBuffer);
+        int GetAttrib(USBCARDREADER *pDrv, void *pvUser, uint32_t u32AttrId, uint32_t cbAttrib);
+        int SetAttrib(USBCARDREADER *pDrv, void *pvUser, uint32_t u32AttrId,
+                      uint8_t *pu8Attrib, uint32_t cbAttrib);
+
+    private:
+        static DECLCALLBACK(void *) drvQueryInterface(PPDMIBASE pInterface, const char *pszIID);
+        static DECLCALLBACK(int)    drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
+        static DECLCALLBACK(void)   drvDestruct(PPDMDRVINS pDrvIns);
+
+        int vrdeSCardRequest(void *pvUser, uint32_t u32Function, const void *pvData, uint32_t cbData);
+
+        Console * const mParent;
+
+        UCRREMOTE *m_pRemote;
+};
+
+#endif /* !MAIN_INCLUDED_UsbCardReader_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/UsbWebcamInterface.h b/src/VBox/Main/include/UsbWebcamInterface.h
new file mode 100644
index 00000000..eb803ba4
--- /dev/null
+++ b/src/VBox/Main/include/UsbWebcamInterface.h
@@ -0,0 +1,79 @@
+/* $Id: UsbWebcamInterface.h $ */
+/** @file
+ * VirtualBox PDM Driver for Emulated USB Webcam
+ */
+
+/*
+ * Copyright (C) 2011-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
+ */
+
+#ifndef MAIN_INCLUDED_UsbWebcamInterface_h
+#define MAIN_INCLUDED_UsbWebcamInterface_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/vmm/pdmdrv.h>
+#define VRDE_VIDEOIN_WITH_VRDEINTERFACE /* Get the VRDE interface definitions. */
+#include <VBox/RemoteDesktop/VRDEVideoIn.h>
+
+class ConsoleVRDPServer;
+typedef struct EMWEBCAMDRV EMWEBCAMDRV;
+typedef struct EMWEBCAMREMOTE EMWEBCAMREMOTE;
+
+class EmWebcam
+{
+    public:
+        EmWebcam(ConsoleVRDPServer *pServer);
+        virtual ~EmWebcam();
+
+        static const PDMDRVREG DrvReg;
+
+        void EmWebcamConstruct(EMWEBCAMDRV *pDrv);
+        void EmWebcamDestruct(EMWEBCAMDRV *pDrv);
+
+        /* Callbacks. */
+        void EmWebcamCbNotify(uint32_t u32Id, const void *pvData, uint32_t cbData);
+        void EmWebcamCbDeviceDesc(int rcRequest, void *pDeviceCtx, void *pvUser,
+                                  const VRDEVIDEOINDEVICEDESC *pDeviceDesc, uint32_t cbDeviceDesc);
+        void EmWebcamCbControl(int rcRequest, void *pDeviceCtx, void *pvUser,
+                               const VRDEVIDEOINCTRLHDR *pControl, uint32_t cbControl);
+        void EmWebcamCbFrame(int rcRequest, void *pDeviceCtx,
+                             const VRDEVIDEOINPAYLOADHDR *pFrame, uint32_t cbFrame);
+
+        /* Methods for the PDM driver. */
+        int SendControl(EMWEBCAMDRV *pDrv, void *pvUser, uint64_t u64DeviceId,
+                        const VRDEVIDEOINCTRLHDR *pControl, uint32_t cbControl);
+
+    private:
+        static DECLCALLBACK(void *) drvQueryInterface(PPDMIBASE pInterface, const char *pszIID);
+        static DECLCALLBACK(int)    drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
+        static DECLCALLBACK(void)   drvDestruct(PPDMDRVINS pDrvIns);
+
+        ConsoleVRDPServer * const mParent;
+
+        EMWEBCAMDRV *mpDrv;
+        EMWEBCAMREMOTE *mpRemote;
+        uint64_t volatile mu64DeviceIdSrc;
+};
+
+#endif /* !MAIN_INCLUDED_UsbWebcamInterface_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/VBoxNls.h b/src/VBox/Main/include/VBoxNls.h
new file mode 100644
index 00000000..19fbc69f
--- /dev/null
+++ b/src/VBox/Main/include/VBoxNls.h
@@ -0,0 +1,65 @@
+/* $Id: VBoxNls.h $ */
+/** @file
+ * VBox NLS.
+ */
+
+/*
+ * Copyright (C) 2020-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
+ */
+
+
+#ifndef MAIN_INCLUDED_VBoxNls_h
+#define MAIN_INCLUDED_VBoxNls_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#ifdef VBOX_WITH_MAIN_NLS
+
+#include <VBox/com/defs.h>
+#include <VBox/com/ptr.h>
+#include <VBox/com/string.h>
+#include "VirtualBoxTranslator.h"
+
+
+# define DECLARE_TRANSLATION_CONTEXT(ctx) \
+struct ctx \
+{\
+   static const char *tr(const char *pszSource, const char *pszComment = NULL, const size_t aNum = ~(size_t)0) \
+   { \
+       return VirtualBoxTranslator::translate(NULL, #ctx, pszSource, pszComment, aNum); \
+   } \
+}
+#else
+# define DECLARE_TRANSLATION_CONTEXT(ctx) \
+struct ctx \
+{\
+   static const char *tr(const char *pszSource, const char *pszComment = NULL, const size_t aNum = ~(size_t)0) \
+   { \
+       NOREF(pszComment); \
+       NOREF(aNum);       \
+       return pszSource;  \
+   } \
+}
+#endif
+
+#endif /* !MAIN_INCLUDED_VBoxNls_h */
+
diff --git a/src/VBox/Main/include/VFSExplorerImpl.h b/src/VBox/Main/include/VFSExplorerImpl.h
new file mode 100644
index 00000000..fb5e4912
--- /dev/null
+++ b/src/VBox/Main/include/VFSExplorerImpl.h
@@ -0,0 +1,101 @@
+/* $Id: VFSExplorerImpl.h $ */
+/** @file
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2009-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
+ */
+
+#ifndef MAIN_INCLUDED_VFSExplorerImpl_h
+#define MAIN_INCLUDED_VFSExplorerImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "VFSExplorerWrap.h"
+
+class ATL_NO_VTABLE VFSExplorer :
+    public VFSExplorerWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(VFSExplorer)
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT FinalConstruct() { return BaseFinalConstruct(); }
+    void FinalRelease() { uninit(); BaseFinalRelease(); }
+
+    HRESULT init(VFSType_T aType, Utf8Str aFilePath, Utf8Str aHostname, Utf8Str aUsername, Utf8Str aPassword, VirtualBox *aVirtualBox);
+    void uninit();
+
+    /* public methods only for internal purposes */
+    static HRESULT setErrorStatic(HRESULT aResultCode, const char *aText, ...)
+    {
+        va_list va;
+        va_start(va, aText);
+        HRESULT hrc = setErrorInternalV(aResultCode, getStaticClassIID(), getStaticComponentName(), aText, va, false, true);
+        va_end(va);
+        return hrc;
+    }
+
+private:
+
+    // wrapped IVFSExplorer properties
+    HRESULT getPath(com::Utf8Str &aPath);
+    HRESULT getType(VFSType_T *aType);
+
+   // wrapped IVFSExplorer methods
+    HRESULT update(ComPtr<IProgress> &aProgress);
+    HRESULT cd(const com::Utf8Str &aDir, ComPtr<IProgress> &aProgress);
+    HRESULT cdUp(ComPtr<IProgress> &aProgress);
+    HRESULT entryList(std::vector<com::Utf8Str> &aNames,
+                      std::vector<ULONG> &aTypes,
+                      std::vector<LONG64> &aSizes,
+                      std::vector<ULONG> &aModes);
+    HRESULT exists(const std::vector<com::Utf8Str> &aNames,
+                   std::vector<com::Utf8Str> &aExists);
+    HRESULT remove(const std::vector<com::Utf8Str> &aNames,
+                   ComPtr<IProgress> &aProgress);
+
+    /* Private member vars */
+    VirtualBox * const mVirtualBox;
+
+    ////////////////////////////////////////////////////////////////////////////////
+    ////
+    //// VFSExplorer definitions
+    ////
+    //////////////////////////////////////////////////////////////////////////////////
+    //
+    class TaskVFSExplorer;  /* Worker thread helper */
+    struct Data;
+    Data *m;
+
+    /* Private member methods */
+    FsObjType_T i_iprtToVfsObjType(RTFMODE aType) const;
+
+    HRESULT i_updateFS(TaskVFSExplorer *aTask);
+    HRESULT i_deleteFS(TaskVFSExplorer *aTask);
+
+};
+
+#endif /* !MAIN_INCLUDED_VFSExplorerImpl_h */
+
diff --git a/src/VBox/Main/include/VMMDev.h b/src/VBox/Main/include/VMMDev.h
new file mode 100644
index 00000000..a5583d41
--- /dev/null
+++ b/src/VBox/Main/include/VMMDev.h
@@ -0,0 +1,115 @@
+/* $Id: VMMDev.h $ */
+/** @file
+ * VirtualBox Driver interface to VMM device
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_VMMDev_h
+#define MAIN_INCLUDED_VMMDev_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "VirtualBoxBase.h"
+#include <VBox/vmm/pdmdrv.h>
+#include <VBox/hgcmsvc.h>
+#include <iprt/asm.h>
+
+class Console;
+
+class VMMDevMouseInterface
+{
+public:
+    virtual ~VMMDevMouseInterface() { /* Make VC++ 19.2 happy. */ }
+    virtual PPDMIVMMDEVPORT getVMMDevPort() = 0;
+};
+
+class VMMDev : public VMMDevMouseInterface
+{
+public:
+    VMMDev(Console *console);
+    virtual ~VMMDev();
+    static const PDMDRVREG  DrvReg;
+    /** Pointer to the associated VMMDev driver. */
+    struct DRVMAINVMMDEV *mpDrv;
+
+    bool fSharedFolderActive;
+    bool isShFlActive()
+    {
+        return fSharedFolderActive;
+    }
+
+    Console *getParent()
+    {
+        return mParent;
+    }
+
+    int WaitCredentialsJudgement (uint32_t u32Timeout, uint32_t *pu32GuestFlags);
+    int SetCredentialsJudgementResult (uint32_t u32Flags);
+
+    PPDMIVMMDEVPORT getVMMDevPort();
+
+#ifdef VBOX_WITH_HGCM
+    int hgcmLoadService (const char *pszServiceLibrary, const char *pszServiceName);
+    int hgcmHostCall (const char *pszServiceName, uint32_t u32Function, uint32_t cParms, PVBOXHGCMSVCPARM paParms);
+    void hgcmShutdown(bool fUvmIsInvalid = false);
+
+    bool hgcmIsActive (void) { return ASMAtomicReadBool(&m_fHGCMActive); }
+#endif /* VBOX_WITH_HGCM */
+
+private:
+#ifdef VBOX_WITH_HGCM
+# ifdef VBOX_WITH_GUEST_PROPS
+    void i_guestPropSetMultiple(void *names, void *values, void *timestamps, void *flags);
+    void i_guestPropSet(const char *pszName, const char *pszValue, const char *pszFlags);
+    int  i_guestPropSetGlobalPropertyFlags(uint32_t fFlags);
+    int  i_guestPropLoadAndConfigure();
+# endif
+#endif
+    static DECLCALLBACK(void *) drvQueryInterface(PPDMIBASE pInterface, const char *pszIID);
+    static DECLCALLBACK(int)    drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
+    static DECLCALLBACK(void)   drvDestruct(PPDMDRVINS pDrvIns);
+    static DECLCALLBACK(void)   drvReset(PPDMDRVINS pDrvIns);
+    static DECLCALLBACK(void)   drvPowerOn(PPDMDRVINS pDrvIns);
+    static DECLCALLBACK(void)   drvPowerOff(PPDMDRVINS pDrvIns);
+    static DECLCALLBACK(void)   drvSuspend(PPDMDRVINS pDrvIns);
+    static DECLCALLBACK(void)   drvResume(PPDMDRVINS pDrvIns);
+    static DECLCALLBACK(int)    hgcmSave(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM);
+    static DECLCALLBACK(int)    hgcmLoad(PPDMDRVINS pDrvIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
+
+    Console * const         mParent;
+
+    RTSEMEVENT mCredentialsEvent;
+    uint32_t mu32CredentialsFlags;
+
+#ifdef VBOX_WITH_HGCM
+    bool volatile m_fHGCMActive;
+#endif /* VBOX_WITH_HGCM */
+};
+
+/** VMMDev object ID used by Console::i_vmm2User_QueryGenericObject and VMMDev::drvConstruct. */
+#define VMMDEV_OID                          "e2ff0c7b-c02b-46d0-aa90-b9caf0f60561"
+
+#endif /* !MAIN_INCLUDED_VMMDev_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/VRDEServerImpl.h b/src/VBox/Main/include/VRDEServerImpl.h
new file mode 100644
index 00000000..c8e47273
--- /dev/null
+++ b/src/VBox/Main/include/VRDEServerImpl.h
@@ -0,0 +1,98 @@
+/* $Id: VRDEServerImpl.h $ */
+
+/** @file
+ *
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_VRDEServerImpl_h
+#define MAIN_INCLUDED_VRDEServerImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "VRDEServerWrap.h"
+
+namespace settings
+{
+    struct VRDESettings;
+}
+
+class ATL_NO_VTABLE VRDEServer :
+    public VRDEServerWrap
+{
+public:
+
+    DECLARE_COMMON_CLASS_METHODS(VRDEServer)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(Machine *aParent);
+    HRESULT init(Machine *aParent, VRDEServer *aThat);
+    HRESULT initCopy(Machine *aParent, VRDEServer *aThat);
+    void uninit();
+
+    // public methods only for internal purposes
+    HRESULT i_loadSettings(const settings::VRDESettings &data);
+    HRESULT i_saveSettings(settings::VRDESettings &data);
+    void i_rollback();
+    void i_commit();
+    void i_copyFrom(VRDEServer *aThat);
+
+private:
+
+     // wrapped IVRDEServer properties
+     HRESULT getEnabled(BOOL *aEnabled);
+     HRESULT setEnabled(BOOL aEnabled);
+     HRESULT getAuthType(AuthType_T *aAuthType);
+     HRESULT setAuthType(AuthType_T aAuthType);
+     HRESULT getAuthTimeout(ULONG *aAuthTimeout);
+     HRESULT setAuthTimeout(ULONG aAuthTimeout);
+     HRESULT getAllowMultiConnection(BOOL *aAllowMultiConnection);
+     HRESULT setAllowMultiConnection(BOOL aAllowMultiConnection);
+     HRESULT getReuseSingleConnection(BOOL *aReuseSingleConnection);
+     HRESULT setReuseSingleConnection(BOOL aReuseSingleConnection);
+     HRESULT getVRDEExtPack(com::Utf8Str &aVRDEExtPack);
+     HRESULT setVRDEExtPack(const com::Utf8Str &aVRDEExtPack);
+     HRESULT getAuthLibrary(com::Utf8Str &aAuthLibrary);
+     HRESULT setAuthLibrary(const com::Utf8Str &aAuthLibrary);
+     HRESULT getVRDEProperties(std::vector<com::Utf8Str> &aVRDEProperties);
+
+    // wrapped IVRDEServer methods
+    HRESULT setVRDEProperty(const com::Utf8Str &aKey,
+                            const com::Utf8Str &aValue);
+    HRESULT getVRDEProperty(const com::Utf8Str &aKey,
+                            com::Utf8Str &aValue);
+
+    Machine * const     mParent;
+    const ComObjPtr<VRDEServer> mPeer;
+
+    Backupable<settings::VRDESettings> mData;
+};
+
+#endif /* !MAIN_INCLUDED_VRDEServerImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/VirtualBoxBase.h b/src/VBox/Main/include/VirtualBoxBase.h
new file mode 100644
index 00000000..2fa10f90
--- /dev/null
+++ b/src/VBox/Main/include/VirtualBoxBase.h
@@ -0,0 +1,1118 @@
+/* $Id: VirtualBoxBase.h $ */
+/** @file
+ * VirtualBox COM base classes definition
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_VirtualBoxBase_h
+#define MAIN_INCLUDED_VirtualBoxBase_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/cdefs.h>
+#include <iprt/thread.h>
+
+#include <list>
+#include <map>
+
+#include "ObjectState.h"
+
+#include "VBox/com/AutoLock.h"
+#include "VBox/com/string.h"
+#include "VBox/com/Guid.h"
+
+#include "VBox/com/VirtualBox.h"
+
+#include "VirtualBoxTranslator.h"
+
+// avoid including VBox/settings.h and VBox/xml.h; only declare the classes
+namespace xml
+{
+class File;
+}
+
+namespace com
+{
+class ErrorInfo;
+}
+
+using namespace com;
+using namespace util;
+
+class VirtualBox;
+class Machine;
+class Medium;
+class Host;
+typedef std::list<ComObjPtr<Medium> > MediaList;
+typedef std::list<Utf8Str> StringsList;
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// COM helpers
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#if !defined(VBOX_WITH_XPCOM)
+
+/* use a special version of the singleton class factory,
+ * see KB811591 in msdn for more info. */
+
+#undef DECLARE_CLASSFACTORY_SINGLETON
+#define DECLARE_CLASSFACTORY_SINGLETON(obj) DECLARE_CLASSFACTORY_EX(CMyComClassFactorySingleton<obj>)
+
+/**
+ * @todo r=bird: This CMyComClassFactorySingleton stuff is probably obsoleted by
+ *                microatl.h? Right?
+ */
+
+template <class T>
+class CMyComClassFactorySingleton : public ATL::CComClassFactory
+{
+public:
+    CMyComClassFactorySingleton() :
+        m_hrCreate(S_OK), m_spObj(NULL)
+    {
+    }
+    virtual ~CMyComClassFactorySingleton()
+    {
+        if (m_spObj)
+            m_spObj->Release();
+    }
+    // IClassFactory
+    STDMETHOD(CreateInstance)(LPUNKNOWN pUnkOuter, REFIID riid, void** ppvObj)
+    {
+        HRESULT hRes = E_POINTER;
+        if (ppvObj != NULL)
+        {
+            *ppvObj = NULL;
+            // no aggregation for singletons
+            AssertReturn(pUnkOuter == NULL, CLASS_E_NOAGGREGATION);
+            if (m_hrCreate == S_OK && m_spObj == NULL)
+            {
+                Lock();
+                __try
+                {
+                    // Fix:  The following If statement was moved inside the __try statement.
+                    // Did another thread arrive here first?
+                    if (m_hrCreate == S_OK && m_spObj == NULL)
+                    {
+                        // lock the module to indicate activity
+                        // (necessary for the monitor shutdown thread to correctly
+                        // terminate the module in case when CreateInstance() fails)
+                        ATL::_pAtlModule->Lock();
+                        ATL::CComObjectCached<T> *p;
+                        m_hrCreate = ATL::CComObjectCached<T>::CreateInstance(&p);
+                        if (SUCCEEDED(m_hrCreate))
+                        {
+                            m_hrCreate = p->QueryInterface(IID_IUnknown, (void **)&m_spObj);
+                            if (FAILED(m_hrCreate))
+                            {
+                                delete p;
+                            }
+                        }
+                        ATL::_pAtlModule->Unlock();
+                    }
+                }
+                __finally
+                {
+                    Unlock();
+                }
+            }
+            if (m_hrCreate == S_OK)
+            {
+                hRes = m_spObj->QueryInterface(riid, ppvObj);
+            }
+            else
+            {
+                hRes = m_hrCreate;
+            }
+        }
+        return hRes;
+    }
+    HRESULT m_hrCreate;
+    IUnknown *m_spObj;
+};
+
+#endif /* !defined(VBOX_WITH_XPCOM) */
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Macros
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Special version of the Assert macro to be used within VirtualBoxBase
+ *  subclasses.
+ *
+ *  In the debug build, this macro is equivalent to Assert.
+ *  In the release build, this macro uses |setError(E_FAIL, ...)| to set the
+ *  error info from the asserted expression.
+ *
+ *  @see VirtualBoxBase::setError
+ *
+ *  @param   expr    Expression which should be true.
+ */
+#define ComAssert(expr) \
+    do { \
+        if (RT_LIKELY(!!(expr))) \
+        { /* likely */ } \
+        else \
+        { \
+            AssertMsgFailed(("%s\n", #expr)); \
+            setError(E_FAIL, \
+                     VirtualBoxBase::tr("Assertion failed: [%s] at '%s' (%d) in %s.\nPlease contact the product vendor!"), \
+                     #expr, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
+        } \
+    } while (0)
+
+/**
+ *  Special version of the AssertFailed macro to be used within VirtualBoxBase
+ *  subclasses.
+ *
+ *  In the debug build, this macro is equivalent to AssertFailed.
+ *  In the release build, this macro uses |setError(E_FAIL, ...)| to set the
+ *  error info from the asserted expression.
+ *
+ *  @see VirtualBoxBase::setError
+ *
+ */
+#define ComAssertFailed() \
+    do { \
+        AssertFailed(); \
+        setError(E_FAIL, \
+                 VirtualBoxBase::tr("Assertion failed: at '%s' (%d) in %s.\nPlease contact the product vendor!"), \
+                 __FILE__, __LINE__, __PRETTY_FUNCTION__); \
+    } while (0)
+
+/**
+ *  Special version of the AssertMsg macro to be used within VirtualBoxBase
+ *  subclasses.
+ *
+ *  See ComAssert for more info.
+ *
+ *  @param   expr    Expression which should be true.
+ *  @param   a       printf argument list (in parenthesis).
+ */
+#define ComAssertMsg(expr, a) \
+    do { \
+        if (RT_LIKELY(!!(expr))) \
+        { /* likely */ } \
+        else \
+        { \
+            Utf8StrFmt MyAssertMsg a; /* may throw bad_alloc */ \
+            AssertMsgFailed(("%s\n", MyAssertMsg.c_str())); \
+            setError(E_FAIL, \
+                     VirtualBoxBase::tr("Assertion failed: [%s] at '%s' (%d) in %s.\n%s.\nPlease contact the product vendor!"), \
+                     #expr, __FILE__, __LINE__, __PRETTY_FUNCTION__, MyAssertMsg.c_str()); \
+        } \
+    } while (0)
+
+/**
+ *  Special version of the AssertMsgFailed macro to be used within VirtualBoxBase
+ *  subclasses.
+ *
+ *  See ComAssert for more info.
+ *
+ *  @param   a       printf argument list (in parenthesis).
+ */
+#define ComAssertMsgFailed(a) \
+    do { \
+        Utf8StrFmt MyAssertMsg a; /* may throw bad_alloc */ \
+        AssertMsgFailed(("%s\n", MyAssertMsg.c_str())); \
+        setError(E_FAIL, \
+                 VirtualBoxBase::tr("Assertion failed: at '%s' (%d) in %s.\n%s.\nPlease contact the product vendor!"), \
+                 __FILE__, __LINE__, __PRETTY_FUNCTION__, MyAssertMsg.c_str()); \
+    } while (0)
+
+/**
+ *  Special version of the AssertRC macro to be used within VirtualBoxBase
+ *  subclasses.
+ *
+ *  See ComAssert for more info.
+ *
+ * @param   vrc     VBox status code.
+ */
+#define ComAssertRC(vrc)            ComAssertMsgRC(vrc, ("%Rra", vrc))
+
+/**
+ *  Special version of the AssertMsgRC macro to be used within VirtualBoxBase
+ *  subclasses.
+ *
+ *  See ComAssert for more info.
+ *
+ *  @param   vrc    VBox status code.
+ *  @param   msg    printf argument list (in parenthesis).
+ */
+#define ComAssertMsgRC(vrc, msg)    ComAssertMsg(RT_SUCCESS(vrc), msg)
+
+/**
+ *  Special version of the AssertComRC macro to be used within VirtualBoxBase
+ *  subclasses.
+ *
+ *  See ComAssert for more info.
+ *
+ *  @param hrc  COM result code
+ */
+#define ComAssertComRC(hrc)         ComAssertMsg(SUCCEEDED(hrc), ("COM RC=%Rhrc (0x%08X)", (hrc), (hrc)))
+
+
+/** Special version of ComAssert that returns ret if expr fails */
+#define ComAssertRet(expr, ret)             \
+    do { ComAssert(expr); if (!(expr)) return (ret); } while (0)
+/** Special version of ComAssertMsg that returns ret if expr fails */
+#define ComAssertMsgRet(expr, a, ret)       \
+    do { ComAssertMsg(expr, a); if (!(expr)) return (ret); } while (0)
+/** Special version of ComAssertRC that returns ret if vrc does not succeed */
+#define ComAssertRCRet(vrc, ret)            \
+    do { ComAssertRC(vrc); if (!RT_SUCCESS(vrc)) return (ret); } while (0)
+/** Special version of ComAssertComRC that returns ret if rc does not succeed */
+#define ComAssertComRCRet(rc, ret)          \
+    do { ComAssertComRC(rc); if (!SUCCEEDED(rc)) return (ret); } while (0)
+/** Special version of ComAssertComRC that returns rc if rc does not succeed */
+#define ComAssertComRCRetRC(rc)             \
+    do { ComAssertComRC(rc); if (!SUCCEEDED(rc)) return (rc); } while (0)
+/** Special version of ComAssertFailed that returns ret */
+#define ComAssertFailedRet(ret)             \
+    do { ComAssertFailed(); return (ret); } while (0)
+/** Special version of ComAssertMsgFailed that returns ret */
+#define ComAssertMsgFailedRet(msg, ret)     \
+    do { ComAssertMsgFailed(msg); return (ret); } while (0)
+
+
+/** Special version of ComAssert that returns void if expr fails */
+#define ComAssertRetVoid(expr)                  \
+    do { ComAssert(expr); if (!(expr)) return; } while (0)
+/** Special version of ComAssertMsg that returns void if expr fails */
+#define ComAssertMsgRetVoid(expr, a)            \
+    do { ComAssertMsg(expr, a); if (!(expr)) return; } while (0)
+/** Special version of ComAssertRC that returns void if vrc does not succeed */
+#define ComAssertRCRetVoid(vrc)                 \
+    do { ComAssertRC(vrc); if (!RT_SUCCESS(vrc)) return; } while (0)
+/** Special version of ComAssertComRC that returns void if rc does not succeed */
+#define ComAssertComRCRetVoid(rc)               \
+    do { ComAssertComRC(rc); if (!SUCCEEDED(rc)) return; } while (0)
+/** Special version of ComAssertFailed that returns void */
+#define ComAssertFailedRetVoid()                \
+    do { ComAssertFailed(); return; } while (0)
+/** Special version of ComAssertMsgFailed that returns void */
+#define ComAssertMsgFailedRetVoid(msg)          \
+    do { ComAssertMsgFailed(msg); return; } while (0)
+
+
+/** Special version of ComAssert that evaluates eval and breaks if expr fails */
+#define ComAssertBreak(expr, eval)                \
+    if (1) { ComAssert(expr); if (!(expr)) { eval; break; } } else do {} while (0)
+/** Special version of ComAssertMsg that evaluates eval and breaks if expr fails */
+#define ComAssertMsgBreak(expr, a, eval)          \
+    if (1) { ComAssertMsg(expr, a); if (!(expr)) { eval; break; } } else do {} while (0)
+/** Special version of ComAssertRC that evaluates eval and breaks if vrc does not succeed */
+#define ComAssertRCBreak(vrc, eval)               \
+    if (1) { ComAssertRC(vrc); if (!RT_SUCCESS(vrc)) { eval; break; } } else do {} while (0)
+/** Special version of ComAssertFailed that evaluates eval and breaks */
+#define ComAssertFailedBreak(eval)                \
+    if (1) { ComAssertFailed(); { eval; break; } } else do {} while (0)
+/** Special version of ComAssertMsgFailed that evaluates eval and breaks */
+#define ComAssertMsgFailedBreak(msg, eval)        \
+    if (1) { ComAssertMsgFailed (msg); { eval; break; } } else do {} while (0)
+/** Special version of ComAssertComRC that evaluates eval and breaks if rc does not succeed */
+#define ComAssertComRCBreak(rc, eval)             \
+    if (1) { ComAssertComRC(rc); if (!SUCCEEDED(rc)) { eval; break; } } else do {} while (0)
+/** Special version of ComAssertComRC that just breaks if rc does not succeed */
+#define ComAssertComRCBreakRC(rc)                 \
+    if (1) { ComAssertComRC(rc); if (!SUCCEEDED(rc)) { break; } } else do {} while (0)
+
+
+/** Special version of ComAssert that evaluates eval and throws it if expr fails */
+#define ComAssertThrow(expr, eval)                \
+    do { ComAssert(expr); if (!(expr)) { throw (eval); } } while (0)
+/** Special version of ComAssertRC that evaluates eval and throws it if vrc does not succeed */
+#define ComAssertRCThrow(vrc, eval)               \
+    do { ComAssertRC(vrc); if (!RT_SUCCESS(vrc)) { throw (eval); } } while (0)
+/** Special version of ComAssertComRC that evaluates eval and throws it if rc does not succeed */
+#define ComAssertComRCThrow(rc, eval)             \
+    do { ComAssertComRC(rc); if (!SUCCEEDED(rc)) { throw (eval); } } while (0)
+/** Special version of ComAssertComRC that just throws rc if rc does not succeed */
+#define ComAssertComRCThrowRC(rc)                 \
+    do { ComAssertComRC(rc); if (!SUCCEEDED(rc)) { throw rc; } } while (0)
+/** Special version of ComAssert that throws eval */
+#define ComAssertFailedThrow(eval)                \
+    do { ComAssertFailed(); { throw (eval); } } while (0)
+
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Checks that the pointer argument is not NULL and returns E_INVALIDARG +
+ * extended error info on failure.
+ * @param arg   Input pointer-type argument (strings, interface pointers...)
+ */
+#define CheckComArgNotNull(arg) \
+    do { \
+        if (RT_LIKELY((arg) != NULL)) \
+        { /* likely */ }\
+        else \
+            return setError(E_INVALIDARG, VirtualBoxBase::tr("Argument %s is NULL"), #arg); \
+    } while (0)
+
+/**
+ * Checks that the pointer argument is a valid pointer or NULL and returns
+ * E_INVALIDARG + extended error info on failure.
+ * @param arg   Input pointer-type argument (strings, interface pointers...)
+ */
+#define CheckComArgMaybeNull(arg) \
+    do { \
+        if (RT_LIKELY(RT_VALID_PTR(arg) || (arg) == NULL)) \
+        { /* likely */ }\
+        else \
+            return setError(E_INVALIDARG, \
+                            VirtualBoxBase::tr("Argument %s is an invalid pointer"), #arg); \
+    } while (0)
+
+/**
+ * Checks that the given pointer to an argument is valid and returns
+ * E_POINTER + extended error info otherwise.
+ * @param arg   Pointer argument.
+ */
+#define CheckComArgPointerValid(arg) \
+    do { \
+        if (RT_LIKELY(RT_VALID_PTR(arg))) \
+        { /* likely */ }\
+        else \
+            return setError(E_POINTER, \
+                VirtualBoxBase::tr("Argument %s points to invalid memory location (%p)"), \
+                #arg, (void *)(arg)); \
+    } while (0)
+
+/**
+ * Checks that safe array argument is not NULL and returns E_INVALIDARG +
+ * extended error info on failure.
+ * @param arg   Input safe array argument (strings, interface pointers...)
+ */
+#define CheckComArgSafeArrayNotNull(arg) \
+    do { \
+        if (RT_LIKELY(!ComSafeArrayInIsNull(arg))) \
+        { /* likely */ }\
+        else \
+            return setError(E_INVALIDARG, \
+                            VirtualBoxBase::tr("Argument %s is NULL"), #arg); \
+    } while (0)
+
+/**
+ * Checks that a string input argument is valid (not NULL or obviously invalid
+ * pointer), returning E_INVALIDARG + extended error info if invalid.
+ * @param a_bstrIn  Input string argument (IN_BSTR).
+ */
+#define CheckComArgStr(a_bstrIn) \
+    do { \
+        IN_BSTR const bstrInCheck = (a_bstrIn); /* type check */ \
+        if (RT_LIKELY(RT_VALID_PTR(bstrInCheck))) \
+        { /* likely */ }\
+        else \
+            return setError(E_INVALIDARG, \
+                            VirtualBoxBase::tr("Argument %s is an invalid pointer"), #a_bstrIn); \
+    } while (0)
+/**
+ * Checks that the string argument is not a NULL, a invalid pointer or an empty
+ * string, returning E_INVALIDARG + extended error info on failure.
+ * @param a_bstrIn  Input string argument (BSTR etc.).
+ */
+#define CheckComArgStrNotEmptyOrNull(a_bstrIn) \
+    do { \
+        IN_BSTR const bstrInCheck = (a_bstrIn); /* type check */ \
+        if (RT_LIKELY(RT_VALID_PTR(bstrInCheck) && *(bstrInCheck) != '\0')) \
+        { /* likely */ }\
+        else \
+            return setError(E_INVALIDARG, \
+                            VirtualBoxBase::tr("Argument %s is empty or an invalid pointer"), \
+                            #a_bstrIn); \
+    } while (0)
+
+/**
+ * Converts the Guid input argument (string) to a Guid object, returns with
+ * E_INVALIDARG and error message on failure.
+ *
+ * @param a_Arg     Argument.
+ * @param a_GuidVar The Guid variable name.
+ */
+#define CheckComArgGuid(a_Arg, a_GuidVar) \
+    do { \
+        Guid tmpGuid(a_Arg); \
+        (a_GuidVar) = tmpGuid; \
+        if (RT_LIKELY((a_GuidVar).isValid())) \
+        { /* likely */ }\
+        else \
+            return setError(E_INVALIDARG, \
+                            VirtualBoxBase::tr("GUID argument %s is not valid (\"%ls\")"), \
+                            #a_Arg, Bstr(a_Arg).raw()); \
+    } while (0)
+
+/**
+ * Checks that the given expression (that must involve the argument) is true and
+ * returns E_INVALIDARG + extended error info on failure.
+ * @param arg   Argument.
+ * @param expr  Expression to evaluate.
+ */
+#define CheckComArgExpr(arg, expr) \
+    do { \
+        if (RT_LIKELY(!!(expr))) \
+        { /* likely */ }\
+        else \
+            return setError(E_INVALIDARG, \
+                            VirtualBoxBase::tr("Argument %s is invalid (must be %s)"), \
+                            #arg, #expr); \
+    } while (0)
+
+/**
+ * Checks that the given expression (that must involve the argument) is true and
+ * returns E_INVALIDARG + extended error info on failure. The error message must
+ * be customized.
+ * @param arg   Argument.
+ * @param expr  Expression to evaluate.
+ * @param msg   Parenthesized printf-like expression (must start with a verb,
+ *              like "must be one of...", "is not within...").
+ */
+#define CheckComArgExprMsg(arg, expr, msg) \
+    do { \
+        if (RT_LIKELY(!!(expr))) \
+        { /* likely */ }\
+        else \
+            return setError(E_INVALIDARG, VirtualBoxBase::tr("Argument %s %s"), \
+                            #arg, Utf8StrFmt msg .c_str()); \
+    } while (0)
+
+/**
+ * Checks that the given pointer to an output argument is valid and returns
+ * E_POINTER + extended error info otherwise.
+ * @param arg   Pointer argument.
+ */
+#define CheckComArgOutPointerValid(arg) \
+    do { \
+        if (RT_LIKELY(RT_VALID_PTR(arg))) \
+        { /* likely */ }\
+        else \
+            return setError(E_POINTER, \
+                            VirtualBoxBase::tr("Output argument %s points to invalid memory location (%p)"), \
+                            #arg, (void *)(arg)); \
+    } while (0)
+
+/**
+ * Checks that the given pointer to an output safe array argument is valid and
+ * returns E_POINTER + extended error info otherwise.
+ * @param arg   Safe array argument.
+ */
+#define CheckComArgOutSafeArrayPointerValid(arg) \
+    do { \
+        if (RT_LIKELY(!ComSafeArrayOutIsNull(arg))) \
+        { /* likely */ }\
+        else \
+            return setError(E_POINTER, \
+                            VirtualBoxBase::tr("Output argument %s points to invalid memory location (%p)"), \
+                            #arg, (void*)(arg)); \
+    } while (0)
+
+/**
+ * Sets the extended error info and returns E_NOTIMPL.
+ */
+#define ReturnComNotImplemented() \
+    do { \
+        return setError(E_NOTIMPL, VirtualBoxBase::tr("Method %s is not implemented"), __FUNCTION__); \
+    } while (0)
+
+/**
+ *  Declares an empty constructor and destructor for the given class.
+ *  This is useful to prevent the compiler from generating the default
+ *  ctor and dtor, which in turn allows to use forward class statements
+ *  (instead of including their header files) when declaring data members of
+ *  non-fundamental types with constructors (which are always called implicitly
+ *  by constructors and by the destructor of the class).
+ *
+ *  This macro is to be placed within (the public section of) the class
+ *  declaration. Its counterpart, DEFINE_EMPTY_CTOR_DTOR, must be placed
+ *  somewhere in one of the translation units (usually .cpp source files).
+ *
+ *  @param      cls     class to declare a ctor and dtor for
+ */
+#define DECLARE_EMPTY_CTOR_DTOR(cls) cls(); virtual ~cls();
+
+/**
+ *  Defines an empty constructor and destructor for the given class.
+ *  See DECLARE_EMPTY_CTOR_DTOR for more info.
+ */
+#define DEFINE_EMPTY_CTOR_DTOR(cls) \
+    cls::cls()  { /*empty*/ } \
+    cls::~cls() { /*empty*/ }
+
+/**
+ *  A variant of 'throw' that hits a debug breakpoint first to make
+ *  finding the actual thrower possible.
+ */
+#ifdef DEBUG
+# define DebugBreakThrow(a) \
+    do { \
+        RTAssertDebugBreak(); \
+        throw (a); \
+    } while (0)
+#else
+# define DebugBreakThrow(a) throw (a)
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// VirtualBoxBase
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifdef VBOX_WITH_MAIN_NLS
+# define DECLARE_TRANSLATE_METHODS(cls) \
+    static inline const char *tr(const char  *aSourceText, \
+                                 const char  *aComment = NULL, \
+                                 const size_t aNum = ~(size_t)0) \
+    { \
+        return VirtualBoxTranslator::translate(NULL, #cls, aSourceText, aComment, aNum); \
+    }
+#else
+# define DECLARE_TRANSLATE_METHODS(cls) \
+    static inline const char *tr(const char *aSourceText, \
+                                 const char *aComment = NULL, \
+                                 const size_t aNum = ~(size_t)0) \
+    { \
+        RT_NOREF(aComment, aNum); \
+        return aSourceText; \
+    }
+#endif
+
+#define DECLARE_COMMON_CLASS_METHODS(cls) \
+    DECLARE_EMPTY_CTOR_DTOR(cls) \
+    DECLARE_TRANSLATE_METHODS(cls)
+
+#define VIRTUALBOXBASE_ADD_VIRTUAL_COMPONENT_METHODS(cls, iface) \
+    virtual const IID& getClassIID() const \
+    { \
+        return cls::getStaticClassIID(); \
+    } \
+    static const IID& getStaticClassIID() \
+    { \
+        return COM_IIDOF(iface); \
+    } \
+    virtual const char* getComponentName() const \
+    { \
+        return cls::getStaticComponentName(); \
+    } \
+    static const char* getStaticComponentName() \
+    { \
+        return #cls; \
+    }
+
+/**
+ * VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT:
+ * This macro must be used once in the declaration of any class derived
+ * from VirtualBoxBase. It implements the pure virtual getClassIID() and
+ * getComponentName() methods. If this macro is not present, instances
+ * of a class derived from VirtualBoxBase cannot be instantiated.
+ *
+ * @param cls The class name, e.g. "Class".
+ * @param iface The interface name which this class implements, e.g. "IClass".
+ */
+#ifdef VBOX_WITH_XPCOM
+  #define VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(cls, iface) \
+    VIRTUALBOXBASE_ADD_VIRTUAL_COMPONENT_METHODS(cls, iface)
+#else // !VBOX_WITH_XPCOM
+  #define VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(cls, iface) \
+    VIRTUALBOXBASE_ADD_VIRTUAL_COMPONENT_METHODS(cls, iface) \
+    STDMETHOD(InterfaceSupportsErrorInfo)(REFIID riid) \
+    { \
+        const ATL::_ATL_INTMAP_ENTRY* pEntries = cls::_GetEntries(); \
+        Assert(pEntries); \
+        if (!pEntries) \
+            return S_FALSE; \
+        BOOL bSupports = FALSE; \
+        BOOL bISupportErrorInfoFound = FALSE; \
+        while (pEntries->pFunc != NULL && !bSupports) \
+        { \
+            if (!bISupportErrorInfoFound) \
+                bISupportErrorInfoFound = InlineIsEqualGUID(*(pEntries->piid), IID_ISupportErrorInfo); \
+            else \
+                bSupports = InlineIsEqualGUID(*(pEntries->piid), riid); \
+            pEntries++; \
+        } \
+        Assert(bISupportErrorInfoFound); \
+        return bSupports ? S_OK : S_FALSE; \
+    }
+#endif // !VBOX_WITH_XPCOM
+
+/**
+ * VBOX_TWEAK_INTERFACE_ENTRY:
+ * Macro for defining magic interface entries needed for all interfaces
+ * implemented by any subclass of VirtualBoxBase.
+ */
+#ifdef VBOX_WITH_XPCOM
+#define VBOX_TWEAK_INTERFACE_ENTRY(iface)
+#else // !VBOX_WITH_XPCOM
+#define VBOX_TWEAK_INTERFACE_ENTRY(iface)                                   \
+        COM_INTERFACE_ENTRY_AGGREGATE(IID_IMarshal, m_pUnkMarshaler.m_p)
+#endif // !VBOX_WITH_XPCOM
+
+
+/**
+ * Abstract base class for all component classes implementing COM
+ * interfaces of the VirtualBox COM library.
+ *
+ * Declares functionality that should be available in all components.
+ *
+ * The object state logic is documented in ObjectState.h.
+ */
+class ATL_NO_VTABLE VirtualBoxBase
+    : public Lockable
+    , public ATL::CComObjectRootEx<ATL::CComMultiThreadModel>
+#if !defined (VBOX_WITH_XPCOM)
+    , public ISupportErrorInfo
+#endif
+{
+protected:
+#ifdef RT_OS_WINDOWS
+     ComPtr<IUnknown> m_pUnkMarshaler;
+#endif
+
+     HRESULT BaseFinalConstruct();
+     void BaseFinalRelease();
+
+public:
+    DECLARE_COMMON_CLASS_METHODS(VirtualBoxBase)
+
+    /**
+     * Uninitialization method.
+     *
+     * Must be called by all final implementations (component classes) when the
+     * last reference to the object is released, before calling the destructor.
+     *
+     * @note Never call this method the AutoCaller scope or after the
+     *       ObjectState::addCaller() call not paired by
+     *       ObjectState::releaseCaller() because it is a guaranteed deadlock.
+     *       See AutoUninitSpan and AutoCaller.h/ObjectState.h for details.
+     */
+    virtual void uninit()
+    { }
+
+    /**
+     */
+    ObjectState &getObjectState()
+    {
+        return mState;
+    }
+
+    /**
+     * Pure virtual method for simple run-time type identification without
+     * having to enable C++ RTTI.
+     *
+     * This *must* be implemented by every subclass deriving from VirtualBoxBase;
+     * use the VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT macro to do that most easily.
+     */
+    virtual const IID& getClassIID() const = 0;
+
+    /**
+     * Pure virtual method for simple run-time type identification without
+     * having to enable C++ RTTI.
+     *
+     * This *must* be implemented by every subclass deriving from VirtualBoxBase;
+     * use the VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT macro to do that most easily.
+     */
+    virtual const char* getComponentName() const = 0;
+
+    /**
+     * Virtual method which determines the locking class to be used for validating
+     * lock order with the standard member lock handle. This method is overridden
+     * in a number of subclasses.
+     */
+    virtual VBoxLockingClass getLockingClass() const
+    {
+        return LOCKCLASS_OTHEROBJECT;
+    }
+
+    virtual RWLockHandle *lockHandle() const;
+
+    static HRESULT handleUnexpectedExceptions(VirtualBoxBase *const aThis, RT_SRC_POS_DECL);
+
+    static HRESULT setErrorInternalF(HRESULT aResultCode,
+                                     const GUID &aIID,
+                                     const char *aComponent,
+                                     bool aWarning,
+                                     bool aLogIt,
+                                     LONG aResultDetail,
+                                     const char *aText, ...);
+    static HRESULT setErrorInternalV(HRESULT aResultCode,
+                                     const GUID &aIID,
+                                     const char *aComponent,
+                                     const char *aText,
+                                     va_list aArgs,
+                                     bool aWarning,
+                                     bool aLogIt,
+                                     LONG aResultDetail = 0);
+    static void clearError(void);
+
+    HRESULT setError(HRESULT aResultCode);
+    HRESULT setError(HRESULT aResultCode, const char *pcsz, ...);
+    HRESULT setError(const ErrorInfo &ei);
+    HRESULT setErrorVrcV(int vrc, const char *pcszMsgFmt, va_list va_args);
+    HRESULT setErrorVrc(int vrc);
+    HRESULT setErrorVrc(int vrc, const char *pcszMsgFmt, ...);
+    HRESULT setErrorBoth(HRESULT hrc, int vrc);
+    HRESULT setErrorBoth(HRESULT hrc, int vrc, const char *pcszMsgFmt, ...);
+    HRESULT setWarning(HRESULT aResultCode, const char *pcsz, ...);
+    HRESULT setErrorNoLog(HRESULT aResultCode, const char *pcsz, ...);
+
+
+    /** Initialize COM for a new thread. */
+    static HRESULT initializeComForThread(void)
+    {
+#ifndef VBOX_WITH_XPCOM
+        HRESULT hrc = CoInitializeEx(NULL, COINIT_MULTITHREADED | COINIT_DISABLE_OLE1DDE | COINIT_SPEED_OVER_MEMORY);
+        AssertComRCReturn(hrc, hrc);
+#endif
+        return S_OK;
+    }
+
+    /** Uninitializes COM for a dying thread. */
+    static void uninitializeComForThread(void)
+    {
+#ifndef VBOX_WITH_XPCOM
+        CoUninitialize();
+#endif
+    }
+
+
+private:
+    /** Object for representing object state */
+    ObjectState mState;
+
+    /** User-level object lock for subclasses */
+    RWLockHandle *mObjectLock;
+
+    /** Slot of this object in the g_aClassFactoryStats array */
+    uint32_t iFactoryStat;
+
+private:
+    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(VirtualBoxBase); /* Shuts up MSC warning C4625. */
+};
+
+/** Structure for counting the currently existing and ever created objects
+ * for each component name. */
+typedef struct CLASSFACTORY_STAT
+{
+    const char *psz;
+    uint64_t current;
+    uint64_t overall;
+} CLASSFACTORY_STAT;
+
+/** Maximum number of component names to deal with. There will be debug
+ * assertions if the value is too low. Since the table is global and its
+ * entries are reasonably small, it's not worth squeezing out the last bit. */
+#define CLASSFACTORYSTATS_MAX 128
+
+/* global variables (defined in VirtualBoxBase.cpp) */
+extern CLASSFACTORY_STAT g_aClassFactoryStats[CLASSFACTORYSTATS_MAX];
+extern RWLockHandle *g_pClassFactoryStatsLock;
+
+extern void APIDumpComponentFactoryStats();
+
+/**
+ * Dummy macro that is used to shut down Qt's lupdate tool warnings in some
+ * situations. This macro needs to be present inside (better at the very
+ * beginning) of the declaration of the class that uses translation, to make
+ * lupdate happy.
+ */
+#define Q_OBJECT
+
+////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+
+
+/**
+ *  Simple template that manages data structure allocation/deallocation
+ *  and supports data pointer sharing (the instance that shares the pointer is
+ *  not responsible for memory deallocation as opposed to the instance that
+ *  owns it).
+ */
+template <class D>
+class Shareable
+{
+public:
+
+    Shareable() : mData(NULL), mIsShared(FALSE) {}
+    virtual ~Shareable() { free(); }
+
+    void allocate() { attach(new D); }
+
+    virtual void free() {
+        if (mData) {
+            if (!mIsShared)
+                delete mData;
+            mData = NULL;
+            mIsShared = false;
+        }
+    }
+
+    void attach(D *d) {
+        AssertMsg(d, ("new data must not be NULL"));
+        if (d && mData != d) {
+            if (mData && !mIsShared)
+                delete mData;
+            mData = d;
+            mIsShared = false;
+        }
+    }
+
+    void attach(Shareable &d) {
+        AssertMsg(
+            d.mData == mData || !d.mIsShared,
+            ("new data must not be shared")
+        );
+        if (this != &d && !d.mIsShared) {
+            attach(d.mData);
+            d.mIsShared = true;
+        }
+    }
+
+    void share(D *d) {
+        AssertMsg(d, ("new data must not be NULL"));
+        if (mData != d) {
+            if (mData && !mIsShared)
+                delete mData;
+            mData = d;
+            mIsShared = true;
+        }
+    }
+
+    void share(const Shareable &d) { share(d.mData); }
+
+    void attachCopy(const D *d) {
+        AssertMsg(d, ("data to copy must not be NULL"));
+        if (d)
+            attach(new D(*d));
+    }
+
+    void attachCopy(const Shareable &d) {
+        attachCopy(d.mData);
+    }
+
+    virtual D *detach() {
+        D *d = mData;
+        mData = NULL;
+        mIsShared = false;
+        return d;
+    }
+
+    D *data() const {
+        return mData;
+    }
+
+    D *operator->() const {
+        AssertMsg(mData, ("data must not be NULL"));
+        return mData;
+    }
+
+    bool isNull() const { return mData == NULL; }
+    bool operator!() const { return isNull(); }
+
+    bool isShared() const { return mIsShared; }
+
+protected:
+
+    D *mData;
+    bool mIsShared;
+};
+
+/**
+ *  Simple template that enhances Shareable<> and supports data
+ *  backup/rollback/commit (using the copy constructor of the managed data
+ *  structure).
+ */
+template<class D>
+class Backupable : public Shareable<D>
+{
+public:
+
+    Backupable() : Shareable<D>(), mBackupData(NULL) {}
+
+    void free()
+    {
+        AssertMsg(this->mData || !mBackupData, ("backup must be NULL if data is NULL"));
+        rollback();
+        Shareable<D>::free();
+    }
+
+    D *detach()
+    {
+        AssertMsg(this->mData || !mBackupData, ("backup must be NULL if data is NULL"));
+        rollback();
+        return Shareable<D>::detach();
+    }
+
+    void share(const Backupable &d)
+    {
+        AssertMsg(!d.isBackedUp(), ("data to share must not be backed up"));
+        if (!d.isBackedUp())
+            Shareable<D>::share(d.mData);
+    }
+
+    /**
+     *  Stores the current data pointer in the backup area, allocates new data
+     *  using the copy constructor on current data and makes new data active.
+     *
+     *  @deprecated Use backupEx to avoid throwing wild out-of-memory exceptions.
+     */
+    void backup()
+    {
+        AssertMsg(this->mData, ("data must not be NULL"));
+        if (this->mData && !mBackupData)
+        {
+            D *pNewData = new D(*this->mData);
+            mBackupData = this->mData;
+            this->mData = pNewData;
+        }
+    }
+
+    /**
+     *  Stores the current data pointer in the backup area, allocates new data
+     *  using the copy constructor on current data and makes new data active.
+     *
+     *  @returns S_OK, E_OUTOFMEMORY or E_FAIL (internal error).
+     */
+    HRESULT backupEx()
+    {
+        AssertMsgReturn(this->mData, ("data must not be NULL"), E_FAIL);
+        if (this->mData && !mBackupData)
+        {
+            try
+            {
+                D *pNewData = new D(*this->mData);
+                mBackupData = this->mData;
+                this->mData = pNewData;
+            }
+            catch (std::bad_alloc &)
+            {
+                return E_OUTOFMEMORY;
+            }
+        }
+        return S_OK;
+    }
+
+    /**
+     *  Deletes new data created by #backup() and restores previous data pointer
+     *  stored in the backup area, making it active again.
+     */
+    void rollback()
+    {
+        if (this->mData && mBackupData)
+        {
+            delete this->mData;
+            this->mData = mBackupData;
+            mBackupData = NULL;
+        }
+    }
+
+    /**
+     *  Commits current changes by deleting backed up data and clearing up the
+     *  backup area. The new data pointer created by #backup() remains active
+     *  and becomes the only managed pointer.
+     *
+     *  This method is much faster than #commitCopy() (just a single pointer
+     *  assignment operation), but makes the previous data pointer invalid
+     *  (because it is freed). For this reason, this method must not be
+     *  used if it's possible that data managed by this instance is shared with
+     *  some other Shareable instance. See #commitCopy().
+     */
+    void commit()
+    {
+        if (this->mData && mBackupData)
+        {
+            if (!this->mIsShared)
+                delete mBackupData;
+            mBackupData = NULL;
+            this->mIsShared = false;
+        }
+    }
+
+    /**
+     *  Commits current changes by assigning new data to the previous data
+     *  pointer stored in the backup area using the assignment operator.
+     *  New data is deleted, the backup area is cleared and the previous data
+     *  pointer becomes active and the only managed pointer.
+     *
+     *  This method is slower than #commit(), but it keeps the previous data
+     *  pointer valid (i.e. new data is copied to the same memory location).
+     *  For that reason it's safe to use this method on instances that share
+     *  managed data with other Shareable instances.
+     */
+    void commitCopy()
+    {
+        if (this->mData && mBackupData)
+        {
+            *mBackupData = *(this->mData);
+            delete this->mData;
+            this->mData = mBackupData;
+            mBackupData = NULL;
+        }
+    }
+
+    void assignCopy(const D *pData)
+    {
+        AssertMsg(this->mData, ("data must not be NULL"));
+        AssertMsg(pData, ("data to copy must not be NULL"));
+        if (this->mData && pData)
+        {
+            if (!mBackupData)
+            {
+                D *pNewData = new D(*pData);
+                mBackupData = this->mData;
+                this->mData = pNewData;
+            }
+            else
+                *this->mData = *pData;
+        }
+    }
+
+    void assignCopy(const Backupable &d)
+    {
+        assignCopy(d.mData);
+    }
+
+    bool isBackedUp() const
+    {
+        return mBackupData != NULL;
+    }
+
+    D *backedUpData() const
+    {
+        return mBackupData;
+    }
+
+protected:
+
+    D *mBackupData;
+};
+
+#endif /* !MAIN_INCLUDED_VirtualBoxBase_h */
+
diff --git a/src/VBox/Main/include/VirtualBoxClientImpl.h b/src/VBox/Main/include/VirtualBoxClientImpl.h
new file mode 100644
index 00000000..f7e40a69
--- /dev/null
+++ b/src/VBox/Main/include/VirtualBoxClientImpl.h
@@ -0,0 +1,144 @@
+/* $Id: VirtualBoxClientImpl.h $ */
+/** @file
+ * Header file for the VirtualBoxClient (IVirtualBoxClient) class, VBoxC.
+ */
+
+/*
+ * Copyright (C) 2010-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
+ */
+
+#ifndef MAIN_INCLUDED_VirtualBoxClientImpl_h
+#define MAIN_INCLUDED_VirtualBoxClientImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "VirtualBoxClientWrap.h"
+#include "EventImpl.h"
+#include "VirtualBoxTranslator.h"
+
+#ifdef RT_OS_WINDOWS
+# include "win/resource.h"
+#endif
+
+class ATL_NO_VTABLE VirtualBoxClient :
+    public VirtualBoxClientWrap
+#ifdef RT_OS_WINDOWS
+    , public ATL::CComCoClass<VirtualBoxClient, &CLSID_VirtualBoxClient>
+#endif
+{
+public:
+    DECLARE_CLASSFACTORY_SINGLETON(VirtualBoxClient)
+
+    // Do not use any ATL registry support.
+    //DECLARE_REGISTRY_RESOURCEID(IDR_VIRTUALBOX)
+
+    DECLARE_NOT_AGGREGATABLE(VirtualBoxClient)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init();
+    void uninit();
+
+#ifdef RT_OS_WINDOWS
+    /* HACK ALERT! Implemented in dllmain.cpp. */
+    ULONG InternalRelease();
+#endif
+
+private:
+    // wrapped IVirtualBoxClient properties
+    virtual HRESULT getVirtualBox(ComPtr<IVirtualBox> &aVirtualBox);
+    virtual HRESULT getSession(ComPtr<ISession> &aSession);
+    virtual HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
+
+    // wrapped IVirtualBoxClient methods
+    virtual HRESULT checkMachineError(const ComPtr<IMachine> &aMachine);
+
+    /** Instance counter for simulating something similar to a singleton.
+     * Only the first instance will be a usable object, all additional
+     * instances will return a failure at creation time and will not work. */
+    static uint32_t g_cInstances;
+
+#ifdef RT_OS_WINDOWS
+    virtual HRESULT i_investigateVirtualBoxObjectCreationFailure(HRESULT hrc);
+#endif
+
+#ifdef VBOX_WITH_SDS
+    int     i_getServiceAccountAndStartType(const wchar_t *pwszServiceName,
+                                            wchar_t *pwszAccountName, size_t cwcAccountName, uint32_t *puStartType);
+#endif
+
+    static DECLCALLBACK(int) SVCWatcherThread(RTTHREAD ThreadSelf, void *pvUser);
+
+    struct Data
+    {
+        Data()
+            : m_ThreadWatcher(NIL_RTTHREAD)
+            , m_SemEvWatcher(NIL_RTSEMEVENT)
+#ifdef VBOX_WITH_MAIN_NLS
+            , m_pVBoxTranslator(NULL)
+            , m_pTrComponent(NULL)
+#endif
+        {}
+
+        ~Data()
+        {
+            /* HACK ALERT! This is for DllCanUnloadNow(). */
+            if (m_pEventSource.isNotNull())
+            {
+                s_cUnnecessaryAtlModuleLocks--;
+                AssertMsg(s_cUnnecessaryAtlModuleLocks == 0, ("%d\n", s_cUnnecessaryAtlModuleLocks));
+            }
+        }
+
+        ComPtr<IVirtualBox> m_pVirtualBox;
+        ComPtr<IToken> m_pToken;
+        const ComObjPtr<EventSource> m_pEventSource;
+        ComPtr<IEventSource> m_pVBoxEventSource;
+        ComPtr<IEventListener> m_pVBoxEventListener;
+
+        RTTHREAD m_ThreadWatcher;
+        RTSEMEVENT m_SemEvWatcher;
+#ifdef VBOX_WITH_MAIN_NLS
+        VirtualBoxTranslator *m_pVBoxTranslator;
+        PTRCOMPONENT          m_pTrComponent;
+#endif
+    };
+
+    Data mData;
+
+public:
+    /** Hack for discounting the AtlModule lock held by Data::m_pEventSource during
+     * DllCanUnloadNow().  This is incremented to 1 when init() initialized
+     * m_pEventSource and is decremented by the Data destructor (above). */
+    static LONG s_cUnnecessaryAtlModuleLocks;
+
+#ifdef VBOX_WITH_MAIN_NLS
+    HRESULT i_reloadApiLanguage();
+    HRESULT i_registerEventListener();
+    void    i_unregisterEventListener();
+#endif
+};
+
+#endif /* !MAIN_INCLUDED_VirtualBoxClientImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/VirtualBoxErrorInfoImpl.h b/src/VBox/Main/include/VirtualBoxErrorInfoImpl.h
new file mode 100644
index 00000000..6f6e9ef5
--- /dev/null
+++ b/src/VBox/Main/include/VirtualBoxErrorInfoImpl.h
@@ -0,0 +1,175 @@
+/* $Id: VirtualBoxErrorInfoImpl.h $ */
+/** @file
+ * VirtualBoxErrorInfo COM class definition.
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_VirtualBoxErrorInfoImpl_h
+#define MAIN_INCLUDED_VirtualBoxErrorInfoImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "VirtualBoxBase.h"
+
+using namespace com;
+
+class ATL_NO_VTABLE VirtualBoxErrorInfo
+    : public ATL::CComObjectRootEx<ATL::CComMultiThreadModel>
+    , VBOX_SCRIPTABLE_IMPL(IVirtualBoxErrorInfo)
+#ifndef VBOX_WITH_XPCOM /* IErrorInfo doesn't inherit from IDispatch, ugly 3am hack: */
+    , public IDispatch
+#endif
+{
+public:
+
+    DECLARE_NOT_AGGREGATABLE(VirtualBoxErrorInfo)
+
+    DECLARE_PROTECT_FINAL_CONSTRUCT()
+
+    BEGIN_COM_MAP(VirtualBoxErrorInfo)
+        COM_INTERFACE_ENTRY(IErrorInfo)
+        COM_INTERFACE_ENTRY(IVirtualBoxErrorInfo)
+        COM_INTERFACE_ENTRY(IDispatch)
+        COM_INTERFACE_ENTRY_AGGREGATE(IID_IMarshal, m_pUnkMarshaler)
+    END_COM_MAP()
+
+    DECLARE_TRANSLATE_METHODS(VirtualBoxErrorInfo)
+
+    HRESULT FinalConstruct()
+    {
+#ifndef VBOX_WITH_XPCOM
+        return CoCreateFreeThreadedMarshaler((IUnknown *)(void *)this, &m_pUnkMarshaler);
+#else
+        return S_OK;
+#endif
+    }
+
+    void FinalRelease()
+    {
+#ifndef VBOX_WITH_XPCOM
+        if (m_pUnkMarshaler)
+        {
+            m_pUnkMarshaler->Release();
+            m_pUnkMarshaler = NULL;
+        }
+#endif
+    }
+
+#ifndef VBOX_WITH_XPCOM
+
+    HRESULT init(IErrorInfo *aInfo);
+
+    STDMETHOD(GetGUID)(GUID *guid);
+    STDMETHOD(GetSource)(BSTR *pBstrSource);
+    STDMETHOD(GetDescription)(BSTR *description);
+    STDMETHOD(GetHelpFile)(BSTR *pBstrHelpFile);
+    STDMETHOD(GetHelpContext)(DWORD *pdwHelpContext);
+
+    // IDispatch forwarding - 3am hack.
+    typedef IDispatchImpl<IVirtualBoxErrorInfo, &IID_IVirtualBoxErrorInfo, &LIBID_VirtualBox, kTypeLibraryMajorVersion, kTypeLibraryMinorVersion> idi;
+
+    STDMETHOD(GetTypeInfoCount)(UINT *pcInfo)
+    {
+        return idi::GetTypeInfoCount(pcInfo);
+    }
+
+    STDMETHOD(GetTypeInfo)(UINT iInfo, LCID Lcid, ITypeInfo **ppTypeInfo)
+    {
+        return idi::GetTypeInfo(iInfo, Lcid, ppTypeInfo);
+    }
+
+    STDMETHOD(GetIDsOfNames)(REFIID rIID, LPOLESTR *papwszNames, UINT cNames, LCID Lcid, DISPID *paDispIDs)
+    {
+        return idi::GetIDsOfNames(rIID, papwszNames, cNames, Lcid, paDispIDs);
+    }
+
+    STDMETHOD(Invoke)(DISPID idDispMember, REFIID rIID, LCID Lcid, WORD fw, DISPPARAMS *pDispParams,
+                      VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *piErrArg)
+    {
+        return idi::Invoke(idDispMember, rIID, Lcid, fw, pDispParams, pVarResult, pExcepInfo, piErrArg);
+    }
+
+#else // defined(VBOX_WITH_XPCOM)
+
+    HRESULT init(nsIException *aInfo);
+
+    NS_DECL_NSIEXCEPTION
+
+#endif
+
+    VirtualBoxErrorInfo()
+        : m_resultCode(S_OK),
+          m_resultDetail(0)
+    {}
+    virtual ~VirtualBoxErrorInfo() {}
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init(HRESULT aResultCode,
+                 const GUID &aIID,
+                 const char *pcszComponent,
+                 const Utf8Str &strText,
+                 IVirtualBoxErrorInfo *aNext = NULL);
+
+    HRESULT initEx(HRESULT aResultCode,
+                   LONG aResultDetail,
+                   const GUID &aIID,
+                   const char *pcszComponent,
+                   const Utf8Str &strText,
+                   IVirtualBoxErrorInfo *aNext = NULL);
+
+    HRESULT init(const com::ErrorInfo &ei,
+                 IVirtualBoxErrorInfo *aNext = NULL);
+
+    // IVirtualBoxErrorInfo properties
+    STDMETHOD(COMGETTER(ResultCode))(LONG *aResultCode);
+    STDMETHOD(COMGETTER(ResultDetail))(LONG *aResultDetail);
+    STDMETHOD(COMGETTER(InterfaceID))(BSTR *aIID);
+    STDMETHOD(COMGETTER(Component))(BSTR *aComponent);
+    STDMETHOD(COMGETTER(Text))(BSTR *aText);
+    STDMETHOD(COMGETTER(Next))(IVirtualBoxErrorInfo **aNext);
+
+    const char* getComponentName() const { return "VirtualBoxErrorInfo"; }
+
+private:
+    static HRESULT setError(HRESULT rc,
+                            const char * /* a */,
+                            const char * /* b */,
+                            void *       /* c */) { return rc; }
+
+    HRESULT m_resultCode;
+    LONG    m_resultDetail;
+    Utf8Str m_strText;
+    Guid    m_IID;
+    Utf8Str m_strComponent;
+    ComPtr<IVirtualBoxErrorInfo> mNext;
+
+#ifndef VBOX_WITH_XPCOM
+    IUnknown *m_pUnkMarshaler;
+#endif
+};
+
+#endif /* !MAIN_INCLUDED_VirtualBoxErrorInfoImpl_h */
+
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/VirtualBoxImpl.h b/src/VBox/Main/include/VirtualBoxImpl.h
new file mode 100644
index 00000000..e75f11f0
--- /dev/null
+++ b/src/VBox/Main/include/VirtualBoxImpl.h
@@ -0,0 +1,502 @@
+/* $Id: VirtualBoxImpl.h $ */
+/** @file
+ * VirtualBox COM class implementation
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef MAIN_INCLUDED_VirtualBoxImpl_h
+#define MAIN_INCLUDED_VirtualBoxImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/VBoxCryptoIf.h>
+
+#include "VirtualBoxBase.h"
+#include "objectslist.h"
+#include "VirtualBoxWrap.h"
+
+#ifdef RT_OS_WINDOWS
+# include "win/resource.h"
+#endif
+
+//#ifdef DEBUG_bird
+//# define VBOXSVC_WITH_CLIENT_WATCHER
+//#endif
+
+namespace com
+{
+    class Event;
+    class EventQueue;
+}
+
+class SessionMachine;
+class GuestOSType;
+class Progress;
+class Host;
+class SystemProperties;
+class DHCPServer;
+class PerformanceCollector;
+class CloudProviderManager;
+#ifdef VBOX_WITH_EXTPACK
+class ExtPackManager;
+#endif
+class AutostartDb;
+class NATNetwork;
+#ifdef VBOX_WITH_CLOUD_NET
+class CloudNetwork;
+#endif /* VBOX_WITH_CLOUD_NET */
+
+
+typedef std::list<ComObjPtr<SessionMachine> > SessionMachinesList;
+
+#ifdef RT_OS_WINDOWS
+class SVCHlpClient;
+#endif
+
+namespace settings
+{
+    class MainConfigFile;
+    struct MediaRegistry;
+}
+
+
+#if defined(VBOX_WITH_SDS) && !defined(VBOX_WITH_XPCOM)
+class VirtualBoxClassFactory; /* See ../src-server/win/svcmain.cpp  */
+#endif
+
+class ATL_NO_VTABLE VirtualBox :
+    public VirtualBoxWrap
+#ifdef RT_OS_WINDOWS
+     , public ATL::CComCoClass<VirtualBox, &CLSID_VirtualBox>
+#endif
+{
+
+public:
+
+    typedef std::list<ComPtr<IInternalSessionControl> > InternalControlList;
+    typedef ObjectsList<Machine> MachinesOList;
+
+#if 0 /* obsoleted by AsyncEvent */
+    class CallbackEvent;
+    friend class CallbackEvent;
+#endif
+    class AsyncEvent;
+    friend class AsyncEvent;
+
+#ifndef VBOX_WITH_XPCOM
+# ifdef VBOX_WITH_SDS
+    DECLARE_CLASSFACTORY_EX(VirtualBoxClassFactory)
+# else
+    DECLARE_CLASSFACTORY_SINGLETON(VirtualBox)
+# endif
+#endif
+
+    // Do not use any ATL registry support.
+    //DECLARE_REGISTRY_RESOURCEID(IDR_VIRTUALBOX)
+
+    // Kind of redundant (VirtualBoxWrap declares itself not aggregatable and
+    // CComCoClass<VirtualBox, &CLSID_VirtualBox> as aggregatable, the former
+    // is the first inheritance), but the C++ multiple inheritance rules and
+    // the class factory in svcmain.cpp needs this to disambiguate.
+    DECLARE_NOT_AGGREGATABLE(VirtualBox)
+
+    // to postpone generation of the default ctor/dtor
+    DECLARE_COMMON_CLASS_METHODS(VirtualBox)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+    HRESULT init();
+    HRESULT initMachines();
+    HRESULT initMedia(const Guid &uuidMachineRegistry,
+                      const settings::MediaRegistry &mediaRegistry,
+                      const Utf8Str &strMachineFolder);
+    void uninit();
+
+    // public methods only for internal purposes
+
+    /**
+     * Override of the default locking class to be used for validating lock
+     * order with the standard member lock handle.
+     */
+    virtual VBoxLockingClass getLockingClass() const
+    {
+        return LOCKCLASS_VIRTUALBOXOBJECT;
+    }
+
+#ifdef DEBUG
+    void i_dumpAllBackRefs();
+#endif
+
+    HRESULT i_postEvent(Event *event);
+
+    HRESULT i_addProgress(IProgress *aProgress);
+    HRESULT i_removeProgress(IN_GUID aId);
+
+#ifdef RT_OS_WINDOWS
+    typedef HRESULT (*PFN_SVC_HELPER_CLIENT_T)(SVCHlpClient *aClient, Progress *aProgress, void *aUser, int *aVrc);
+    HRESULT i_startSVCHelperClient(bool aPrivileged,
+                                   PFN_SVC_HELPER_CLIENT_T aFunc,
+                                   void *aUser, Progress *aProgress);
+#endif
+
+    void i_addProcessToReap(RTPROCESS pid);
+    void i_updateClientWatcher();
+
+    int i_loadVDPlugin(const char *pszPluginLibrary);
+    int i_unloadVDPlugin(const char *pszPluginLibrary);
+
+    void i_onMediumRegistered(const Guid &aMediumId, const DeviceType_T aDevType, BOOL aRegistered);
+    void i_onMediumConfigChanged(IMedium *aMedium);
+    void i_onMediumChanged(IMediumAttachment* aMediumAttachment);
+    void i_onStorageControllerChanged(const Guid &aMachineId, const com::Utf8Str &aControllerName);
+    void i_onStorageDeviceChanged(IMediumAttachment* aStorageDevice, BOOL fRemoved, BOOL fSilent);
+    void i_onMachineStateChanged(const Guid &aId, MachineState_T aState);
+    void i_onMachineDataChanged(const Guid &aId, BOOL aTemporary = FALSE);
+    void i_onMachineGroupsChanged(const Guid &aId);
+    BOOL i_onExtraDataCanChange(const Guid &aId, const Utf8Str &aKey, const Utf8Str &aValue, Bstr &aError);
+    void i_onExtraDataChanged(const Guid &aId, const Utf8Str &aKey, const Utf8Str &aValue);
+    void i_onMachineRegistered(const Guid &aId, BOOL aRegistered);
+    void i_onSessionStateChanged(const Guid &aId, SessionState_T aState);
+
+    void i_onSnapshotTaken(const Guid &aMachineId, const Guid &aSnapshotId);
+    void i_onSnapshotDeleted(const Guid &aMachineId, const Guid &aSnapshotId);
+    void i_onSnapshotRestored(const Guid &aMachineId, const Guid &aSnapshotId);
+    void i_onSnapshotChanged(const Guid &aMachineId, const Guid &aSnapshotId);
+
+    void i_onGuestPropertyChanged(const Guid &aMachineId, const Utf8Str &aName, const Utf8Str &aValue, const Utf8Str &aFlags,
+                                  const BOOL fWasDeleted);
+    void 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);
+    void i_onNATNetworkChanged(const Utf8Str &aNetworkName);
+    void i_onNATNetworkStartStop(const Utf8Str &aNetworkName, BOOL aStart);
+    void i_onNATNetworkSetting(const Utf8Str &aNetworkName, BOOL aEnabled, const Utf8Str &aNetwork,
+                               const Utf8Str &aGateway, BOOL aAdvertiseDefaultIpv6RouteEnabled,
+                               BOOL fNeedDhcpServer);
+    void 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);
+    void i_onHostNameResolutionConfigurationChange();
+
+    int i_natNetworkRefInc(const Utf8Str &aNetworkName);
+    int i_natNetworkRefDec(const Utf8Str &aNetworkName);
+
+    RWLockHandle *i_getNatNetLock() const;
+    bool i_isNatNetStarted(const Utf8Str &aNetworkName) const;
+
+    void i_onCloudProviderListChanged(BOOL aRegistered);
+    void i_onCloudProviderRegistered(const Utf8Str &aProviderId, BOOL aRegistered);
+    void i_onCloudProviderUninstall(const Utf8Str &aProviderId);
+
+    void i_onProgressCreated(const Guid &aId, BOOL aCreated);
+
+    void i_onLanguageChanged(const Utf8Str &aLanguageId);
+
+#ifdef VBOX_WITH_UPDATE_AGENT
+    void i_onUpdateAgentAvailable(IUpdateAgent *aAgent,
+                                  const Utf8Str &aVer, UpdateChannel_T aChannel, UpdateSeverity_T aSev,
+                                  const Utf8Str &aDownloadURL, const Utf8Str &aWebURL, const Utf8Str &aReleaseNotes);
+    void i_onUpdateAgentError(IUpdateAgent *aAgent, const Utf8Str &aErrMsg, LONG aRc);
+    void i_onUpdateAgentStateChanged(IUpdateAgent *aAgent, UpdateState_T aState);
+    void i_onUpdateAgentSettingsChanged(IUpdateAgent *aAgent, const Utf8Str &aAttributeHint);
+#endif /* VBOX_WITH_UPDATE_AGENT */
+
+#ifdef VBOX_WITH_CLOUD_NET
+    HRESULT i_findCloudNetworkByName(const com::Utf8Str &aNetworkName,
+                                     ComObjPtr<CloudNetwork> *aNetwork = NULL);
+    HRESULT i_getEventSource(ComPtr<IEventSource>& aSource);
+#endif /* VBOX_WITH_CLOUD_NET */
+
+    ComObjPtr<GuestOSType> i_getUnknownOSType();
+
+    void i_getOpenedMachines(SessionMachinesList &aMachines,
+                           InternalControlList *aControls = NULL);
+    MachinesOList &i_getMachinesList();
+
+    HRESULT i_findMachine(const Guid &aId,
+                          bool fPermitInaccessible,
+                          bool aSetError,
+                          ComObjPtr<Machine> *aMachine = NULL);
+
+    HRESULT i_findMachineByName(const Utf8Str &aName,
+                                bool aSetError,
+                                ComObjPtr<Machine> *aMachine = NULL);
+
+    HRESULT i_validateMachineGroup(const com::Utf8Str &aGroup, bool fPrimary);
+    HRESULT i_convertMachineGroups(const std::vector<com::Utf8Str> aMachineGroups, StringsList *pllMachineGroups);
+
+    HRESULT i_findHardDiskById(const Guid &id,
+                               bool aSetError,
+                               ComObjPtr<Medium> *aHardDisk = NULL);
+    HRESULT i_findHardDiskByLocation(const Utf8Str &strLocation,
+                                     bool aSetError,
+                                     ComObjPtr<Medium> *aHardDisk = NULL);
+    HRESULT i_findDVDOrFloppyImage(DeviceType_T mediumType,
+                                   const Guid *aId,
+                                   const Utf8Str &aLocation,
+                                   bool aSetError,
+                                   ComObjPtr<Medium> *aImage = NULL);
+    HRESULT i_findRemoveableMedium(DeviceType_T mediumType,
+                                   const Guid &uuid,
+                                   bool fRefresh,
+                                   bool aSetError,
+                                   ComObjPtr<Medium> &pMedium);
+
+    HRESULT i_findGuestOSType(const Utf8Str &strOSType,
+                              ComObjPtr<GuestOSType> &guestOSType);
+
+    const Guid &i_getGlobalRegistryId() const;
+
+    const ComObjPtr<Host> &i_host() const;
+    SystemProperties *i_getSystemProperties() const;
+    CloudProviderManager *i_getCloudProviderManager() const;
+#ifdef VBOX_WITH_EXTPACK
+    ExtPackManager *i_getExtPackManager() const;
+#endif
+#ifdef VBOX_WITH_RESOURCE_USAGE_API
+    const ComObjPtr<PerformanceCollector> &i_performanceCollector() const;
+#endif /* VBOX_WITH_RESOURCE_USAGE_API */
+
+    void i_getDefaultMachineFolder(Utf8Str &str) const;
+    void i_getDefaultHardDiskFormat(Utf8Str &str) const;
+
+    /** Returns the VirtualBox home directory */
+    const Utf8Str &i_homeDir() const;
+    int i_calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult);
+    void i_copyPathRelativeToConfig(const Utf8Str &strSource, Utf8Str &strTarget);
+    HRESULT i_registerMedium(const ComObjPtr<Medium> &pMedium, ComObjPtr<Medium> *ppMedium,
+                             AutoWriteLock &mediaTreeLock, bool fCalledFromMediumInit = false);
+    HRESULT i_unregisterMedium(Medium *pMedium);
+    HRESULT i_unregisterMachineMedia(const Guid &id);
+    HRESULT i_unregisterMachine(Machine *pMachine, CleanupMode_T aCleanupMode, const Guid &id);
+    void i_rememberMachineNameChangeForMedia(const Utf8Str &strOldConfigDir,
+                                             const Utf8Str &strNewConfigDir);
+    void i_saveMediaRegistry(settings::MediaRegistry &mediaRegistry,
+                             const Guid &uuidRegistry,
+                             const Utf8Str &strMachineFolder);
+    HRESULT i_saveSettings();
+    void i_markRegistryModified(const Guid &uuid);
+    void i_unmarkRegistryModified(const Guid &uuid);
+    void i_saveModifiedRegistries();
+    static const com::Utf8Str &i_getVersionNormalized();
+    static HRESULT i_ensureFilePathExists(const Utf8Str &strFileName, bool fCreate);
+    const Utf8Str& i_settingsFilePath();
+    AutostartDb* i_getAutostartDb() const;
+    RWLockHandle& i_getMachinesListLockHandle();
+    RWLockHandle& i_getMediaTreeLockHandle();
+    int  i_encryptSetting(const Utf8Str &aPlaintext, Utf8Str *aCiphertext);
+    int  i_decryptSetting(Utf8Str *aPlaintext, const Utf8Str &aCiphertext);
+    void i_storeSettingsKey(const Utf8Str &aKey);
+    bool i_isMediaUuidInUse(const Guid &aId, DeviceType_T deviceType);
+    HRESULT i_retainCryptoIf(PCVBOXCRYPTOIF *ppCryptoIf);
+    HRESULT i_releaseCryptoIf(PCVBOXCRYPTOIF pCryptoIf);
+    HRESULT i_unloadCryptoIfModule(void);
+
+
+
+private:
+    class ClientWatcher;
+
+    // wrapped IVirtualBox properties
+    HRESULT getVersion(com::Utf8Str &aVersion);
+    HRESULT getVersionNormalized(com::Utf8Str &aVersionNormalized);
+    HRESULT getRevision(ULONG *aRevision);
+    HRESULT getPackageType(com::Utf8Str &aPackageType);
+    HRESULT getAPIVersion(com::Utf8Str &aAPIVersion);
+    HRESULT getAPIRevision(LONG64 *aAPIRevision);
+    HRESULT getHomeFolder(com::Utf8Str &aHomeFolder);
+    HRESULT getSettingsFilePath(com::Utf8Str &aSettingsFilePath);
+    HRESULT getHost(ComPtr<IHost> &aHost);
+    HRESULT getSystemProperties(ComPtr<ISystemProperties> &aSystemProperties);
+    HRESULT getMachines(std::vector<ComPtr<IMachine> > &aMachines);
+    HRESULT getMachineGroups(std::vector<com::Utf8Str> &aMachineGroups);
+    HRESULT getHardDisks(std::vector<ComPtr<IMedium> > &aHardDisks);
+    HRESULT getDVDImages(std::vector<ComPtr<IMedium> > &aDVDImages);
+    HRESULT getFloppyImages(std::vector<ComPtr<IMedium> > &aFloppyImages);
+    HRESULT getProgressOperations(std::vector<ComPtr<IProgress> > &aProgressOperations);
+    HRESULT getGuestOSTypes(std::vector<ComPtr<IGuestOSType> > &aGuestOSTypes);
+    HRESULT getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders);
+    HRESULT getPerformanceCollector(ComPtr<IPerformanceCollector> &aPerformanceCollector);
+    HRESULT getDHCPServers(std::vector<ComPtr<IDHCPServer> > &aDHCPServers);
+    HRESULT getNATNetworks(std::vector<ComPtr<INATNetwork> > &aNATNetworks);
+    HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
+    HRESULT getExtensionPackManager(ComPtr<IExtPackManager> &aExtensionPackManager);
+    HRESULT getHostOnlyNetworks(std::vector<ComPtr<IHostOnlyNetwork> > &aHostOnlyNetworks);
+    HRESULT getInternalNetworks(std::vector<com::Utf8Str> &aInternalNetworks);
+    HRESULT getGenericNetworkDrivers(std::vector<com::Utf8Str> &aGenericNetworkDrivers);
+    HRESULT getCloudNetworks(std::vector<ComPtr<ICloudNetwork> > &aCloudNetworks);
+    HRESULT getCloudProviderManager(ComPtr<ICloudProviderManager> &aCloudProviderManager);
+
+   // wrapped IVirtualBox methods
+    HRESULT composeMachineFilename(const com::Utf8Str &aName,
+                                   const com::Utf8Str &aGroup,
+                                   const com::Utf8Str &aCreateFlags,
+                                   const com::Utf8Str &aBaseFolder,
+                                   com::Utf8Str &aFile);
+    HRESULT 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);
+    HRESULT openMachine(const com::Utf8Str &aSettingsFile,
+                        const com::Utf8Str &aPassword,
+                        ComPtr<IMachine> &aMachine);
+    HRESULT registerMachine(const ComPtr<IMachine> &aMachine);
+    HRESULT findMachine(const com::Utf8Str &aNameOrId,
+                        ComPtr<IMachine> &aMachine);
+    HRESULT getMachinesByGroups(const std::vector<com::Utf8Str> &aGroups,
+                                std::vector<ComPtr<IMachine> > &aMachines);
+    HRESULT getMachineStates(const std::vector<ComPtr<IMachine> > &aMachines,
+                             std::vector<MachineState_T> &aStates);
+    HRESULT createAppliance(ComPtr<IAppliance> &aAppliance);
+    HRESULT createUnattendedInstaller(ComPtr<IUnattended> &aUnattended);
+    HRESULT createMedium(const com::Utf8Str &aFormat,
+                         const com::Utf8Str &aLocation,
+                         AccessMode_T aAccessMode,
+                         DeviceType_T aDeviceType,
+                         ComPtr<IMedium> &aMedium);
+    HRESULT openMedium(const com::Utf8Str &aLocation,
+                       DeviceType_T aDeviceType,
+                       AccessMode_T aAccessMode,
+                       BOOL aForceNewUuid,
+                       ComPtr<IMedium> &aMedium);
+    HRESULT getGuestOSType(const com::Utf8Str &aId,
+                           ComPtr<IGuestOSType> &aType);
+    HRESULT createSharedFolder(const com::Utf8Str &aName,
+                               const com::Utf8Str &aHostPath,
+                               BOOL aWritable,
+                               BOOL aAutomount,
+                               const com::Utf8Str &aAutoMountPoint);
+    HRESULT removeSharedFolder(const com::Utf8Str &aName);
+    HRESULT getExtraDataKeys(std::vector<com::Utf8Str> &aKeys);
+    HRESULT getExtraData(const com::Utf8Str &aKey,
+                         com::Utf8Str &aValue);
+    HRESULT setExtraData(const com::Utf8Str &aKey,
+                         const com::Utf8Str &aValue);
+    HRESULT setSettingsSecret(const com::Utf8Str &aPassword);
+    HRESULT createDHCPServer(const com::Utf8Str &aName,
+                             ComPtr<IDHCPServer> &aServer);
+    HRESULT findDHCPServerByNetworkName(const com::Utf8Str &aName,
+                                        ComPtr<IDHCPServer> &aServer);
+    HRESULT removeDHCPServer(const ComPtr<IDHCPServer> &aServer);
+    HRESULT createNATNetwork(const com::Utf8Str &aNetworkName,
+                             ComPtr<INATNetwork> &aNetwork);
+    HRESULT findNATNetworkByName(const com::Utf8Str &aNetworkName,
+                                 ComPtr<INATNetwork> &aNetwork);
+    HRESULT removeNATNetwork(const ComPtr<INATNetwork> &aNetwork);
+    HRESULT createHostOnlyNetwork(const com::Utf8Str &aNetworkName,
+                                  ComPtr<IHostOnlyNetwork> &aNetwork);
+    HRESULT findHostOnlyNetworkByName(const com::Utf8Str &aNetworkName,
+                                     ComPtr<IHostOnlyNetwork> &aNetwork);
+    HRESULT findHostOnlyNetworkById(const com::Guid &aId,
+                                   ComPtr<IHostOnlyNetwork> &aNetwork);
+    HRESULT removeHostOnlyNetwork(const ComPtr<IHostOnlyNetwork> &aNetwork);
+    HRESULT createCloudNetwork(const com::Utf8Str &aNetworkName,
+                               ComPtr<ICloudNetwork> &aNetwork);
+    HRESULT findCloudNetworkByName(const com::Utf8Str &aNetworkName,
+                                   ComPtr<ICloudNetwork> &aNetwork);
+    HRESULT removeCloudNetwork(const ComPtr<ICloudNetwork> &aNetwork);
+    HRESULT checkFirmwarePresent(FirmwareType_T aFirmwareType,
+                                 const com::Utf8Str &aVersion,
+                                 com::Utf8Str &aUrl,
+                                 com::Utf8Str &aFile,
+                                 BOOL *aResult);
+    HRESULT findProgressById(const com::Guid &aId,
+                             ComPtr<IProgress> &aProgressObject);
+
+    static HRESULT i_setErrorStaticBoth(HRESULT aResultCode, int vrc, const char *aText, ...)
+    {
+        va_list va;
+        va_start (va, aText);
+        HRESULT hrc = setErrorInternalV(aResultCode, getStaticClassIID(), getStaticComponentName(), aText, va, false, true, vrc);
+        va_end(va);
+        return hrc;
+    }
+
+    HRESULT i_registerMachine(Machine *aMachine);
+    HRESULT i_registerDHCPServer(DHCPServer *aDHCPServer,
+                                 bool aSaveRegistry = true);
+    HRESULT i_unregisterDHCPServer(DHCPServer *aDHCPServer);
+    HRESULT i_registerNATNetwork(NATNetwork *aNATNetwork,
+                                 bool aSaveRegistry = true);
+    HRESULT i_unregisterNATNetwork(NATNetwork *aNATNetwork,
+                                   bool aSaveRegistry = true);
+    HRESULT i_checkMediaForConflicts(const Guid &aId,
+                                     const Utf8Str &aLocation,
+                                     Utf8Str &aConflictType,
+                                     ComObjPtr<Medium> *pDupMedium);
+    int  i_decryptSettings();
+    int  i_decryptMediumSettings(Medium *pMedium);
+    int  i_decryptSettingBytes(uint8_t *aPlaintext,
+                               const uint8_t *aCiphertext,
+                               size_t aCiphertextSize) const;
+    int  i_encryptSettingBytes(const uint8_t *aPlaintext,
+                               uint8_t *aCiphertext,
+                               size_t aPlaintextSize,
+                               size_t aCiphertextSize) const;
+    void i_reportDriverVersions(void);
+
+    struct Data;            // opaque data structure, defined in VirtualBoxImpl.cpp
+
+    Data *m;
+
+    /* static variables (defined in VirtualBoxImpl.cpp) */
+    static com::Utf8Str sVersion;
+    static com::Utf8Str sVersionNormalized;
+    static ULONG sRevision;
+    static com::Utf8Str sPackageType;
+    static com::Utf8Str sAPIVersion;
+    static std::map<com::Utf8Str, int> sNatNetworkNameToRefCount;
+    static RWLockHandle* spMtxNatNetworkNameToRefCountLock;
+
+    static DECLCALLBACK(int) AsyncEventHandler(RTTHREAD thread, void *pvUser);
+
+#ifdef RT_OS_WINDOWS
+    friend class StartSVCHelperClientData;
+    static void i_SVCHelperClientThreadTask(StartSVCHelperClientData *pTask);
+#endif
+
+#if defined(RT_OS_WINDOWS) && defined(VBOXSVC_WITH_CLIENT_WATCHER)
+protected:
+    void i_callHook(const char *a_pszFunction) RT_OVERRIDE;
+    bool i_watchClientProcess(RTPROCESS a_pidClient, const char *a_pszFunction);
+public:
+    static void i_logCaller(const char *a_pszFormat, ...);
+private:
+
+#endif
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+#endif /* !MAIN_INCLUDED_VirtualBoxImpl_h */
+
diff --git a/src/VBox/Main/include/VirtualBoxSDSImpl.h b/src/VBox/Main/include/VirtualBoxSDSImpl.h
new file mode 100644
index 00000000..0b5c2ad9
--- /dev/null
+++ b/src/VBox/Main/include/VirtualBoxSDSImpl.h
@@ -0,0 +1,161 @@
+/* $Id: VirtualBoxSDSImpl.h $ */
+/** @file
+ * VBox Global COM Class definition
+ */
+
+/*
+ * Copyright (C) 2017-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
+ */
+
+#ifndef MAIN_INCLUDED_VirtualBoxSDSImpl_h
+#define MAIN_INCLUDED_VirtualBoxSDSImpl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "VirtualBoxBase.h"
+
+/* Enable the watcher code in debug builds. */
+#ifdef DEBUG
+# define WITH_WATCHER
+#endif
+
+
+class VBoxSDSPerUserData; /* See VirtualBoxSDSImpl.cpp. */
+struct VBoxSDSWatcher;    /* See VirtualBoxSDSImpl.cpp. */
+
+/**
+ * The IVirtualBoxSDS implementation.
+ *
+ * This class helps different VBoxSVC processes make sure a user only have a
+ * single VirtualBox instance.
+ *
+ * @note This is a simple internal class living in a privileged process.  So, we
+ *       do not use the API wrappers as they add complexity.  In particular,
+ *       they add the auto caller logic, which is an excellent tool to create
+ *       unkillable processes.  If an API method during development or product
+ *       for instance triggers an NT exception like STATUS_ACCESS_VIOLATION, the
+ *       caller will be unwound without releasing the caller.  When uninit is
+ *       called during COM shutdown/whatever, the thread gets stuck waiting for
+ *       the long gone caller and cannot be killed (Windows 10, build 16299),
+ *       requiring a reboot to continue.
+ *
+ * @todo Would be very nice to get rid of the ATL cruft too here.
+ */
+class VirtualBoxSDS
+    : public IVirtualBoxSDS
+    , public ATL::CComObjectRootEx<ATL::CComMultiThreadModel>
+    , public ATL::CComCoClass<VirtualBoxSDS, &CLSID_VirtualBoxSDS>
+{
+private:
+    typedef std::map<com::Utf8Str, VBoxSDSPerUserData *> UserDataMap_T;
+    /** Per user data map (key is SID string).
+     * This is an insert-only map! */
+    UserDataMap_T           m_UserDataMap;
+    /** Number of registered+watched VBoxSVC processes. */
+    uint32_t                m_cVBoxSvcProcesses;
+#ifdef WITH_WATCHER
+    /** Number of watcher threads.   */
+    uint32_t                m_cWatchers;
+    /** Pointer to an array of watcher pointers. */
+    VBoxSDSWatcher        **m_papWatchers;
+    /** Lock protecting m_papWatchers and associated structures. */
+    RTCRITSECT              m_WatcherCritSect;
+#endif
+    /** Lock protecting m_UserDataMap . */
+    RTCRITSECTRW            m_MapCritSect;
+
+public:
+    DECLARE_CLASSFACTORY_SINGLETON(VirtualBoxSDS)
+    DECLARE_NOT_AGGREGATABLE(VirtualBoxSDS)
+    DECLARE_PROTECT_FINAL_CONSTRUCT()
+
+    BEGIN_COM_MAP(VirtualBoxSDS)
+        COM_INTERFACE_ENTRY(IVirtualBoxSDS)
+    END_COM_MAP()
+
+    DECLARE_COMMON_CLASS_METHODS(VirtualBoxSDS)
+
+    HRESULT FinalConstruct();
+    void    FinalRelease();
+
+private:
+
+    /** @name IVirtualBoxSDS methods
+     * @{ */
+    STDMETHOD(RegisterVBoxSVC)(IVBoxSVCRegistration *aVBoxSVC, LONG aPid, IUnknown **aExistingVirtualBox);
+    STDMETHOD(DeregisterVBoxSVC)(IVBoxSVCRegistration *aVBoxSVC, LONG aPid);
+    STDMETHOD(LaunchVMProcess)(IN_BSTR aMachine, IN_BSTR aComment, IN_BSTR aFrontend,
+                               ComSafeArrayIn(IN_BSTR, aEnvironmentChanges), IN_BSTR aCmdOptions,
+                               ULONG aSessionId, ULONG *aPid);
+    /** @} */
+
+
+    /** @name Private methods
+     * @{ */
+    /**
+     * Gets the client user SID of the
+     */
+    static bool i_getClientUserSid(com::Utf8Str *a_pStrSid, com::Utf8Str *a_pStrUsername);
+
+    /**
+     * Returns whether a VBoxSDS feature is enabled or not.
+     *
+     * @returns \c true if enabled, \c false if not.
+     * @param   a_pwszFeature   Feature to check enabled status for.
+     */
+    static bool i_isFeatureEnabled(wchar_t const *a_pwszFeature);
+
+    /**
+     * Looks up the given user.
+     *
+     * @returns Pointer to the LOCKED per user data.  NULL if not found.
+     * @param   a_rStrUserSid   The user SID.
+     */
+    VBoxSDSPerUserData *i_lookupPerUserData(com::Utf8Str const &a_rStrUserSid);
+
+    /**
+     * Looks up the given user, creating it if not found
+     *
+     * @returns Pointer to the LOCKED per user data.  NULL on allocation error.
+     * @param   a_rStrUserSid   The user SID.
+     * @param   a_rStrUsername  The user name if available.
+     */
+    VBoxSDSPerUserData *i_lookupOrCreatePerUserData(com::Utf8Str const &a_rStrUserSid, com::Utf8Str const &a_rStrUsername);
+
+#ifdef WITH_WATCHER
+    static DECLCALLBACK(int) i_watcherThreadProc(RTTHREAD hSelf, void *pvUser);
+    bool i_watchIt(VBoxSDSPerUserData *pProcess, HANDLE hProcess, RTPROCESS pid);
+    void i_stopWatching(VBoxSDSPerUserData *pProcess, RTPROCESS pid);
+    void i_shutdownAllWatchers(void);
+
+    void i_decrementClientCount();
+    void i_incrementClientCount();
+#endif
+    /** @} */
+};
+
+#ifdef WITH_WATCHER
+void VBoxSDSNotifyClientCount(uint32_t cClients);
+#endif
+
+#endif /* !MAIN_INCLUDED_VirtualBoxSDSImpl_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/VirtualBoxTranslator.h b/src/VBox/Main/include/VirtualBoxTranslator.h
new file mode 100644
index 00000000..ef87ff4e
--- /dev/null
+++ b/src/VBox/Main/include/VirtualBoxTranslator.h
@@ -0,0 +1,165 @@
+/* $Id: VirtualBoxTranslator.h $ */
+/** @file
+ * VirtualBox Translator.
+ */
+
+/*
+ * Copyright (C) 2005-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
+ */
+
+#ifndef MAIN_INCLUDED_VirtualBoxTranslator_h
+#define MAIN_INCLUDED_VirtualBoxTranslator_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <list>
+
+#include <iprt/cpp/lock.h>
+#include <VBox/com/AutoLock.h>
+
+COM_STRUCT_OR_CLASS(IVirtualBox);
+class QMTranslator;
+
+class VirtualBoxTranslator
+    : public util::RWLockHandle
+{
+public:
+    virtual ~VirtualBoxTranslator();
+
+    static VirtualBoxTranslator *instance();
+    /* Returns instance if exists, returns NULL otherwise. */
+    static VirtualBoxTranslator *tryInstance() RT_NOEXCEPT;
+    void release();
+
+    /* Load language based on settings in the VirtualBox config */
+    HRESULT loadLanguage(ComPtr<IVirtualBox> aVirtualBox);
+
+private:
+    /** Translator component. */
+    struct TranslatorComponent
+    {
+        QMTranslator *pTranslator;
+        /** Path to translation files. It includes file prefix, i.e '/path/to/folder/file_prefix'. */
+        com::Utf8Str  strPath;
+
+        TranslatorComponent() : pTranslator(NULL) {}
+    };
+public:
+    /** Pointer to a translator component. */
+    typedef TranslatorComponent *PTRCOMPONENT;
+
+    /**
+     * Registers the translation for a component.
+     *
+     * @returns VBox status code
+     * @param aTranslationPath  Path to the translation files, this includes the
+     *                          base filename prefix.
+     * @param aDefault          Use this as the default translation component, i.e.
+     *                          when translate() is called with NULL for @a
+     *                          aComponent.
+     * @param aComponent        Pointer to where is the component handle should be
+     *                          returned on success.  The return value must be used
+     *                          for all subsequent calls to translate().
+     */
+    static int registerTranslation(const char *aTranslationPath,
+                                   bool aDefault,
+                                   PTRCOMPONENT *aComponent);
+
+    /**
+     * Removes translations for a component.
+     *
+     * @returns VBox status code
+     * @param   aComponent      The component.  NULL is quietly (VWRN_NOT_FOUND)
+     *                          ignored .
+     */
+    static int unregisterTranslation(PTRCOMPONENT aComponent);
+
+    /**
+     * Translates @a aSourceText to user language.
+     * Uses component marked as default if @a aTranslationComponent is NULL
+     *
+     * @returns Translated string or @a aSourceText. The returned string is
+     *          valid only during lifetime of the translator instance.
+     */
+    static const char *translate(PTRCOMPONENT aComponent,
+                                 const char  *aContext,
+                                 const char  *aSourceText,
+                                 const char  *aComment = NULL,
+                                 const size_t aNum = ~(size_t)0) RT_NOEXCEPT;
+
+    /**
+     * Returns source text stored in the cache if exists.
+     * Otherwise, the pszTranslation itself returned.
+     */
+    static const char *trSource(const char *aTranslation) RT_NOEXCEPT;
+
+    /* Convenience function used by VirtualBox::init */
+    int i_loadLanguage(const char *pszLang);
+
+    static int32_t initCritSect();
+
+    com::Utf8Str language();
+
+private:
+    static RTCRITSECTRW s_instanceRwLock;
+    static VirtualBoxTranslator *s_pInstance;
+
+    uint32_t m_cInstanceRefs;
+
+    typedef std::list<TranslatorComponent> TranslatorList;
+    TranslatorList  m_lTranslators;
+    TranslatorComponent *m_pDefaultComponent;
+
+    /* keep the language code for registration */
+    com::Utf8Str m_strLanguage;
+
+    /** String cache that all translation strings are stored in.
+     * This is a add-only cache, which allows translate() to return C-strings w/o
+     * needing to think about racing loadLanguage() wrt string lifetime. */
+    RTSTRCACHE    m_hStrCache;
+    /** RTStrCacheCreate status code. */
+    int           m_rcCache;
+
+    VirtualBoxTranslator();
+
+    int i_loadLanguageForComponent(TranslatorComponent *aComponent, const char *aLang);
+
+    int i_setLanguageFile(TranslatorComponent *aComponent, const char *aFileName);
+
+    int i_registerTranslation(const char *aTranslationPath,
+                              bool aDefault,
+                              PTRCOMPONENT *aComponent);
+
+    int i_unregisterTranslation(PTRCOMPONENT aComponent);
+
+    const char *i_translate(PTRCOMPONENT aComponent,
+                            const char   *aContext,
+                            const char   *aSourceText,
+                            const char   *aComment = NULL,
+                            const size_t aNum = ~(size_t)0) RT_NOEXCEPT;
+};
+
+/** Pointer to a translator component. */
+typedef VirtualBoxTranslator::PTRCOMPONENT PTRCOMPONENT;
+
+#endif /* !MAIN_INCLUDED_VirtualBoxTranslator_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/WebMWriter.h b/src/VBox/Main/include/WebMWriter.h
new file mode 100644
index 00000000..67d4b128
--- /dev/null
+++ b/src/VBox/Main/include/WebMWriter.h
@@ -0,0 +1,579 @@
+/* $Id: WebMWriter.h $ */
+/** @file
+ * WebMWriter.h - WebM container handling.
+ */
+
+/*
+ * Copyright (C) 2013-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
+ */
+
+#ifndef MAIN_INCLUDED_WebMWriter_h
+#define MAIN_INCLUDED_WebMWriter_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/buildconfig.h>
+#include <iprt/mem.h>
+#include <iprt/rand.h>
+#include <iprt/string.h>
+
+#include "VBox/com/VirtualBox.h"
+#include <VBox/version.h>
+
+#include "EBMLWriter.h"
+#include "EBML_MKV.h"
+
+#include <queue>
+#include <map>
+#include <list>
+
+#ifdef VBOX_WITH_LIBVPX
+# ifdef _MSC_VER
+#  pragma warning(push)
+#  pragma warning(disable: 4668) /* vpx_codec.h(64) : warning C4668: '__GNUC__' is not defined as a preprocessor macro, replacing with '0' for '#if/#elif' */
+#  include <vpx/vpx_encoder.h>
+#  pragma warning(pop)
+# else
+#  include <vpx/vpx_encoder.h>
+# endif
+#endif /* VBOX_WITH_LIBVPX */
+
+/** No flags specified. */
+#define VBOX_WEBM_BLOCK_FLAG_NONE           0
+/** Invisible block which can be skipped. */
+#define VBOX_WEBM_BLOCK_FLAG_INVISIBLE      0x08
+/** The block marks a key frame. */
+#define VBOX_WEBM_BLOCK_FLAG_KEY_FRAME      0x80
+
+/** The default timecode scale factor for WebM -- all timecodes in the segments are expressed in ms.
+ *  This allows every cluster to have blocks with positive values up to 32.767 seconds. */
+#define VBOX_WEBM_TIMECODESCALE_FACTOR_MS   1000000
+
+/** Maximum time (in ms) a cluster can store. */
+#define VBOX_WEBM_CLUSTER_MAX_LEN_MS        INT16_MAX
+
+/** Maximum time a block can store.
+ *  With signed 16-bit timecodes and a default timecode scale of 1ms per unit this makes 65536ms. */
+#define VBOX_WEBM_BLOCK_MAX_LEN_MS          UINT16_MAX
+
+#ifdef VBOX_WITH_LIBVORBIS
+# pragma pack(push)
+# pragma pack(1)
+    /** Ogg Vorbis codec private data within the MKV (WEBM) container.
+     *  Taken from: https://www.matroska.org/technical/codec_specs.html */
+    typedef struct WEBMOGGVORBISPRIVDATA
+    {
+        WEBMOGGVORBISPRIVDATA(uint32_t a_cbHdrIdent, uint32_t a_cbHdrComments, uint32_t a_cbHdrSetup)
+            : cbHdrIdent(a_cbHdrIdent)
+            , cbHdrComments(a_cbHdrComments)
+        {
+            RT_NOREF(a_cbHdrSetup);
+
+            /* We supply 3 headers total: The "real" header, comments header + setup header. */
+            cHeaders = 3 /* Headers */ - 1; /* Note: Always "minus one" here. */
+
+            Assert(a_cbHdrIdent    <= UINT8_MAX);
+            Assert(a_cbHdrComments <= UINT8_MAX);
+            Assert(a_cbHdrSetup    <= _8K);
+            Assert(a_cbHdrIdent + a_cbHdrComments + a_cbHdrSetup <= sizeof(abHdr));
+        }
+
+        /** Number of private headers - 1. */
+        uint8_t  cHeaders;
+        /** Size of identification header (in bytes). */
+        uint8_t  cbHdrIdent;
+        /** < Size of comments header (in bytes). */
+        uint8_t  cbHdrComments;
+        /** < Header code area. */
+        uint8_t  abHdr[UINT8_MAX /* Header */ + UINT8_MAX /* Comments header */ + _8K /* Setup header */];
+
+    } WEBMOGGVORBISPRIVDATA, *PWEBMOGGVORBISPRIVDATA;
+# pragma pack(pop)
+#endif
+
+class WebMWriter : public EBMLWriter
+{
+
+public:
+
+    /** Defines an absolute WebM timecode (Block + Cluster). */
+    typedef uint64_t WebMTimecodeAbs;
+
+    /** Defines a relative WebM timecode (Block). */
+    typedef uint16_t WebMTimecodeRel;
+
+    /** Defines the WebM block flags data type. */
+    typedef uint8_t  WebMBlockFlags;
+
+    /**
+     * Track type enumeration.
+     */
+    enum WebMTrackType
+    {
+        /** Unknown / invalid type. */
+        WebMTrackType_Invalid     = 0,
+        /** Only writes audio. */
+        WebMTrackType_Audio       = 1,
+        /** Only writes video. */
+        WebMTrackType_Video       = 2
+    };
+
+    struct WebMTrack;
+
+    /**
+     * Structure for defining a WebM simple block.
+     */
+    struct WebMSimpleBlock
+    {
+        WebMSimpleBlock(WebMTrack *a_pTrack,
+                        WebMTimecodeAbs a_tcAbsPTSMs, const void *a_pvData, size_t a_cbData, WebMBlockFlags a_fFlags)
+            : pTrack(a_pTrack)
+        {
+            Data.tcAbsPTSMs = a_tcAbsPTSMs;
+            Data.cb         = a_cbData;
+            Data.fFlags     = a_fFlags;
+
+            if (Data.cb)
+            {
+                Data.pv = RTMemDup(a_pvData, a_cbData);
+                if (!Data.pv)
+                    throw;
+            }
+        }
+
+        virtual ~WebMSimpleBlock()
+        {
+            if (Data.pv)
+            {
+                Assert(Data.cb);
+                RTMemFree(Data.pv);
+            }
+        }
+
+        WebMTrack    *pTrack;
+
+        /** Actual simple block data. */
+        struct
+        {
+            WebMTimecodeAbs tcAbsPTSMs;
+            WebMTimecodeRel tcRelToClusterMs;
+            void          *pv;
+            size_t         cb;
+            WebMBlockFlags fFlags;
+        } Data;
+    };
+
+    /** A simple block queue.*/
+    typedef std::queue<WebMSimpleBlock *> WebMSimpleBlockQueue;
+
+    /** Structure for queuing all simple blocks bound to a single timecode.
+     *  This can happen if multiple tracks are being involved. */
+    struct WebMTimecodeBlocks
+    {
+        WebMTimecodeBlocks(void)
+            : fClusterNeeded(false)
+            , fClusterStarted(false) { }
+
+        /** The actual block queue for this timecode. */
+        WebMSimpleBlockQueue Queue;
+        /** Whether a new cluster is needed for this timecode or not. */
+        bool                 fClusterNeeded;
+        /** Whether a new cluster already has been started for this timecode or not. */
+        bool                 fClusterStarted;
+
+        /**
+         * Enqueues a simple block into the internal queue.
+         *
+         * @param   a_pBlock    Block to enqueue and take ownership of.
+         */
+        void Enqueue(WebMSimpleBlock *a_pBlock)
+        {
+            Queue.push(a_pBlock);
+
+            if (a_pBlock->Data.fFlags & VBOX_WEBM_BLOCK_FLAG_KEY_FRAME)
+                fClusterNeeded = true;
+        }
+    };
+
+    /** A block map containing all currently queued blocks.
+     *  The key specifies a unique timecode, whereas the value
+     *  is a queue of blocks which all correlate to the key (timecode). */
+    typedef std::map<WebMTimecodeAbs, WebMTimecodeBlocks> WebMBlockMap;
+
+    /**
+     * Structure for defining a WebM (encoding) queue.
+     */
+    struct WebMQueue
+    {
+        WebMQueue(void)
+            : tcAbsLastBlockWrittenMs(0)
+            , tsLastProcessedMs(0) { }
+
+        /** Blocks as FIFO (queue). */
+        WebMBlockMap    Map;
+        /** Absolute timecode (in ms) of last written block to queue. */
+        WebMTimecodeAbs tcAbsLastBlockWrittenMs;
+        /** Time stamp (in ms) of when the queue was processed last. */
+        uint64_t        tsLastProcessedMs;
+    };
+
+    /**
+     * Structure for keeping a WebM track entry.
+     */
+    struct WebMTrack
+    {
+        WebMTrack(WebMTrackType a_enmType, PRECORDINGCODEC pTheCodec, uint8_t a_uTrack, uint64_t a_offID)
+            : enmType(a_enmType)
+            , pCodec(pTheCodec)
+            , uTrack(a_uTrack)
+            , offUUID(a_offID)
+            , cTotalBlocks(0)
+            , tcAbsLastWrittenMs(0)
+        {
+            uUUID = RTRandU32();
+        }
+
+        /** The type of this track. */
+        WebMTrackType   enmType;
+        /** Pointer to codec data to use. */
+        PRECORDINGCODEC pCodec;
+        /** Track parameters. */
+        union
+        {
+            struct
+            {
+                /** Sample rate of input data. */
+                uint32_t uHz;
+                /** Duration of the frame in samples (per channel).
+                 *  Valid frame size are:
+                 *
+                 *  ms           Frame size
+                 *  2.5          120
+                 *  5            240
+                 *  10           480
+                 *  20 (Default) 960
+                 *  40           1920
+                 *  60           2880
+                 */
+                uint16_t framesPerBlock;
+                /** How many milliseconds (ms) one written (simple) block represents. */
+                uint16_t msPerBlock;
+            } Audio;
+        };
+        /** This track's track number. Also used as key in track map. */
+        uint8_t             uTrack;
+        /** The track's "UUID".
+         *  Needed in case this track gets mux'ed with tracks from other files. Not really unique though. */
+        uint32_t            uUUID;
+        /** Absolute offset in file of track UUID.
+         *  Needed to write the hash sum within the footer. */
+        uint64_t            offUUID;
+        /** Total number of blocks. */
+        uint64_t            cTotalBlocks;
+        /** Absoute timecode (in ms) of last write. */
+        WebMTimecodeAbs     tcAbsLastWrittenMs;
+    };
+
+    /**
+     * Structure for a single cue point track position entry.
+     */
+    struct WebMCueTrackPosEntry
+    {
+        WebMCueTrackPosEntry(uint64_t a_offCluster)
+            : offCluster(a_offCluster) { }
+
+        /** Offset (in bytes) of the related cluster containing the given position. */
+        uint64_t offCluster;
+    };
+
+    /** Map for keeping track position entries for a single cue point.
+     *  The key is the track number (*not* UUID!). */
+    typedef std::map<uint8_t, WebMCueTrackPosEntry *> WebMCueTrackPosMap;
+
+    /**
+     * Structure for keeping a cue point.
+     */
+    struct WebMCuePoint
+    {
+        WebMCuePoint(WebMTimecodeAbs a_tcAbs)
+            : tcAbs(a_tcAbs) { }
+
+        virtual ~WebMCuePoint()
+        {
+            Clear();
+        }
+
+        void Clear(void)
+        {
+            WebMCueTrackPosMap::iterator itTrackPos = Pos.begin();
+            while (itTrackPos != Pos.end())
+            {
+                WebMCueTrackPosEntry *pTrackPos = itTrackPos->second;
+                AssertPtr(pTrackPos);
+                delete pTrackPos;
+
+                Pos.erase(itTrackPos);
+                itTrackPos = Pos.begin();
+            }
+
+            Assert(Pos.empty());
+        }
+
+        /** Map containing all track positions for this specific cue point. */
+        WebMCueTrackPosMap Pos;
+        /** Absolute time code according to the segment time base. */
+        WebMTimecodeAbs    tcAbs;
+    };
+
+    /** List of cue points. */
+    typedef std::list<WebMCuePoint *> WebMCuePointList;
+
+    /**
+     * Structure for keeping a WebM cluster entry.
+     */
+    struct WebMCluster
+    {
+        WebMCluster(void)
+            : uID(0)
+            , offStart(0)
+            , fOpen(false)
+            , tcAbsStartMs(0)
+            , cBlocks(0) { }
+
+        /** This cluster's ID. */
+        uint64_t        uID;
+        /** Absolute offset (in bytes) of this cluster.
+         *  Needed for seeking info table. */
+        uint64_t        offStart;
+        /** Whether this cluster element is opened currently. */
+        bool            fOpen;
+        /** Absolute timecode (in ms) when this cluster starts. */
+        WebMTimecodeAbs tcAbsStartMs;
+        /** Absolute timecode (in ms) of when last written to this cluster. */
+        WebMTimecodeAbs tcAbsLastWrittenMs;
+        /** Number of (simple) blocks in this cluster. */
+        uint64_t        cBlocks;
+    };
+
+    /**
+     * Structure for keeping a WebM segment entry.
+     *
+     * Current we're only using one segment.
+     */
+    struct WebMSegment
+    {
+        WebMSegment(void)
+            : m_tcAbsStartMs(0)
+            , m_tcAbsLastWrittenMs(0)
+            , m_offStart(0)
+            , m_offInfo(0)
+            , m_offSeekInfo(0)
+            , m_offTracks(0)
+            , m_offCues(0)
+            , m_cClusters(0)
+        {
+            m_uTimecodeScaleFactor = VBOX_WEBM_TIMECODESCALE_FACTOR_MS;
+
+            LogFunc(("Default timecode scale is: %RU64ns\n", m_uTimecodeScaleFactor));
+        }
+
+        virtual ~WebMSegment()
+        {
+            uninit();
+        }
+
+        /**
+         * Initializes a segment.
+         *
+         * @returns VBox status code.
+         */
+        int init(void)
+        {
+            return RTCritSectInit(&m_CritSect);
+        }
+
+        /**
+         * Uninitializes a segment.
+         */
+        void uninit(void)
+        {
+            clear();
+
+            RTCritSectDelete(&m_CritSect);
+        }
+
+        /**
+         * Clear the segment's data by removing (and freeing) all data.
+         */
+        void clear(void)
+        {
+            WebMCuePointList::iterator itCuePoint = m_lstCuePoints.begin();
+            while (itCuePoint != m_lstCuePoints.end())
+            {
+                WebMCuePoint *pCuePoint = (*itCuePoint);
+                AssertPtr(pCuePoint);
+                delete pCuePoint;
+
+                m_lstCuePoints.erase(itCuePoint);
+                itCuePoint = m_lstCuePoints.begin();
+            }
+
+            Assert(m_lstCuePoints.empty());
+        }
+
+        /** Critical section for serializing access to this segment. */
+        RTCRITSECT                      m_CritSect;
+
+        /** The timecode scale factor of this segment. */
+        uint64_t                        m_uTimecodeScaleFactor;
+
+        /** Absolute timecode (in ms) when starting this segment. */
+        WebMTimecodeAbs                 m_tcAbsStartMs;
+        /** Absolute timecode (in ms) of last write. */
+        WebMTimecodeAbs                 m_tcAbsLastWrittenMs;
+
+        /** Absolute offset (in bytes) of CurSeg. */
+        uint64_t                        m_offStart;
+        /** Absolute offset (in bytes) of general info. */
+        uint64_t                        m_offInfo;
+        /** Absolute offset (in bytes) of seeking info. */
+        uint64_t                        m_offSeekInfo;
+        /** Absolute offset (in bytes) of tracks. */
+        uint64_t                        m_offTracks;
+        /** Absolute offset (in bytes) of cues table. */
+        uint64_t                        m_offCues;
+        /** List of cue points. Needed for seeking table. */
+        WebMCuePointList                m_lstCuePoints;
+
+        /** Total number of clusters. */
+        uint64_t                        m_cClusters;
+
+        /** Map of tracks.
+         *  The key marks the track number (*not* the UUID!). */
+        std::map <uint8_t, WebMTrack *> m_mapTracks;
+
+        /** Current cluster which is being handled.
+         *
+         *  Note that we don't need (and shouldn't need, as this can be a *lot* of data!) a
+         *  list of all clusters. */
+        WebMCluster                     m_CurCluster;
+
+        WebMQueue                       m_queueBlocks;
+
+    } m_CurSeg;
+
+    /** Audio codec to use. */
+    RecordingAudioCodec_T       m_enmAudioCodec;
+    /** Video codec to use. */
+    RecordingVideoCodec_T       m_enmVideoCodec;
+
+    /** Whether we're currently in the tracks section. */
+    bool                        m_fInTracksSection;
+
+    /** Size of timecodes (in bytes). */
+    size_t                      m_cbTimecode;
+    /** Maximum value a timecode can have. */
+    uint32_t                    m_uTimecodeMax;
+
+#ifdef VBOX_WITH_LIBVPX
+    /**
+     * Block data for VP8-encoded video data.
+     */
+    struct BlockData_VP8
+    {
+        const vpx_codec_enc_cfg_t *pCfg;
+        const vpx_codec_cx_pkt_t  *pPkt;
+    };
+#endif /* VBOX_WITH_LIBVPX */
+
+    /**
+     * Block data for encoded audio data.
+     */
+    struct BlockData_Audio
+    {
+        /** Pointer to encoded audio data. */
+        const void *pvData;
+        /** Size (in bytes) of encoded audio data. */
+        size_t      cbData;
+        /** PTS (in ms) of encoded audio data. */
+        uint64_t    uPTSMs;
+    };
+
+public:
+
+    WebMWriter();
+
+    virtual ~WebMWriter();
+
+public:
+
+    int OpenEx(const char *a_pszFilename, PRTFILE a_phFile,
+               RecordingAudioCodec_T a_enmAudioCodec, RecordingVideoCodec_T a_enmVideoCodec);
+
+    int Open(const char *a_pszFilename, uint64_t a_fOpen,
+             RecordingAudioCodec_T a_enmAudioCodec, RecordingVideoCodec_T a_enmVideoCodec);
+
+    int Close(void);
+
+    int AddAudioTrack(PRECORDINGCODEC pCodec, uint16_t uHz, uint8_t cChannels, uint8_t cBits, uint8_t *puTrack);
+
+    int AddVideoTrack(PRECORDINGCODEC pCodec, uint16_t uWidth, uint16_t uHeight, uint32_t uFPS, uint8_t *puTrack);
+
+    int WriteBlock(uint8_t uTrack, const void *pvData, size_t cbData, WebMTimecodeAbs tcAbsPTSMs, WebMBlockFlags uFlags);
+
+    const com::Utf8Str& GetFileName(void);
+
+    uint64_t GetFileSize(void);
+
+    uint64_t GetAvailableSpace(void);
+
+    /**
+     * Returns the number of written WebM clusters.
+     *
+     * @returns Number of written WebM clusters; 0 when no clusters written (empty file).
+     */
+    uint64_t GetClusters(void) const { return m_CurSeg.m_cClusters; }
+
+protected:
+
+    int init(RecordingAudioCodec_T a_enmAudioCodec, RecordingVideoCodec_T a_enmVideoCodec);
+
+    void destroy(void);
+
+    int writeHeader(void);
+
+    void writeSeekHeader(void);
+
+    int writeFooter(void);
+
+    int writeSimpleBlockEBML(WebMTrack *a_pTrack, WebMSimpleBlock *a_pBlock);
+
+    int writeSimpleBlockQueued(WebMTrack *a_pTrack, WebMSimpleBlock *a_pBlock);
+
+    int processQueue(WebMQueue *pQueue, bool fForce);
+
+protected:
+
+    typedef std::map <uint8_t, WebMTrack *> WebMTracks;
+};
+
+#endif /* !MAIN_INCLUDED_WebMWriter_h */
diff --git a/src/VBox/Main/include/Wrapper.h b/src/VBox/Main/include/Wrapper.h
new file mode 100644
index 00000000..bb2f5550
--- /dev/null
+++ b/src/VBox/Main/include/Wrapper.h
@@ -0,0 +1,504 @@
+/* $Id: Wrapper.h $ */
+/** @file
+ * VirtualBox COM - API wrapper helpers.
+ */
+
+/*
+ * Copyright (C) 2012-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
+ */
+
+#ifndef MAIN_INCLUDED_Wrapper_h
+#define MAIN_INCLUDED_Wrapper_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <vector>
+#include <VBox/com/ptr.h>
+#include <VBox/com/array.h>
+
+#include "AutoCaller.h"
+
+
+/**
+ * Checks that the given pointer to an output argument is valid and throws
+ * E_POINTER + extended error info otherwise.
+ * @param arg   Pointer argument.
+ */
+#define CheckComArgOutPointerValidThrow(arg) \
+    do { \
+        if (RT_LIKELY(RT_VALID_PTR(arg))) \
+        { /* likely */ }\
+        /* Have to use use VirtualBoxBase::tr here or lupdate won't be able to figure out the context, \
+           as it is picking it up right here rather than in the places where the macro is actually used. */ \
+        else throw setError(E_POINTER, VirtualBoxBase::tr("Output argument %s points to invalid memory location (%p)"), \
+                            #arg, (void *)(arg)); \
+    } while (0)
+
+
+class BSTROutConverter
+{
+public:
+    BSTROutConverter() : mDst(NULL)
+    {
+    }
+
+    BSTROutConverter(BSTR *aDst) : mDst(aDst)
+    {
+    }
+
+    ~BSTROutConverter()
+    {
+        if (mDst)
+            Bstr(mStr).detachTo(mDst);
+    }
+
+    com::Utf8Str &str()
+    {
+        return mStr;
+    }
+
+private:
+    com::Utf8Str mStr;
+    BSTR *mDst;
+};
+
+class BSTRInConverter
+{
+public:
+    BSTRInConverter() : mSrc()
+    {
+    }
+
+    BSTRInConverter(CBSTR aSrc) : mSrc(aSrc)
+    {
+    }
+
+    ~BSTRInConverter()
+    {
+    }
+
+    const com::Utf8Str &str()
+    {
+        return mSrc;
+    }
+
+private:
+    const com::Utf8Str mSrc;
+};
+
+class ArrayBSTROutConverter
+{
+public:
+    ArrayBSTROutConverter() :
+#ifdef VBOX_WITH_XPCOM
+        mDstSize(NULL),
+        mDst(NULL)
+#else // !VBOX_WITH_XPCOM
+        mDst(NULL)
+#endif // !VBOX_WITH_XPCOM
+    {
+    }
+
+    ArrayBSTROutConverter(ComSafeArrayOut(BSTR, aDst)) :
+#ifdef VBOX_WITH_XPCOM
+        mDstSize(aDstSize),
+        mDst(aDst)
+#else // !VBOX_WITH_XPCOM
+        mDst(aDst)
+#endif // !VBOX_WITH_XPCOM
+    {
+    }
+
+    ~ArrayBSTROutConverter()
+    {
+        if (mDst)
+        {
+            com::SafeArray<BSTR> outArray(mArray.size());
+            for (size_t i = 0; i < mArray.size(); i++)
+                Bstr(mArray[i]).detachTo(&outArray[i]);
+            outArray.detachTo(ComSafeArrayOutArg(mDst));
+        }
+    }
+
+    std::vector<com::Utf8Str> &array()
+    {
+        return mArray;
+    }
+
+private:
+    std::vector<com::Utf8Str> mArray;
+#ifdef VBOX_WITH_XPCOM
+    PRUint32 *mDstSize;
+    BSTR **mDst;
+#else // !VBOX_WITH_XPCOM
+    SAFEARRAY **mDst;
+#endif // !VBOX_WITH_XPCOM
+};
+
+class ArrayBSTRInConverter
+{
+public:
+    ArrayBSTRInConverter()
+    {
+    }
+
+    ArrayBSTRInConverter(ComSafeArrayIn(IN_BSTR, aSrc))
+    {
+        if (!ComSafeArrayInIsNull(aSrc))
+        {
+            com::SafeArray<IN_BSTR> inArray(ComSafeArrayInArg(aSrc));
+            mArray.resize(inArray.size());
+            for (size_t i = 0; i < inArray.size(); i++)
+                mArray[i] = inArray[i];
+        }
+    }
+
+    ~ArrayBSTRInConverter()
+    {
+    }
+
+    const std::vector<com::Utf8Str> &array()
+    {
+        return mArray;
+    }
+
+private:
+    std::vector<com::Utf8Str> mArray;
+};
+
+class UuidOutConverter
+{
+public:
+    UuidOutConverter() : mDst(NULL)
+    {
+    }
+
+    UuidOutConverter(BSTR *aDst) : mDst(aDst)
+    {
+    }
+
+    ~UuidOutConverter()
+    {
+        if (mDst)
+            mUuid.toUtf16().detachTo(mDst);
+    }
+
+    com::Guid &uuid()
+    {
+        return mUuid;
+    }
+
+private:
+    com::Guid mUuid;
+    BSTR *mDst;
+};
+
+class UuidInConverter
+{
+public:
+    UuidInConverter() : mSrc()
+    {
+    }
+
+    UuidInConverter(CBSTR aSrc) : mSrc(aSrc)
+    {
+    }
+
+    ~UuidInConverter()
+    {
+    }
+
+    const com::Guid &uuid()
+    {
+        return mSrc;
+    }
+
+private:
+    const com::Guid mSrc;
+};
+
+class ArrayUuidOutConverter
+{
+public:
+    ArrayUuidOutConverter() :
+#ifdef VBOX_WITH_XPCOM
+        mDstSize(NULL),
+        mDst(NULL)
+#else // !VBOX_WITH_XPCOM
+        mDst(NULL)
+#endif // !VBOX_WITH_XPCOM
+    {
+    }
+
+    ArrayUuidOutConverter(ComSafeArrayOut(BSTR, aDst)) :
+#ifdef VBOX_WITH_XPCOM
+        mDstSize(aDstSize),
+        mDst(aDst)
+#else // !VBOX_WITH_XPCOM
+        mDst(aDst)
+#endif // !VBOX_WITH_XPCOM
+    {
+    }
+
+    ~ArrayUuidOutConverter()
+    {
+        if (mDst)
+        {
+            com::SafeArray<BSTR> outArray(mArray.size());
+            for (size_t i = 0; i < mArray.size(); i++)
+                mArray[i].toUtf16().detachTo(&outArray[i]);
+            outArray.detachTo(ComSafeArrayOutArg(mDst));
+        }
+    }
+
+    std::vector<com::Guid> &array()
+    {
+        return mArray;
+    }
+
+private:
+    std::vector<com::Guid> mArray;
+#ifdef VBOX_WITH_XPCOM
+    PRUint32 *mDstSize;
+    BSTR **mDst;
+#else // !VBOX_WITH_XPCOM
+    SAFEARRAY **mDst;
+#endif // !VBOX_WITH_XPCOM
+};
+
+template <class A>
+class ComTypeOutConverter
+{
+public:
+    ComTypeOutConverter() : mDst(NULL)
+    {
+    }
+
+    ComTypeOutConverter(A **aDst) : mDst(aDst)
+    {
+    }
+
+    ~ComTypeOutConverter()
+    {
+        if (mDst)
+            mPtr.queryInterfaceTo(mDst);
+    }
+
+    ComPtr<A> &ptr()
+    {
+        return mPtr;
+    }
+
+private:
+    ComPtr<A> mPtr;
+    A **mDst;
+};
+
+template <class A>
+class ComTypeInConverter
+{
+public:
+    ComTypeInConverter() : mSrc(NULL)
+    {
+    }
+
+    ComTypeInConverter(A *aSrc) : mSrc(aSrc)
+    {
+    }
+
+    ~ComTypeInConverter()
+    {
+    }
+
+    const ComPtr<A> &ptr()
+    {
+        return mSrc;
+    }
+
+private:
+    const ComPtr<A> mSrc;
+};
+
+template <class A>
+class ArrayComTypeOutConverter
+{
+public:
+    ArrayComTypeOutConverter() :
+#ifdef VBOX_WITH_XPCOM
+        mDstSize(NULL),
+        mDst(NULL)
+#else // !VBOX_WITH_XPCOM
+        mDst(NULL)
+#endif // !VBOX_WITH_XPCOM
+    {
+    }
+
+    ArrayComTypeOutConverter(ComSafeArrayOut(A *, aDst)) :
+#ifdef VBOX_WITH_XPCOM
+        mDstSize(aDstSize),
+        mDst(aDst)
+#else // !VBOX_WITH_XPCOM
+        mDst(aDst)
+#endif // !VBOX_WITH_XPCOM
+    {
+    }
+
+    ~ArrayComTypeOutConverter()
+    {
+        if (mDst)
+        {
+            com::SafeIfaceArray<A> outArray(mArray);
+            outArray.detachTo(ComSafeArrayOutArg(mDst));
+        }
+    }
+
+    std::vector<ComPtr<A> > &array()
+    {
+        return mArray;
+    }
+
+private:
+    std::vector<ComPtr<A> > mArray;
+#ifdef VBOX_WITH_XPCOM
+    PRUint32 *mDstSize;
+    A ***mDst;
+#else // !VBOX_WITH_XPCOM
+    SAFEARRAY **mDst;
+#endif // !VBOX_WITH_XPCOM
+};
+
+template <class A>
+class ArrayComTypeInConverter
+{
+public:
+    ArrayComTypeInConverter()
+    {
+    }
+
+    ArrayComTypeInConverter(ComSafeArrayIn(A *, aSrc))
+    {
+        if (!ComSafeArrayInIsNull(aSrc))
+        {
+            com::SafeIfaceArray<A> inArray(ComSafeArrayInArg(aSrc));
+            mArray.resize(inArray.size());
+            for (size_t i = 0; i < inArray.size(); i++)
+                mArray[i] = inArray[i];
+        }
+    }
+
+    ~ArrayComTypeInConverter()
+    {
+    }
+
+    const std::vector<ComPtr<A> > &array()
+    {
+        return mArray;
+    }
+
+private:
+    std::vector<ComPtr<A> > mArray;
+};
+
+template <typename A>
+class ArrayOutConverter
+{
+public:
+    ArrayOutConverter() :
+#ifdef VBOX_WITH_XPCOM
+        mDstSize(NULL),
+        mDst(NULL)
+#else // !VBOX_WITH_XPCOM
+        mDst(NULL)
+#endif // !VBOX_WITH_XPCOM
+    {
+    }
+
+    ArrayOutConverter(ComSafeArrayOut(A, aDst)) :
+#ifdef VBOX_WITH_XPCOM
+        mDstSize(aDstSize),
+        mDst(aDst)
+#else // !VBOX_WITH_XPCOM
+        mDst(aDst)
+#endif // !VBOX_WITH_XPCOM
+    {
+    }
+
+    ~ArrayOutConverter()
+    {
+        if (mDst)
+        {
+            com::SafeArray<A> outArray(mArray.size());
+            for (size_t i = 0; i < mArray.size(); i++)
+                outArray[i] = mArray[i];
+            outArray.detachTo(ComSafeArrayOutArg(mDst));
+        }
+    }
+
+    std::vector<A> &array()
+    {
+        return mArray;
+    }
+
+private:
+    std::vector<A> mArray;
+#ifdef VBOX_WITH_XPCOM
+    PRUint32 *mDstSize;
+    A **mDst;
+#else // !VBOX_WITH_XPCOM
+    SAFEARRAY **mDst;
+#endif // !VBOX_WITH_XPCOM
+};
+
+template <typename A>
+class ArrayInConverter
+{
+public:
+    ArrayInConverter()
+    {
+    }
+
+    ArrayInConverter(ComSafeArrayIn(A, aSrc))
+    {
+        if (!ComSafeArrayInIsNull(aSrc))
+        {
+            com::SafeArray<A> inArray(ComSafeArrayInArg(aSrc));
+            mArray.resize(inArray.size());
+            for (size_t i = 0; i < inArray.size(); i++)
+                mArray[i] = inArray[i];
+        }
+    }
+
+    ~ArrayInConverter()
+    {
+    }
+
+    const std::vector<A> &array()
+    {
+        return mArray;
+    }
+
+private:
+    std::vector<A> mArray;
+};
+
+#endif /* !MAIN_INCLUDED_Wrapper_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/netif.h b/src/VBox/Main/include/netif.h
new file mode 100644
index 00000000..3d344914
--- /dev/null
+++ b/src/VBox/Main/include/netif.h
@@ -0,0 +1,145 @@
+/* $Id: netif.h $ */
+/** @file
+ * Main - Network Interfaces.
+ */
+
+/*
+ * Copyright (C) 2008-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
+ */
+
+#ifndef MAIN_INCLUDED_netif_h
+#define MAIN_INCLUDED_netif_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/cdefs.h>
+#include <iprt/types.h>
+#include <iprt/net.h>
+/** @todo r=bird: The inlined code below that drags in asm.h here. I doubt
+ *        speed is very important here, so move it into a .cpp file, please. */
+#include <iprt/asm.h>
+
+#ifndef RT_OS_WINDOWS
+# include <arpa/inet.h>
+# include <stdio.h>
+#endif /* !RT_OS_WINDOWS */
+
+#define VBOXNET_IPV4ADDR_DEFAULT      0x0138A8C0  /* 192.168.56.1 */
+#define VBOXNET_IPV4MASK_DEFAULT      "255.255.255.0"
+
+#define VBOXNET_MAX_SHORT_NAME 50
+
+#if 1
+/**
+ * Encapsulation type.
+ * @note Must match HostNetworkInterfaceMediumType_T exactly.
+ * @todo r=bird: Why are we duplicating HostNetworkInterfaceMediumType_T here?!?
+ */
+typedef enum NETIFTYPE
+{
+    NETIF_T_UNKNOWN,
+    NETIF_T_ETHERNET,
+    NETIF_T_PPP,
+    NETIF_T_SLIP
+} NETIFTYPE;
+
+/**
+ * Current state of the interface.
+ * @note Must match HostNetworkInterfaceStatus_T exactly.
+ * @todo r=bird: Why are we duplicating HostNetworkInterfaceStatus_T here?!?
+ */
+typedef enum NETIFSTATUS
+{
+    NETIF_S_UNKNOWN,
+    NETIF_S_UP,
+    NETIF_S_DOWN
+} NETIFSTATUS;
+
+/**
+ * Host Network Interface Information.
+ */
+typedef struct NETIFINFO
+{
+    NETIFINFO     *pNext;
+    RTNETADDRIPV4  IPAddress;
+    RTNETADDRIPV4  IPNetMask;
+    RTNETADDRIPV6  IPv6Address;
+    RTNETADDRIPV6  IPv6NetMask;
+    BOOL           fDhcpEnabled;
+    BOOL           fIsDefault;
+    BOOL           fWireless;
+    RTMAC          MACAddress;
+    NETIFTYPE      enmMediumType;
+    NETIFSTATUS    enmStatus;
+    uint32_t       uSpeedMbits;
+    RTUUID         Uuid;
+    char           szShortName[VBOXNET_MAX_SHORT_NAME];
+    char           szName[1];
+} NETIFINFO;
+
+/** Pointer to a network interface info. */
+typedef NETIFINFO *PNETIFINFO;
+/** Pointer to a const network interface info. */
+typedef NETIFINFO const *PCNETIFINFO;
+#endif
+
+int NetIfList(std::list <ComObjPtr<HostNetworkInterface> > &list);
+int NetIfEnableStaticIpConfig(VirtualBox *pVBox, HostNetworkInterface * pIf, ULONG aOldIp, ULONG aNewIp, ULONG aMask);
+int NetIfEnableStaticIpConfigV6(VirtualBox *pVBox, HostNetworkInterface *pIf, const Utf8Str &aOldIPV6Address, const Utf8Str &aIPV6Address, ULONG aIPV6MaskPrefixLength);
+int NetIfEnableDynamicIpConfig(VirtualBox *pVBox, HostNetworkInterface * pIf);
+#ifdef RT_OS_WINDOWS
+int NetIfCreateHostOnlyNetworkInterface(VirtualBox *pVBox, IHostNetworkInterface **aHostNetworkInterface, IProgress **aProgress,
+                                        IN_BSTR bstrName = NULL);
+#else
+int NetIfCreateHostOnlyNetworkInterface(VirtualBox *pVBox, IHostNetworkInterface **aHostNetworkInterface, IProgress **aProgress,
+                                        const char *pszName = NULL);
+#endif
+int NetIfRemoveHostOnlyNetworkInterface(VirtualBox *pVBox, const Guid &aId, IProgress **aProgress);
+int NetIfGetConfig(HostNetworkInterface * pIf, NETIFINFO *);
+int NetIfGetConfigByName(PNETIFINFO pInfo);
+int NetIfGetState(const char *pcszIfName, NETIFSTATUS *penmState);
+int NetIfGetLinkSpeed(const char *pcszIfName, uint32_t *puMbits);
+int NetIfDhcpRediscover(VirtualBox *pVBox, HostNetworkInterface * pIf);
+int NetIfAdpCtlOut(const char *pszName, const char *pszCmd, char *pszBuffer, size_t cBufSize);
+
+DECLINLINE(Bstr) getDefaultIPv4Address(Bstr bstrIfName)
+{
+    /* Get the index from the name */
+    Utf8Str strTmp = bstrIfName;
+    const char *pcszIfName = strTmp.c_str();
+    size_t iPos = strcspn(pcszIfName, "0123456789");
+    uint32_t uInstance = 0;
+    if (pcszIfName[iPos])
+        uInstance = RTStrToUInt32(pcszIfName + iPos);
+
+    in_addr tmp;
+#if defined(RT_OS_WINDOWS)
+    tmp.S_un.S_addr = VBOXNET_IPV4ADDR_DEFAULT + (uInstance << 16);
+#else
+    tmp.s_addr = VBOXNET_IPV4ADDR_DEFAULT + (uInstance << 16);
+#endif
+    char *addr = inet_ntoa(tmp);
+    return Bstr(addr);
+}
+
+#endif /* !MAIN_INCLUDED_netif_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/objectslist.h b/src/VBox/Main/include/objectslist.h
new file mode 100644
index 00000000..fad5a20b
--- /dev/null
+++ b/src/VBox/Main/include/objectslist.h
@@ -0,0 +1,224 @@
+/* $Id: objectslist.h $ */
+/** @file
+ *
+ * List of COM objects
+ */
+
+/*
+ * Copyright (C) 2009-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
+ */
+
+#ifndef MAIN_INCLUDED_objectslist_h
+#define MAIN_INCLUDED_objectslist_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <list>
+#include <VBox/com/ptr.h>
+
+/**
+ * Implements a "flat" objects list with a lock. Since each such list
+ * has its own lock it is not a good idea to implement trees with this.
+ *
+ * ObjectList<T> is designed to behave as if it were a std::list of
+ * COM pointers of class T; in other words,
+ * ObjectList<Medium> behaves like std::list< ComObjPtr<Medium> > but
+ * it's less typing. Iterators, front(), size(), begin() and end()
+ * are implemented.
+ *
+ * In addition it automatically includes an RWLockHandle which can be
+ * accessed with getLockHandle().
+ *
+ * If you need the raw std::list for some reason you can access it with
+ * getList().
+ *
+ * The destructor automatically calls uninit() on every contained
+ * COM object. If this is not desired, clear the member list before
+ * deleting the list object.
+ */
+template<typename T>
+class ObjectsList
+{
+public:
+    typedef ComObjPtr<T> MyType;
+    typedef std::list<MyType> MyList;
+
+    typedef typename MyList::iterator iterator;
+    typedef typename MyList::const_iterator const_iterator;
+        // typename is necessary to disambiguate "::iterator" in templates; see
+        // the "this might hurt your head" part in
+        // http://www.parashift.com/c++-faq-lite/templates.html#faq-35.18
+
+    ObjectsList(RWLockHandle &lockHandle)
+        : m_lock(lockHandle)
+    { }
+
+    ~ObjectsList()
+    {
+        uninitAll();
+    }
+
+private:
+    // prohibit copying and assignment
+    ObjectsList(const ObjectsList &d);
+    ObjectsList& operator=(const ObjectsList &d);
+
+public:
+
+    /**
+     * Returns the lock handle which protects this list, for use with
+     * AutoReadLock or AutoWriteLock.
+     */
+    RWLockHandle& getLockHandle()
+    {
+        return m_lock;
+    }
+
+    /**
+     * Calls m_ll.push_back(p) with locking.
+     * @param p
+     */
+    void addChild(MyType p)
+    {
+        AutoWriteLock al(m_lock COMMA_LOCKVAL_SRC_POS);
+        m_ll.push_back(p);
+    }
+
+    /**
+     * Calls m_ll.remove(p) with locking. Does NOT call uninit()
+     * on the contained object.
+     * @param p
+     */
+    void removeChild(MyType p)
+    {
+        AutoWriteLock al(m_lock COMMA_LOCKVAL_SRC_POS);
+        m_ll.remove(p);
+    }
+
+    /**
+     * Appends all objects from another list to the member list.
+     * Locks the other list for reading but does not lock "this"
+     * (because it might be on the caller's stack and needs no
+     * locking).
+     * @param ll
+     */
+    void appendOtherList(ObjectsList<T> &ll)
+    {
+        AutoReadLock alr(ll.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+        for (const_iterator it = ll.begin();
+             it != ll.end();
+             ++it)
+        {
+            m_ll.push_back(*it);
+        }
+    }
+
+    /**
+     * Calls uninit() on every COM object on the list and then
+     * clears the list, with locking.
+     */
+    void uninitAll()
+    {
+        /* The implementation differs from the high level description, because
+         * it isn't safe to hold any locks when invoking uninit() methods. It
+         * leads to incorrect lock order (first lock, then the Caller related
+         * event semaphore) and thus deadlocks. Dropping the lock is vital,
+         * and means we can't rely on iterators while not holding the lock. */
+        AutoWriteLock al(m_lock COMMA_LOCKVAL_SRC_POS);
+        while (!m_ll.empty())
+        {
+            /* Need a copy of the element, have to delete the entry before
+             * dropping the lock, otherwise someone else might mess with the
+             * list in the mean time, leading to erratic behavior. */
+            MyType q = m_ll.front();
+            m_ll.pop_front();
+            al.release();
+            q->uninit();
+            al.acquire();
+        }
+    }
+
+    /**
+     * Returns the no. of objects on the list (std::list compatibility)
+     * with locking.
+     */
+    size_t size()
+    {
+        AutoReadLock al(m_lock COMMA_LOCKVAL_SRC_POS);
+        return m_ll.size();
+    }
+
+    /**
+     * Returns a raw pointer to the member list of objects.
+     * Does not lock!
+     * @return
+     */
+    MyList& getList()
+    {
+        return m_ll;
+    }
+
+    /**
+     * Returns the first object on the list (std::list compatibility)
+     * with locking.
+     */
+    MyType front()
+    {
+        AutoReadLock al(m_lock COMMA_LOCKVAL_SRC_POS);
+        return m_ll.front();
+    }
+
+    /**
+     * Returns the begin iterator from the list (std::list compatibility).
+     * Does not lock!
+     * @return
+     */
+    iterator begin()
+    {
+        return m_ll.begin();
+    }
+
+    /**
+     * Returns the end iterator from the list (std::list compatibility).
+     * Does not lock!
+     */
+    iterator end()
+    {
+        return m_ll.end();
+    }
+
+    void insert(iterator it, MyType &p)
+    {
+        m_ll.insert(it, p);
+    }
+
+    void erase(iterator it)
+    {
+        m_ll.erase(it);
+    }
+
+private:
+    MyList          m_ll;
+    RWLockHandle    &m_lock;
+};
+
+#endif /* !MAIN_INCLUDED_objectslist_h */
diff --git a/src/VBox/Main/include/ovfreader.h b/src/VBox/Main/include/ovfreader.h
new file mode 100644
index 00000000..8cdb3906
--- /dev/null
+++ b/src/VBox/Main/include/ovfreader.h
@@ -0,0 +1,732 @@
+/* $Id: ovfreader.h $ */
+/** @file
+ * VirtualBox Main - OVF reader declarations.
+ *
+ * Depends only on IPRT, including the RTCString and IPRT XML classes.
+ */
+
+/*
+ * Copyright (C) 2008-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
+ */
+
+#ifndef MAIN_INCLUDED_ovfreader_h
+#define MAIN_INCLUDED_ovfreader_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "iprt/cpp/xml.h"
+#include <map>
+#include <vector>
+
+namespace ovf
+{
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Errors
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Thrown by OVFReader for any kind of error that is not an XML error but
+ * still makes the OVF impossible to parse. Based on xml::LogicError so
+ * that one catch() for all xml::LogicError can handle all possible errors.
+ */
+class OVFLogicError : public xml::LogicError
+{
+public:
+    OVFLogicError(const char *aFormat, ...);
+};
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Enumerations
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * CIM OS values.
+ *
+ * The OVF 1.10 spec refers to some CIM_OperatingSystem.mof doc.  Could this be it:
+ *  http://cvs.opengroup.org/cgi-bin/cvsweb.cgi/pegasus/Schemas/CIM231/DMTF/System/CIM_OperatingSystem.mof
+ *
+ * @todo r=bird: Why are the values are repeating 'CIMOS'. CIMOSType_T is also
+ *               repeating it self, 'Type' and '_T'. Why not call it kCIOMOpSys,
+ *               easier to read as well.
+ *               Then also apply: s/CIMOSType_CIMOS_/kCIMOpSys_/g
+ */
+enum CIMOSType_T
+{
+    CIMOSType_CIMOS_Unknown = 0,
+    CIMOSType_CIMOS_Other   = 1,
+    CIMOSType_CIMOS_MACOS   = 2,
+    CIMOSType_CIMOS_ATTUNIX = 3,
+    CIMOSType_CIMOS_DGUX    = 4,
+    CIMOSType_CIMOS_DECNT   = 5,
+    CIMOSType_CIMOS_Tru64UNIX   = 6,
+    CIMOSType_CIMOS_OpenVMS = 7,
+    CIMOSType_CIMOS_HPUX    = 8,
+    CIMOSType_CIMOS_AIX = 9,
+    CIMOSType_CIMOS_MVS = 10,
+    CIMOSType_CIMOS_OS400   = 11,
+    CIMOSType_CIMOS_OS2 = 12,
+    CIMOSType_CIMOS_JavaVM  = 13,
+    CIMOSType_CIMOS_MSDOS   = 14,
+    CIMOSType_CIMOS_WIN3x   = 15,
+    CIMOSType_CIMOS_WIN95   = 16,
+    CIMOSType_CIMOS_WIN98   = 17,
+    CIMOSType_CIMOS_WINNT   = 18,
+    CIMOSType_CIMOS_WINCE   = 19,
+    CIMOSType_CIMOS_NCR3000 = 20,
+    CIMOSType_CIMOS_NetWare = 21,
+    CIMOSType_CIMOS_OSF = 22,
+    CIMOSType_CIMOS_DCOS    = 23,
+    CIMOSType_CIMOS_ReliantUNIX = 24,
+    CIMOSType_CIMOS_SCOUnixWare = 25,
+    CIMOSType_CIMOS_SCOOpenServer   = 26,
+    CIMOSType_CIMOS_Sequent = 27,
+    CIMOSType_CIMOS_IRIX    = 28,
+    CIMOSType_CIMOS_Solaris = 29,
+    CIMOSType_CIMOS_SunOS   = 30,
+    CIMOSType_CIMOS_U6000   = 31,
+    CIMOSType_CIMOS_ASERIES = 32,
+    CIMOSType_CIMOS_HPNonStopOS = 33,
+    CIMOSType_CIMOS_HPNonStopOSS    = 34,
+    CIMOSType_CIMOS_BS2000  = 35,
+    CIMOSType_CIMOS_LINUX   = 36,
+    CIMOSType_CIMOS_Lynx    = 37,
+    CIMOSType_CIMOS_XENIX   = 38,
+    CIMOSType_CIMOS_VM  = 39,
+    CIMOSType_CIMOS_InteractiveUNIX = 40,
+    CIMOSType_CIMOS_BSDUNIX = 41,
+    CIMOSType_CIMOS_FreeBSD = 42,
+    CIMOSType_CIMOS_NetBSD  = 43,
+    CIMOSType_CIMOS_GNUHurd = 44,
+    CIMOSType_CIMOS_OS9 = 45,
+    CIMOSType_CIMOS_MACHKernel  = 46,
+    CIMOSType_CIMOS_Inferno = 47,
+    CIMOSType_CIMOS_QNX = 48,
+    CIMOSType_CIMOS_EPOC    = 49,
+    CIMOSType_CIMOS_IxWorks = 50,
+    CIMOSType_CIMOS_VxWorks = 51,
+    CIMOSType_CIMOS_MiNT    = 52,
+    CIMOSType_CIMOS_BeOS    = 53,
+    CIMOSType_CIMOS_HPMPE   = 54,
+    CIMOSType_CIMOS_NextStep    = 55,
+    CIMOSType_CIMOS_PalmPilot   = 56,
+    CIMOSType_CIMOS_Rhapsody    = 57,
+    CIMOSType_CIMOS_Windows2000 = 58,
+    CIMOSType_CIMOS_Dedicated   = 59,
+    CIMOSType_CIMOS_OS390   = 60,
+    CIMOSType_CIMOS_VSE = 61,
+    CIMOSType_CIMOS_TPF = 62,
+    CIMOSType_CIMOS_WindowsMe   = 63,
+    CIMOSType_CIMOS_CalderaOpenUNIX = 64,
+    CIMOSType_CIMOS_OpenBSD = 65,
+    CIMOSType_CIMOS_NotApplicable   = 66,
+    CIMOSType_CIMOS_WindowsXP   = 67,
+    CIMOSType_CIMOS_zOS = 68,
+    CIMOSType_CIMOS_MicrosoftWindowsServer2003  = 69,
+    CIMOSType_CIMOS_MicrosoftWindowsServer2003_64   = 70,
+    CIMOSType_CIMOS_WindowsXP_64    = 71,
+    CIMOSType_CIMOS_WindowsXPEmbedded   = 72,
+    CIMOSType_CIMOS_WindowsVista    = 73,
+    CIMOSType_CIMOS_WindowsVista_64 = 74,
+    CIMOSType_CIMOS_WindowsEmbeddedforPointofService    = 75,
+    CIMOSType_CIMOS_MicrosoftWindowsServer2008  = 76,
+    CIMOSType_CIMOS_MicrosoftWindowsServer2008_64   = 77,
+    CIMOSType_CIMOS_FreeBSD_64  = 78,
+    CIMOSType_CIMOS_RedHatEnterpriseLinux   = 79,
+    CIMOSType_CIMOS_RedHatEnterpriseLinux_64    = 80,
+    CIMOSType_CIMOS_Solaris_64  = 81,
+    CIMOSType_CIMOS_SUSE    = 82,
+    CIMOSType_CIMOS_SUSE_64 = 83,
+    CIMOSType_CIMOS_SLES    = 84,
+    CIMOSType_CIMOS_SLES_64 = 85,
+    CIMOSType_CIMOS_NovellOES   = 86,
+    CIMOSType_CIMOS_NovellLinuxDesktop  = 87,
+    CIMOSType_CIMOS_SunJavaDesktopSystem    = 88,
+    CIMOSType_CIMOS_Mandriva    = 89,
+    CIMOSType_CIMOS_Mandriva_64 = 90,
+    CIMOSType_CIMOS_TurboLinux  = 91,
+    CIMOSType_CIMOS_TurboLinux_64   = 92,
+    CIMOSType_CIMOS_Ubuntu  = 93,
+    CIMOSType_CIMOS_Ubuntu_64   = 94,
+    CIMOSType_CIMOS_Debian  = 95,
+    CIMOSType_CIMOS_Debian_64   = 96,
+    CIMOSType_CIMOS_Linux_2_4_x = 97,
+    CIMOSType_CIMOS_Linux_2_4_x_64  = 98,
+    CIMOSType_CIMOS_Linux_2_6_x = 99,
+    CIMOSType_CIMOS_Linux_2_6_x_64  = 100,
+    CIMOSType_CIMOS_Linux_64    = 101,
+    CIMOSType_CIMOS_Other_64    = 102,
+    // types added with CIM 2.25.0 follow:
+    CIMOSType_CIMOS_WindowsServer2008R2 = 103,
+    CIMOSType_CIMOS_VMwareESXi = 104,
+    CIMOSType_CIMOS_Windows7 = 105,
+    CIMOSType_CIMOS_CentOS = 106,
+    CIMOSType_CIMOS_CentOS_64 = 107,
+    CIMOSType_CIMOS_OracleLinux = 108,
+    CIMOSType_CIMOS_OracleLinux_64 = 109,
+    CIMOSType_CIMOS_eComStation = 110,
+    // no new types added with CIM 2.26.0
+    CIMOSType_CIMOS_WindowsServer2011 = 111,
+    CIMOSType_CIMOS_WindowsServer2012 = 112,
+    CIMOSType_CIMOS_Windows8 = 113,
+    CIMOSType_CIMOS_Windows8_64 = 114,
+    CIMOSType_CIMOS_WindowsServer2012R2 = 115,
+    CIMOSType_CIMOS_Windows8_1 = 116,
+    CIMOSType_CIMOS_Windows8_1_64 = 117,
+    CIMOSType_CIMOS_WindowsServer2016 = 118,
+    CIMOSType_CIMOS_Windows10 = 119,
+    CIMOSType_CIMOS_Windows10_64 = 120,
+    // the above covers up to CIM 2.52.0, without checking when it was added
+};
+
+enum OVFVersion_T
+{
+    OVFVersion_unknown,
+    OVFVersion_0_9,
+    OVFVersion_1_0,
+    OVFVersion_2_0
+};
+
+const char* const OVF09_URI_string = "http://www.vmware.com/schema/ovf/1/envelope";
+const char* const OVF10_URI_string = "http://schemas.dmtf.org/ovf/envelope/1";
+const char* const OVF20_URI_string = "http://schemas.dmtf.org/ovf/envelope/2";
+
+const char* const DTMF_SPECS_URI = "http://schemas.dmtf.org/wbem/cim-html/2/";
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Envelope data
+//
+////////////////////////////////////////////////////////////////////////////////
+struct EnvelopeData
+{
+    OVFVersion_T version;//OVF standard version, it is used internally only by VirtualBox
+    RTCString lang;//language
+
+    OVFVersion_T getOVFVersion() const
+    {
+            return version;
+    }
+
+
+    RTCString getStringOVFVersion() const
+    {
+        if (version == OVFVersion_0_9)
+            return "0.9";
+        else if (version == OVFVersion_1_0)
+            return "1.0";
+        else if (version == OVFVersion_2_0)
+            return "2.0";
+        else
+            return "";
+    }
+
+    void setOVFVersion(OVFVersion_T v)
+    {
+        version = v;
+    }
+};
+
+
+struct FileReference
+{
+    RTCString strHref;       // value from /References/File/@href (filename)
+    RTCString strDiskId;     // value from /References/File/@id ()
+};
+
+typedef std::map<uint32_t, FileReference> FileReferenceMap;
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Hardware definition structs
+//
+////////////////////////////////////////////////////////////////////////////////
+
+struct DiskImage
+{
+    // fields from /DiskSection/Disk
+    RTCString strDiskId;     // value from DiskSection/Disk/@diskId
+    int64_t iCapacity;              // value from DiskSection/Disk/@capacity;
+                                    // (maximum size for dynamic images, I guess; we always translate this to bytes)
+    int64_t iPopulatedSize;         // optional value from DiskSection/Disk/@populatedSize
+                                    // (actual used size of disk, always in bytes; can be an estimate of used disk
+                                    // space, but cannot be larger than iCapacity; -1 if not set)
+    RTCString strFormat;              // value from DiskSection/Disk/@format
+                // typically http://www.vmware.com/interfaces/specifications/vmdk.html#streamOptimized
+    RTCString uuidVBox;      // optional; if the file was exported by VirtualBox >= 3.2,
+                                    // then this has the UUID with which the disk was registered
+
+    // fields from /References/File; the spec says the file reference from disk can be empty,
+    // so in that case, strFilename will be empty, then a new disk should be created
+    RTCString strHref;       // value from /References/File/@href (filename); if empty, then the remaining fields are ignored
+    int64_t iSize;                  // value from /References/File/@size (optional according to spec; then we set -1 here)
+    int64_t iChunkSize;             // value from /References/File/@chunkSize (optional, unsupported)
+    RTCString strCompression; // value from /References/File/@compression (optional, can be "gzip" according to spec)
+
+    // additional field which has a descriptive size in megabytes derived from the above; this can be used for progress reports
+    uint32_t ulSuggestedSizeMB;
+};
+
+enum ResourceType_T
+{
+    ResourceType_Other  = 1,
+    ResourceType_ComputerSystem = 2,
+    ResourceType_Processor  = 3,
+    ResourceType_Memory = 4,
+    ResourceType_IDEController  = 5,
+    ResourceType_ParallelSCSIHBA    = 6,
+    ResourceType_FCHBA  = 7,
+    ResourceType_iSCSIHBA   = 8,
+    ResourceType_IBHCA  = 9,
+    ResourceType_EthernetAdapter    = 10,
+    ResourceType_OtherNetworkAdapter    = 11,
+    ResourceType_IOSlot = 12,
+    ResourceType_IODevice   = 13,
+    ResourceType_FloppyDrive    = 14,
+    ResourceType_CDDrive    = 15,
+    ResourceType_DVDDrive   = 16,
+    ResourceType_HardDisk   = 17,
+    ResourceType_TapeDrive  = 18,
+    ResourceType_StorageExtent  = 19,
+    ResourceType_OtherStorageDevice  = 20,
+    ResourceType_SerialPort = 21,
+    ResourceType_ParallelPort   = 22,
+    ResourceType_USBController  = 23,
+    ResourceType_GraphicsController = 24,
+    ResourceType_IEEE1394Controller = 25,
+    ResourceType_PartitionableUnit  = 26,
+    ResourceType_BasePartitionableUnit  = 27,
+    ResourceType_Power  = 28,
+    ResourceType_CoolingCapacity    = 29,
+    ResourceType_EthernetSwitchPort = 30,
+    ResourceType_LogicalDisk    = 31,
+    ResourceType_StorageVolume  = 32,
+    ResourceType_EthernetConnection = 33,
+    ResourceType_SoundCard  = 35    /**< @todo r=klaus: Not part of OVF/CIM spec, should use "Other" or some value from 0x8000..0xffff. */
+};
+
+
+enum StorageAccessType_T
+{   StorageAccessType_Unknown = 0,
+    StorageAccessType_Readable = 1,
+    StorageAccessType_Writeable = 2,
+    StorageAccessType_ReadWrite = 3
+};
+
+enum ComplianceType_T
+{   ComplianceType_No = 0,
+    ComplianceType_Soft = 1,
+    ComplianceType_Medium = 2,
+    ComplianceType_Strong = 3
+};
+
+class VirtualHardwareItem
+{
+public:
+    RTCString strDescription;
+    RTCString strCaption;
+    RTCString strElementName;
+
+    RTCString strInstanceID;
+    RTCString strParent;
+
+    ResourceType_T resourceType;
+    RTCString strOtherResourceType;
+    RTCString strResourceSubType;
+    bool fResourceRequired;
+
+    RTCString strHostResource;   ///< "Abstractly specifies how a device shall connect to a resource on the deployment platform.
+                                 /// Not all devices need a backing." Used with disk items, for which this
+                                 /// references a virtual disk from the Disks section.
+    bool fAutomaticAllocation;
+    bool fAutomaticDeallocation;
+    RTCString strConnection;     ///< "All Ethernet adapters that specify the same abstract network connection name within an OVF
+                                 /// package shall be deployed on the same network. The abstract network connection name shall be
+                                 /// listed in the NetworkSection at the outermost envelope level." We ignore this and only set up
+                                 /// a network adapter depending on the network name.
+    RTCString strAddress;        ///< "Device-specific. For an Ethernet adapter, this specifies the MAC address."
+    int32_t lAddress;            ///< strAddress as an integer, if applicable.
+    RTCString strAddressOnParent;///< "For a device, this specifies its location on the controller."
+    RTCString strAllocationUnits;///< "Specifies the units of allocation used. For example, “byte * 2^20”."
+    uint64_t ullVirtualQuantity; ///< "Specifies the quantity of resources presented. For example, “256”."
+    uint64_t ullReservation;     ///< "Specifies the minimum quantity of resources guaranteed to be available."
+    uint64_t ullLimit;           ///< "Specifies the maximum quantity of resources that will be granted."
+    uint64_t ullWeight;          ///< "Specifies a relative priority for this allocation in relation to other allocations."
+
+    RTCString strConsumerVisibility;
+    RTCString strMappingBehavior;
+    RTCString strPoolID;
+    uint32_t ulBusNumber;        ///< seen with IDE controllers, but not listed in OVF spec
+
+    int m_iLineNumber;           ///< line number of \<Item\> element in XML source; cached for error messages
+
+    VirtualHardwareItem()
+        : fResourceRequired(false)
+        , fAutomaticAllocation(false)
+        , fAutomaticDeallocation(false)
+        , ullVirtualQuantity(0)
+        , ullReservation(0)
+        , ullLimit(0)
+        , ullWeight(0)
+        , ulBusNumber(0)
+        , m_iLineNumber(0)
+        , fDefault(false)
+    {
+        itemName = "Item";
+    }
+
+    virtual ~VirtualHardwareItem() { /* Makes MSC happy. */ }
+
+    void fillItem(const xml::ElementNode *item);
+
+    void setDefaultFlag()
+    {
+        fDefault = true;
+    }
+
+    bool isThereDefaultValues() const
+    {
+        return fDefault;
+    }
+
+    void checkConsistencyAndCompliance() RT_THROW(OVFLogicError)
+    {
+        _checkConsistencyAndCompliance();
+    }
+
+protected:
+    virtual void _checkConsistencyAndCompliance() RT_THROW(OVFLogicError);
+    virtual const RTCString& getItemName()
+    {
+        return _getItemName();
+    }
+
+private:
+    RTCString itemName;
+    bool fDefault;//true means that some fields were absent in the XML and some default values were assigned to.
+
+    virtual const RTCString& _getItemName()
+    {
+        return itemName;
+    }
+};
+
+class StorageItem: public VirtualHardwareItem
+{
+    //see DMTF Schema Documentation http://schemas.dmtf.org/wbem/cim-html/2/
+    StorageAccessType_T accessType;
+    RTCString strHostExtentName;
+#if 0 /* unused */
+    int16_t hostExtentNameFormat;
+    int16_t hostExtentNameNamespace;
+    int64_t hostExtentStartingAddress;
+#endif
+    int64_t hostResourceBlockSize;
+    int64_t limit;
+    RTCString strOtherHostExtentNameFormat;
+    RTCString strOtherHostExtentNameNamespace;
+    int64_t reservation;
+    int64_t virtualQuantity;
+    RTCString strVirtualQuantityUnits;
+    int64_t virtualResourceBlockSize;
+
+public:
+    StorageItem()
+        : VirtualHardwareItem()
+        , accessType(StorageAccessType_Unknown)
+#if 0 /* unused */
+        , hostExtentNameFormat(-1)
+        , hostExtentNameNamespace(-1)
+        , hostExtentStartingAddress(-1)
+#endif
+        , hostResourceBlockSize(-1)
+        , limit(-1)
+        , reservation(-1)
+        , virtualQuantity(-1)
+        , virtualResourceBlockSize(-1)
+    {
+        itemName = "StorageItem";
+    };
+
+    void fillItem(const xml::ElementNode *item);
+
+protected:
+    virtual void _checkConsistencyAndCompliance() RT_THROW(OVFLogicError);
+private:
+    RTCString itemName;
+
+    virtual const RTCString& _getItemName()
+    {
+        return itemName;
+    }
+};
+
+
+class EthernetPortItem: public VirtualHardwareItem
+{
+    //see DMTF Schema Documentation http://schemas.dmtf.org/wbem/cim-html/2/
+#if 0 /* unused */
+    uint16_t DefaultPortVID;
+    uint16_t DefaultPriority;
+    uint16_t DesiredVLANEndpointMode;
+    uint32_t GroupID;
+    uint32_t ManagerID;
+    uint16_t NetworkPortProfileIDType;
+#endif
+    RTCString strNetworkPortProfileID;
+    RTCString strOtherEndpointMode;
+    RTCString strOtherNetworkPortProfileIDTypeInfo;
+    RTCString strPortCorrelationID;
+#if 0 /* unused */
+    uint16_t PortVID;
+    bool Promiscuous;
+    uint64_t ReceiveBandwidthLimit;
+    uint16_t ReceiveBandwidthReservation;
+    bool SourceMACFilteringEnabled;
+    uint32_t VSITypeID;
+    uint8_t VSITypeIDVersion;
+    uint16_t AllowedPriorities[256];
+    uint16_t AllowedToReceiveVLANs[256];
+    uint16_t AllowedToTransmitVLANs[256];
+#endif
+    RTCString strAllowedToReceiveMACAddresses;
+    RTCString strAllowedToTransmitMACAddresses;
+
+public:
+    EthernetPortItem() : VirtualHardwareItem()
+    {
+        itemName = "EthernetPortItem";
+    };
+
+    void fillItem(const xml::ElementNode *item);
+
+protected:
+    virtual void _checkConsistencyAndCompliance() RT_THROW(OVFLogicError);
+private:
+    RTCString itemName;
+
+    virtual const RTCString& _getItemName()
+    {
+        return itemName;
+    }
+};
+
+typedef std::map<RTCString, DiskImage> DiskImagesMap;
+
+struct VirtualSystem;
+
+
+/**
+ * VirtualHardwareItem pointer vector with safe cleanup.
+ *
+ * We need to use object pointers because we also want EthernetPortItem and
+ * StorageItems to go into the container.
+ */
+class HardwareItemVector : public std::vector<VirtualHardwareItem *>
+{
+public:
+    HardwareItemVector() : std::vector<VirtualHardwareItem *>() { }
+    ~HardwareItemVector()
+    {
+        for (iterator it = begin(); it != end(); ++it)
+            delete(*it);
+        clear();
+    }
+
+    /* There is no copying of this vector.  We'd need something like shared_ptr for that. */
+private:
+    HardwareItemVector(const VirtualSystem &);
+
+};
+
+struct HardDiskController
+{
+    RTCString               strIdController;    // instance ID (Item/InstanceId); this gets referenced from VirtualDisk
+
+    enum ControllerSystemType { IDE, SATA, SCSI, VIRTIOSCSI, NVMe };
+    ControllerSystemType    system;             // one of IDE, SATA, SCSI, VIRTIOSCSI, NVMe
+
+    RTCString               strControllerType;
+            // controller subtype (Item/ResourceSubType); e.g. "LsiLogic"; can be empty (esp. for IDE)
+            // note that we treat LsiLogicSAS as a SCSI controller (system == SCSI) even though VirtualBox
+            // treats it as a fourth class besides IDE, SATA, SCSI
+
+    int32_t                 lAddress;           // value from OVF "Address" element
+    bool                    fPrimary;           // controller index; this is determined heuristically by the OVF reader and will
+                                                // be true for the first controller of this type (e.g. IDE primary ctler) or
+                                                // false for the next (e.g. IDE secondary ctler)
+
+    HardDiskController()
+        : lAddress(0),
+          fPrimary(true)
+    { }
+};
+
+typedef std::map<RTCString, HardDiskController> ControllersMap;
+
+struct VirtualDisk
+{
+    RTCString   strIdController;    // SCSI (or IDE) controller this disk is connected to;
+                                    // this must match HardDiskController.strIdController and
+                                    // points into VirtualSystem.mapControllers
+    uint32_t    ulAddressOnParent;  // parsed strAddressOnParent of hardware item; will be 0 or 1 for IDE
+                                    // and possibly higher for disks attached to SCSI controllers (untested)
+    RTCString   strDiskId;          // if the hard disk has an ovf:/disk/<id> reference,
+                                    // this receives the <id> component; points to one of the
+                                    // references in Appliance::Data.mapDisks
+    bool        fEmpty; //true - empty disk, e.g. the component <rasd:HostResource>...</rasd:HostResource> is absent.
+};
+
+typedef std::map<RTCString, VirtualDisk> VirtualDisksMap;
+
+/**
+ * A list of EthernetAdapters is contained in VirtualSystem, representing the
+ * ethernet adapters in the virtual system.
+ */
+struct EthernetAdapter
+{
+    RTCString    strAdapterType;         // "PCNet32" or "E1000" or whatever; from <rasd:ResourceSubType>
+    RTCString    strNetworkName;         // from <rasd:Connection>
+};
+
+typedef std::list<EthernetAdapter> EthernetAdaptersList;
+
+/**
+ * A list of VirtualSystem structs is created by OVFReader::read(). Each refers to
+ * a \<VirtualSystem\> block in the OVF file.
+ */
+struct VirtualSystem
+{
+    RTCString    strName;                // copy of VirtualSystem/@id
+
+    RTCString    strDescription;         // copy of VirtualSystem/AnnotationSection content, if any
+
+    CIMOSType_T  cimos;
+    RTCString    strCimosDesc;           // readable description of the cimos type in the case of cimos = 0/1/102
+    RTCString    strTypeVBox;            // optional type from @vbox:ostype attribute (VirtualBox 4.0 or higher)
+
+    RTCString    strVirtualSystemType;   // generic hardware description; OVF says this can be something like "vmx-4" or "xen";
+                                                // VMware Workstation 6.5 is "vmx-07"
+
+    HardwareItemVector  vecHardwareItems;       //< vector containing all virtual hardware items in parsing order.
+
+    uint64_t            ullMemorySize;          // always in bytes, copied from llHardwareItems; default = 0 (unspecified)
+    uint16_t            cCPUs;                  // no. of CPUs, copied from llHardwareItems; default = 1
+
+    EthernetAdaptersList llEthernetAdapters;    // (one for each VirtualSystem/Item[@ResourceType=10]element)
+
+    ControllersMap      mapControllers;
+            // list of hard disk controllers
+            // (one for each VirtualSystem/Item[@ResourceType=6] element with accumulated data from children)
+
+    VirtualDisksMap     mapVirtualDisks;
+            // (one for each VirtualSystem/Item[@ResourceType=17] element with accumulated data from children)
+
+    bool                fHasFloppyDrive;        // true if there's a floppy item in mapHardwareItems
+    bool                fHasCdromDrive;         // true if there's a CD-ROM item in mapHardwareItems; ISO images are not yet supported by OVFtool
+    bool                fHasUsbController;      // true if there's a USB controller item in mapHardwareItems
+
+    RTCString    strSoundCardType;       // if not empty, then the system wants a soundcard; this then specifies the hardware;
+                                                // VMware Workstation 6.5 uses "ensoniq1371" for example
+
+    RTCString    strLicenseText;         // license info if any; receives contents of VirtualSystem/EulaSection/License
+
+    RTCString    strProduct;             // product info if any; receives contents of VirtualSystem/ProductSection/Product
+    RTCString    strVendor;              // product info if any; receives contents of VirtualSystem/ProductSection/Vendor
+    RTCString    strVersion;             // product info if any; receives contents of VirtualSystem/ProductSection/Version
+    RTCString    strProductUrl;          // product info if any; receives contents of VirtualSystem/ProductSection/ProductUrl
+    RTCString    strVendorUrl;           // product info if any; receives contents of VirtualSystem/ProductSection/VendorUrl
+
+    const xml::ElementNode *pelmVBoxMachine; // pointer to <vbox:Machine> element under <VirtualSystem> element or NULL if not present
+
+    VirtualSystem()
+        : cimos(CIMOSType_CIMOS_Unknown),
+          ullMemorySize(0),
+          cCPUs(1),
+          fHasFloppyDrive(false),
+          fHasCdromDrive(false),
+          fHasUsbController(false),
+          pelmVBoxMachine(NULL)
+    {
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Class OVFReader
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * OVFReader attempts to open, read in and parse an OVF XML file. This is all done
+ * in the constructor; if there is any kind of error in the file -- filesystem error
+ * from IPRT, XML parsing errors from libxml, or OVF logical errors --, exceptions
+ * are thrown. These are all based on xml::Error.
+ *
+ * Hence, use this class as follows:
+<code>
+    OVFReader *pReader = NULL;
+    try
+    {
+        pReader = new("/path/to/file.ovf");
+    }
+    catch (xml::Error &e)
+    {
+        printf("A terrible thing happened: %s", e.what());
+    }
+    // now go look at pReader->m_llVirtualSystem and what's in there
+    if (pReader)
+        delete pReader;
+</code>
+ */
+class OVFReader
+{
+public:
+    OVFReader();
+    OVFReader(const void *pvBuf, size_t cbSize, const RTCString &path);
+    OVFReader(const RTCString &path);
+
+    // Data fields
+    EnvelopeData                m_envelopeData;       //data of root element "Envelope"
+    RTCString                   m_strPath;            // file name given to constructor
+    DiskImagesMap               m_mapDisks;           // map of DiskImage structs, sorted by DiskImage.strDiskId
+    std::list<VirtualSystem>    m_llVirtualSystems;   // list of virtual systems, created by and valid after read()
+
+private:
+    xml::Document               m_doc;
+
+    void parse();
+    void LoopThruSections(const xml::ElementNode *pReferencesElem, const xml::ElementNode *pCurElem);
+    void HandleDiskSection(const xml::ElementNode *pReferencesElem, const xml::ElementNode *pSectionElem);
+    void HandleNetworkSection(const xml::ElementNode *pSectionElem);
+    void HandleVirtualSystemContent(const xml::ElementNode *pContentElem);
+};
+
+} // end namespace ovf
+
+#endif /* !MAIN_INCLUDED_ovfreader_h */
+
diff --git a/src/VBox/Main/include/vbox-libhal.h b/src/VBox/Main/include/vbox-libhal.h
new file mode 100644
index 00000000..6e0d0a82
--- /dev/null
+++ b/src/VBox/Main/include/vbox-libhal.h
@@ -0,0 +1,80 @@
+/* $Id: vbox-libhal.h $ */
+/** @file
+ *
+ * Module to dynamically load libhal and libdbus and load all symbols
+ * which are needed by VirtualBox.
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_vbox_libhal_h
+#define MAIN_INCLUDED_vbox_libhal_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <stdint.h>
+
+#define LIB_HAL "libhal.so.1"
+
+/** Types from the dbus and hal header files which we need.  These are taken more or less
+    verbatim from the DBus and Hal public interface header files. */
+struct DBusError
+{
+    const char *name;
+    const char *message;
+    unsigned int dummy1 : 1; /**< placeholder */
+    unsigned int dummy2 : 1; /**< placeholder */
+    unsigned int dummy3 : 1; /**< placeholder */
+    unsigned int dummy4 : 1; /**< placeholder */
+    unsigned int dummy5 : 1; /**< placeholder */
+    void *padding1; /**< placeholder */
+};
+struct DBusConnection;
+typedef struct DBusConnection DBusConnection;
+typedef uint32_t dbus_bool_t;
+typedef enum { DBUS_BUS_SESSON, DBUS_BUS_SYSTEM, DBUS_BUS_STARTER } DBusBusType;
+struct LibHalContext_s;
+typedef struct LibHalContext_s LibHalContext;
+
+/** The following are the symbols which we need from libdbus and libhal. */
+extern void (*gDBusErrorInit)(DBusError *);
+extern DBusConnection *(*gDBusBusGet)(DBusBusType, DBusError *);
+extern void (*gDBusErrorFree)(DBusError *);
+extern void (*gDBusConnectionUnref)(DBusConnection *);
+extern LibHalContext *(*gLibHalCtxNew)(void);
+extern dbus_bool_t (*gLibHalCtxSetDBusConnection)(LibHalContext *, DBusConnection *);
+extern dbus_bool_t (*gLibHalCtxInit)(LibHalContext *, DBusError *);
+extern char **(*gLibHalFindDeviceStringMatch)(LibHalContext *, const char *, const char *, int *,
+               DBusError *);
+extern char *(*gLibHalDeviceGetPropertyString)(LibHalContext *, const char *, const char *,
+                                              DBusError *);
+extern void (*gLibHalFreeString)(char *);
+extern void (*gLibHalFreeStringArray)(char **);
+extern dbus_bool_t (*gLibHalCtxShutdown)(LibHalContext *, DBusError *);
+extern dbus_bool_t (*gLibHalCtxFree)(LibHalContext *);
+
+extern bool gLibHalCheckPresence(void);
+
+#endif /* !MAIN_INCLUDED_vbox_libhal_h */
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */
diff --git a/src/VBox/Main/include/vector.h b/src/VBox/Main/include/vector.h
new file mode 100644
index 00000000..08671457
--- /dev/null
+++ b/src/VBox/Main/include/vector.h
@@ -0,0 +1,372 @@
+/* $Id: vector.h $ */
+/** @file
+ * STL-inspired vector implementation in C
+ * @note  functions in this file are inline to prevent warnings about
+ *        unused static functions.  I assume that in this day and age a
+ *        compiler makes its own decisions about whether to actually
+ *        inline a function.
+ * @note  as this header is included in rdesktop-vrdp, we do not include other
+ *        required header files here (to wit assert.h, err.h, mem.h and
+ *        types.h).  These must be included first.  If this moves to iprt, we
+ *        should write a wrapper around it doing that.
+ * @todo  can we do more of the type checking at compile time somehow?
+ */
+
+/*
+ * Copyright (C) 2008-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
+ */
+
+#ifndef MAIN_INCLUDED_vector_h
+#define MAIN_INCLUDED_vector_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <stdlib.h>
+
+
+/*********************************************************************************************************************************
+*   Helper macros and definitions                                                                                                *
+*********************************************************************************************************************************/
+
+/** The unit by which the vector capacity is increased */
+#define VECTOR_ALLOC_UNIT 16
+
+/** Calculate a hash of a string of tokens for sanity type checking */
+#define VECTOR_TOKEN_HASH(token) \
+    ((unsigned) \
+     (  VECTOR_TOKEN_HASH4(token, 0) \
+      ^ VECTOR_TOKEN_HASH4(token, 4) \
+      ^ VECTOR_TOKEN_HASH4(token, 8) \
+      ^ VECTOR_TOKEN_HASH4(token, 12)))
+
+/** Helper macro for @a VECTOR_TOKEN_HASH */
+#define VECTOR_TOKEN_HASH_VALUE(token, place, mul) \
+    (sizeof(#token) > place ? #token[place] * mul : 0)
+
+/** Helper macro for @a VECTOR_TOKEN_HASH */
+#define VECTOR_TOKEN_HASH4(token, place) \
+      VECTOR_TOKEN_HASH_VALUE(token, place,     0x1) \
+    ^ VECTOR_TOKEN_HASH_VALUE(token, place + 1, 0x100) \
+    ^ VECTOR_TOKEN_HASH_VALUE(token, place + 2, 0x10000) \
+    ^ VECTOR_TOKEN_HASH_VALUE(token, place + 3, 0x1000000)
+
+/** Generic vector structure, used by @a VECTOR_OBJ and @a VECTOR_PTR */
+#define VECTOR_STRUCT \
+{ \
+    /** The number of elements in the vector */ \
+    size_t mcElements; \
+    /** The current capacity of the vector */ \
+    size_t mcCapacity; \
+    /** The size of an element */ \
+    size_t mcbElement; \
+    /** Hash value of the element type */ \
+    unsigned muTypeHash; \
+    /** The elements themselves */ \
+    void *mpvaElements; \
+    /** Destructor for elements - takes a pointer to an element. */ \
+    void (*mpfnCleanup)(void *); \
+}
+
+/*** Structure definitions ***/
+
+/** A vector of values or objects */
+typedef struct VECTOR_OBJ VECTOR_STRUCT VECTOR_OBJ;
+
+/** A vector of pointer values.  (A handy special case.) */
+typedef struct VECTOR_PTR VECTOR_STRUCT VECTOR_PTR;
+
+/** Convenience macro for annotating the type of the vector.  Unfortunately the
+ * type name is only cosmetic. */
+/** @todo can we do something useful with the type? */
+#define VECTOR_OBJ(type) VECTOR_OBJ
+
+/** Convenience macro for annotating the type of the vector.  Unfortunately the
+ * type name is only cosmetic. */
+#define VECTOR_PTR(type) VECTOR_PTR
+
+/*** Private helper functions and macros ***/
+
+#define VEC_GET_ELEMENT_OBJ(pvaElements, cbElement, cElement) \
+    ((void *)((char *)(pvaElements) + (cElement) * (cbElement)))
+
+#define VEC_GET_ELEMENT_PTR(pvaElements, cElement) \
+    (*(void **)VEC_GET_ELEMENT_OBJ(pvaElements, sizeof(void *), cElement))
+
+/** Default cleanup function that does nothing. */
+DECLINLINE(void) vecNoCleanup(void *pvElement)
+{
+    (void) pvElement;
+}
+
+/** Expand an existing vector, implementation */
+DECLINLINE(int) vecExpand(size_t *pcCapacity, void **ppvaElements,
+                            size_t cbElement)
+{
+    size_t cOldCap, cNewCap;
+    void *pRealloc;
+
+    cOldCap = *pcCapacity;
+    cNewCap = cOldCap + VECTOR_ALLOC_UNIT;
+    pRealloc = RTMemRealloc(*ppvaElements, cNewCap * cbElement);
+    if (!pRealloc)
+        return VERR_NO_MEMORY;
+    *pcCapacity = cNewCap;
+    *ppvaElements = pRealloc;
+    return VINF_SUCCESS;
+}
+
+/** Expand an existing vector */
+#define VEC_EXPAND(pvec) vecExpand(&(pvec)->mcCapacity, &(pvec)->mpvaElements, \
+                                   (pvec)->mcbElement)
+
+/** Reset a vector, cleaning up all its elements. */
+DECLINLINE(void) vecClearObj(VECTOR_OBJ *pvec)
+{
+    unsigned i;
+
+    for (i = 0; i < pvec->mcElements; ++i)
+        pvec->mpfnCleanup(VEC_GET_ELEMENT_OBJ(pvec->mpvaElements,
+                                              pvec->mcbElement, i));
+    pvec->mcElements = 0;
+}
+
+/** Reset a pointer vector, cleaning up all its elements. */
+DECLINLINE(void) vecClearPtr(VECTOR_PTR *pvec)
+{
+    unsigned i;
+
+    for (i = 0; i < pvec->mcElements; ++i)
+        pvec->mpfnCleanup(VEC_GET_ELEMENT_PTR(pvec->mpvaElements, i));
+    pvec->mcElements = 0;
+}
+
+/** Clean up a vector */
+DECLINLINE(void) vecCleanupObj(VECTOR_OBJ *pvec)
+{
+    vecClearObj(pvec);
+    RTMemFree(pvec->mpvaElements);
+    pvec->mpvaElements = NULL;
+}
+
+/** Clean up a pointer vector */
+DECLINLINE(void) vecCleanupPtr(VECTOR_PTR *pvec)
+{
+    vecClearPtr(pvec);
+    RTMemFree(pvec->mpvaElements);
+    pvec->mpvaElements = NULL;
+}
+
+/** Initialise a vector structure, implementation */
+#define VEC_INIT(pvec, cbElement, uTypeHash, pfnCleanup) \
+    pvec->mcElements = pvec->mcCapacity = 0; \
+    pvec->mcbElement = cbElement; \
+    pvec->muTypeHash = uTypeHash; \
+    pvec->mpfnCleanup = pfnCleanup ? pfnCleanup : vecNoCleanup; \
+    pvec->mpvaElements = NULL;
+
+/** Initialise a vector. */
+DECLINLINE(void) vecInitObj(VECTOR_OBJ *pvec, size_t cbElement,
+                            unsigned uTypeHash, void (*pfnCleanup)(void *))
+{
+    VEC_INIT(pvec, cbElement, uTypeHash, pfnCleanup)
+}
+
+/** Initialise a pointer vector. */
+DECLINLINE(void) vecInitPtr(VECTOR_PTR *pvec, size_t cbElement,
+                            unsigned uTypeHash, void (*pfnCleanup)(void *))
+{
+    VEC_INIT(pvec, cbElement, uTypeHash, pfnCleanup)
+}
+
+/** Add an element onto the end of a vector */
+DECLINLINE(int) vecPushBackObj(VECTOR_OBJ *pvec, unsigned uTypeHash,
+                                 void *pvElement)
+{
+    AssertReturn(pvec->muTypeHash == uTypeHash, VERR_INVALID_PARAMETER);
+    if (pvec->mcElements == pvec->mcCapacity)
+    {
+        int vrc2 = VEC_EXPAND(pvec);
+        if (RT_FAILURE(vrc2))
+            return vrc2;
+    }
+    memcpy(VEC_GET_ELEMENT_OBJ(pvec->mpvaElements, pvec->mcbElement,
+                               pvec->mcElements), pvElement, pvec->mcbElement);
+    ++pvec->mcElements;
+    return VINF_SUCCESS;
+}
+
+/** Add a pointer onto the end of a pointer vector */
+DECLINLINE(int) vecPushBackPtr(VECTOR_PTR *pvec, unsigned uTypeHash,
+                                 void *pv)
+{
+    AssertReturn(pvec->muTypeHash == uTypeHash, VERR_INVALID_PARAMETER);
+    if (pvec->mcElements == pvec->mcCapacity)
+    {
+        int vrc2 = VEC_EXPAND(pvec);
+        if (RT_FAILURE(vrc2))
+            return vrc2;
+    }
+    VEC_GET_ELEMENT_PTR(pvec->mpvaElements, pvec->mcElements) = pv;
+    ++pvec->mcElements;
+    return VINF_SUCCESS;
+}
+
+
+/*********************************************************************************************************************************
+*   Public interface macros                                                                                                      *
+*********************************************************************************************************************************/
+
+/**
+ * Initialise a vector structure.  Always succeeds.
+ * @param   pvec        pointer to an uninitialised vector structure
+ * @param   type        the type of the objects in the vector.  As this is
+ *                      hashed by the preprocessor use of space etc is
+ *                      important.
+ * @param   pfnCleanup  cleanup function (void (*pfn)(void *)) that is called
+ *                      on a pointer to a vector element when that element is
+ *                      dropped
+ */
+#define VEC_INIT_OBJ(pvec, type, pfnCleanup) \
+    vecInitObj(pvec, sizeof(type), VECTOR_TOKEN_HASH(type), \
+               (void (*)(void*)) pfnCleanup)
+
+/**
+ * Initialise a vector-of-pointers structure.  Always succeeds.
+ * @param   pvec        pointer to an uninitialised vector structure
+ * @param   type        the type of the pointers in the vector, including the
+ *                      final "*".  As this is hashed by the preprocessor use
+ *                      of space etc is important.
+ * @param   pfnCleanup  cleanup function (void (*pfn)(void *)) that is called
+ *                      directly on a vector element when that element is
+ *                      dropped
+ */
+#define VEC_INIT_PTR(pvec, type, pfnCleanup) \
+    vecInitPtr(pvec, sizeof(type), VECTOR_TOKEN_HASH(type), \
+               (void (*)(void*)) pfnCleanup)
+
+/**
+ * Clean up a vector.
+ * @param pvec  pointer to the vector to clean up.  The clean up function
+ *              specified at initialisation (if any) is called for each element
+ *              in the vector.  After clean up, the vector structure is invalid
+ *              until it is re-initialised
+ */
+#define VEC_CLEANUP_OBJ vecCleanupObj
+
+/**
+ * Clean up a vector-of-pointers.
+ * @param pvec  pointer to the vector to clean up.  The clean up function
+ *              specified at initialisation (if any) is called for each element
+ *              in the vector.  After clean up, the vector structure is invalid
+ *              until it is re-initialised
+ */
+#define VEC_CLEANUP_PTR vecCleanupPtr
+
+/**
+ * Reinitialises a vector structure to empty.
+ * @param  pvec  pointer to the vector to re-initialise.  The clean up function
+ *               specified at initialisation (if any) is called for each element
+ *               in the vector.
+ */
+#define VEC_CLEAR_OBJ vecClearObj
+
+/**
+ * Reinitialises a vector-of-pointers structure to empty.
+ * @param  pvec  pointer to the vector to re-initialise.  The clean up function
+ *               specified at initialisation (if any) is called for each element
+ *               in the vector.
+ */
+#define VEC_CLEAR_PTR vecClearPtr
+
+/**
+ * Adds an element to the back of a vector.  The element will be byte-copied
+ * and become owned by the vector, to be cleaned up by the vector's clean-up
+ * routine when the element is dropped.
+ * @returns iprt status code (VINF_SUCCESS or VERR_NO_MEMORY)
+ * @returns VERR_INVALID_PARAMETER if the type does not match the type given
+ *          when the vector was initialised (asserted)
+ * @param pvec       pointer to the vector on to which the element should be
+ *                   added
+ * @param type       the type of the vector as specified at initialisation.
+ *                   Spacing etc is important.
+ * @param pvElement  void pointer to the element to be added
+ */
+#define VEC_PUSH_BACK_OBJ(pvec, type, pvElement) \
+    vecPushBackObj(pvec, VECTOR_TOKEN_HASH(type), \
+                   (pvElement) + ((pvElement) - (type *)(pvElement)))
+
+/**
+ * Adds a pointer to the back of a vector-of-pointers.  The pointer will become
+ * owned by the vector, to be cleaned up by the vector's clean-up routine when
+ * it is dropped.
+ * @returns iprt status code (VINF_SUCCESS or VERR_NO_MEMORY)
+ * @returns VERR_INVALID_PARAMETER if the type does not match the type given
+ *          when the vector was initialised (asserted)
+ * @param pvec       pointer to the vector on to which the element should be
+ *                   added
+ * @param type       the type of the vector as specified at initialisation.
+ *                   Spacing etc is important.
+ * @param pvElement  the pointer to be added, typecast to pointer-to-void
+ */
+#define VEC_PUSH_BACK_PTR(pvec, type, pvElement) \
+    vecPushBackPtr(pvec, VECTOR_TOKEN_HASH(type), \
+                   (pvElement) + ((pvElement) - (type)(pvElement)))
+
+/**
+ * Returns the count of elements in a vector.
+ * @param  pvec  pointer to the vector.
+ */
+#define VEC_SIZE_OBJ(pvec) (pvec)->mcElements
+
+/**
+ * Returns the count of elements in a vector-of-pointers.
+ * @param  pvec  pointer to the vector.
+ */
+#define VEC_SIZE_PTR VEC_SIZE_OBJ
+
+/**
+ * Iterates over a vector.
+ *
+ * Iterates over the vector elements from first to last and execute the
+ * following instruction or block on each iteration with @a pIterator set to
+ * point to the current element (that is, a pointer to the pointer element for
+ * a vector-of-pointers).  Use in the same way as a "for" statement.
+ *
+ * @param pvec       Pointer to the vector to be iterated over.
+ * @param type       The type of the vector, must match the type specified at
+ *                   vector initialisation (including whitespace etc).
+ * @param pIterator  A pointer to @a type which will be set to point to the
+ *                   current vector element on each iteration.
+ *
+ * @todo  can we assert the correctness of the type in some way?
+ */
+#define VEC_FOR_EACH(pvec, type, pIterator) \
+    for (pIterator = (type *) (pvec)->mpvaElements; \
+            (pvec)->muTypeHash == VECTOR_TOKEN_HASH(type) \
+         && pIterator < (type *) (pvec)->mpvaElements + (pvec)->mcElements; \
+         ++pIterator)
+
+#endif /* !MAIN_INCLUDED_vector_h */
diff --git a/src/VBox/Main/include/win/resource.h b/src/VBox/Main/include/win/resource.h
new file mode 100644
index 00000000..d6aeecdc
--- /dev/null
+++ b/src/VBox/Main/include/win/resource.h
@@ -0,0 +1,43 @@
+/* $Id: resource.h $ */
+/** @file
+ *
+ * Resource definitions
+ */
+
+/*
+ * 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
+ */
+
+#ifndef MAIN_INCLUDED_win_resource_h
+#define MAIN_INCLUDED_win_resource_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+
+// registry script resource ID
+#define IDR_VIRTUALBOX 101
+
+// service name string resource ID
+#define IDS_SERVICENAME 102
+
+
+#endif /* !MAIN_INCLUDED_win_resource_h */