diff options
Diffstat (limited to 'include/VBox/settings.h')
| -rw-r--r-- | include/VBox/settings.h | 1539 |
1 files changed, 1539 insertions, 0 deletions
diff --git a/include/VBox/settings.h b/include/VBox/settings.h new file mode 100644 index 00000000..674e169f --- /dev/null +++ b/include/VBox/settings.h @@ -0,0 +1,1539 @@ +/** @file + * Settings file data structures. + * + * These structures are created by the settings file loader and filled with values + * copied from the raw XML data. This was all new with VirtualBox 3.1 and allows us + * to finally make the XML reader version-independent and read VirtualBox XML files + * from earlier and even newer (future) versions without requiring complicated, + * tedious and error-prone XSLT conversions. + * + * It is this file that defines all structures that map VirtualBox global and + * machine settings to XML files. These structures are used by the rest of Main, + * even though this header file does not require anything else in Main. + * + * Note: Headers in Main code have been tweaked to only declare the structures + * defined here so that this header need only be included from code files that + * actually use these structures. + */ + +/* + * Copyright (C) 2007-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>. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included + * in the VirtualBox distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + * + * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0 + */ + +#ifndef VBOX_INCLUDED_settings_h +#define VBOX_INCLUDED_settings_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#include <iprt/time.h> + +#include "VBox/com/VirtualBox.h" + +#include <VBox/com/Guid.h> +#include <VBox/com/string.h> +#include <VBox/VBoxCryptoIf.h> + +#include <list> +#include <map> +#include <vector> + +/** + * Maximum depth of a medium tree, to prevent stack overflows. + * XPCOM has a relatively low stack size for its workers, and we have + * to avoid crashes due to exceeding the limit both on reading and + * writing config files. The bottleneck is in libxml2. + * Data point: a release and asan build could both handle 3800 on Debian 10. + */ +#define SETTINGS_MEDIUM_DEPTH_MAX 300 + +/** + * Maximum depth of the snapshot tree, to prevent stack overflows. + * XPCOM has a relatively low stack size for its workers, and we have + * to avoid crashes due to exceeding the limit both on reading and + * writing config files. The bottleneck is reading config files with + * deep snapshot nesting, as libxml2 needs quite some stack space. + * Data point: a release and asan build could both handle 1300 on Debian 10. + */ +#define SETTINGS_SNAPSHOT_DEPTH_MAX 250 + +namespace xml +{ + class ElementNode; +} + +namespace settings +{ + +class ConfigFileError; + +//////////////////////////////////////////////////////////////////////////////// +// +// Structures shared between Machine XML and VirtualBox.xml +// +//////////////////////////////////////////////////////////////////////////////// + +typedef std::map<com::Utf8Str, com::Utf8Str> StringsMap; +typedef std::list<com::Utf8Str> StringsList; + +/** + * USB device filter definition. This struct is used both in MainConfigFile + * (for global USB filters) and MachineConfigFile (for machine filters). + * + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct USBDeviceFilter +{ + USBDeviceFilter(); + + bool operator==(const USBDeviceFilter&u) const; + + com::Utf8Str strName; + bool fActive; + com::Utf8Str strVendorId, + strProductId, + strRevision, + strManufacturer, + strProduct, + strSerialNumber, + strPort; + USBDeviceFilterAction_T action; // only used with host USB filters + com::Utf8Str strRemote; // irrelevant for host USB objects + uint32_t ulMaskedInterfaces; // irrelevant for host USB objects +}; + +typedef std::list<USBDeviceFilter> USBDeviceFiltersList; + +struct Medium; +typedef std::list<Medium> MediaList; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct Medium +{ + Medium(); + + bool operator==(const Medium &m) const; + + com::Guid uuid; + com::Utf8Str strLocation; + com::Utf8Str strDescription; + + // the following are for hard disks only: + com::Utf8Str strFormat; + bool fAutoReset; // optional, only for diffs, default is false + StringsMap properties; + MediumType_T hdType; + + MediaList llChildren; // only used with hard disks + + static const struct Medium Empty; +}; + +/** + * A media registry. Starting with VirtualBox 3.3, this can appear in both the + * VirtualBox.xml file as well as machine XML files with settings version 1.11 + * or higher, so these lists are now in ConfigFileBase. + * + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct MediaRegistry +{ + bool operator==(const MediaRegistry &m) const; + + MediaList llHardDisks, + llDvdImages, + llFloppyImages; +}; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct NATRule +{ + NATRule(); + + bool operator==(const NATRule &r) const; + + com::Utf8Str strName; + NATProtocol_T proto; + uint16_t u16HostPort; + com::Utf8Str strHostIP; + uint16_t u16GuestPort; + com::Utf8Str strGuestIP; +}; +typedef std::map<com::Utf8Str, NATRule> NATRulesMap; + +struct NATHostLoopbackOffset +{ + NATHostLoopbackOffset(); + + bool operator==(const NATHostLoopbackOffset &o) const; + + bool operator==(const com::Utf8Str& strAddr) + { + return strLoopbackHostAddress == strAddr; + } + + bool operator==(uint32_t off) + { + return u32Offset == off; + } + + /** Note: 128/8 is only acceptable */ + com::Utf8Str strLoopbackHostAddress; + uint32_t u32Offset; +}; + +typedef std::list<NATHostLoopbackOffset> NATLoopbackOffsetList; + +typedef std::vector<uint8_t> IconBlob; + +/** + * Common base class for both MainConfigFile and MachineConfigFile + * which contains some common logic for both. + */ +class ConfigFileBase +{ +public: + bool fileExists(); + SettingsVersion_T getSettingsVersion(); + + void copyBaseFrom(const ConfigFileBase &b); + +protected: + ConfigFileBase(const com::Utf8Str *pstrFilename); + /* Note: this copy constructor doesn't create a full copy of other, cause + * the file based stuff (xml doc) could not be copied. */ + ConfigFileBase(const ConfigFileBase &other); + + ~ConfigFileBase(); + + typedef enum {Error, HardDisk, DVDImage, FloppyImage} MediaType; + + static const char *stringifyMediaType(MediaType t); + SettingsVersion_T parseVersion(const com::Utf8Str &strVersion, + const xml::ElementNode *pElm); + void parseUUID(com::Guid &guid, + const com::Utf8Str &strUUID, + const xml::ElementNode *pElm) const; + void parseTimestamp(RTTIMESPEC ×tamp, + const com::Utf8Str &str, + const xml::ElementNode *pElm) const; + void parseBase64(IconBlob &binary, + const com::Utf8Str &str, + const xml::ElementNode *pElm) const; + com::Utf8Str stringifyTimestamp(const RTTIMESPEC &tm) const; + void toBase64(com::Utf8Str &str, + const IconBlob &binary) const; + + void readExtraData(const xml::ElementNode &elmExtraData, + StringsMap &map); + void readUSBDeviceFilters(const xml::ElementNode &elmDeviceFilters, + USBDeviceFiltersList &ll); + void readMediumOne(MediaType t, const xml::ElementNode &elmMedium, Medium &med); + void readMedium(MediaType t, const xml::ElementNode &elmMedium, Medium &med); + void readMediaRegistry(const xml::ElementNode &elmMediaRegistry, MediaRegistry &mr); + void readNATForwardRulesMap(const xml::ElementNode &elmParent, NATRulesMap &mapRules); + void readNATLoopbacks(const xml::ElementNode &elmParent, NATLoopbackOffsetList &llLoopBacks); + + void setVersionAttribute(xml::ElementNode &elm); + void specialBackupIfFirstBump(); + void createStubDocument(); + + void buildExtraData(xml::ElementNode &elmParent, const StringsMap &me); + void buildUSBDeviceFilters(xml::ElementNode &elmParent, + const USBDeviceFiltersList &ll, + bool fHostMode); + void buildMedium(MediaType t, + xml::ElementNode &elmMedium, + const Medium &med); + void buildMediaRegistry(xml::ElementNode &elmParent, + const MediaRegistry &mr); + void buildNATForwardRulesMap(xml::ElementNode &elmParent, const NATRulesMap &mapRules); + void buildNATLoopbacks(xml::ElementNode &elmParent, const NATLoopbackOffsetList &natLoopbackList); + void clearDocument(); + + struct Data; + Data *m; + + friend class ConfigFileError; +}; + +//////////////////////////////////////////////////////////////////////////////// +// +// VirtualBox.xml structures +// +//////////////////////////////////////////////////////////////////////////////// + +struct USBDeviceSource +{ + com::Utf8Str strName; + com::Utf8Str strBackend; + com::Utf8Str strAddress; + StringsMap properties; +}; + +typedef std::list<USBDeviceSource> USBDeviceSourcesList; + +#ifdef VBOX_WITH_UPDATE_AGENT +struct UpdateAgent +{ + UpdateAgent(); + + bool fEnabled; + UpdateChannel_T enmChannel; + uint32_t uCheckFreqSeconds; + com::Utf8Str strRepoUrl; + com::Utf8Str strLastCheckDate; + uint32_t uCheckCount; +}; +#endif /* VBOX_WITH_UPDATE_AGENT */ + +struct Host +{ + USBDeviceFiltersList llUSBDeviceFilters; + USBDeviceSourcesList llUSBDeviceSources; +#ifdef VBOX_WITH_UPDATE_AGENT + UpdateAgent updateHost; + /** @todo Add handling for ExtPack and Guest Additions updates here later. See @bugref{7983}. */ +#endif /* VBOX_WITH_UPDATE_AGENT */ +}; + +struct SystemProperties +{ + SystemProperties(); + + com::Utf8Str strDefaultMachineFolder; + com::Utf8Str strDefaultHardDiskFolder; + com::Utf8Str strDefaultHardDiskFormat; + com::Utf8Str strVRDEAuthLibrary; + com::Utf8Str strWebServiceAuthLibrary; + com::Utf8Str strDefaultVRDEExtPack; + com::Utf8Str strDefaultCryptoExtPack; + com::Utf8Str strAutostartDatabasePath; + com::Utf8Str strDefaultAdditionsISO; + com::Utf8Str strDefaultFrontend; + com::Utf8Str strLoggingLevel; + com::Utf8Str strProxyUrl; + uint32_t uProxyMode; /**< ProxyMode_T */ + uint32_t uLogHistoryCount; + bool fExclusiveHwVirt; + com::Utf8Str strLanguageId; +}; + +struct MachineRegistryEntry +{ + com::Guid uuid; + com::Utf8Str strSettingsFile; +}; + +typedef std::list<MachineRegistryEntry> MachinesRegistry; + +struct DhcpOptValue +{ + DhcpOptValue(); + DhcpOptValue(const com::Utf8Str &aText, DHCPOptionEncoding_T aEncoding = DHCPOptionEncoding_Normal); + + com::Utf8Str strValue; + DHCPOptionEncoding_T enmEncoding; +}; + +typedef std::map<DHCPOption_T, DhcpOptValue> DhcpOptionMap; +typedef DhcpOptionMap::value_type DhcpOptValuePair; +typedef DhcpOptionMap::iterator DhcpOptIterator; +typedef DhcpOptionMap::const_iterator DhcpOptConstIterator; + +struct DHCPGroupCondition +{ + DHCPGroupCondition(); + + bool fInclusive; + DHCPGroupConditionType_T enmType; + com::Utf8Str strValue; +}; +typedef std::vector<DHCPGroupCondition> DHCPGroupConditionVec; + + +struct DHCPConfig +{ + DHCPConfig(); + + DhcpOptionMap mapOptions; + uint32_t secMinLeaseTime; + uint32_t secDefaultLeaseTime; + uint32_t secMaxLeaseTime; + com::Utf8Str strForcedOptions; + com::Utf8Str strSuppressedOptions; +}; + +struct DHCPGroupConfig : DHCPConfig +{ + DHCPGroupConfig(); + + com::Utf8Str strName; + DHCPGroupConditionVec vecConditions; +}; +typedef std::vector<DHCPGroupConfig> DHCPGroupConfigVec; + +struct DHCPIndividualConfig : DHCPConfig +{ + DHCPIndividualConfig(); + + com::Utf8Str strMACAddress; + com::Utf8Str strVMName; + uint32_t uSlot; + com::Utf8Str strFixedAddress; +}; +typedef std::map<com::Utf8Str, DHCPIndividualConfig> DHCPIndividualConfigMap; + +struct DHCPServer +{ + DHCPServer(); + + com::Utf8Str strNetworkName; + com::Utf8Str strIPAddress; + com::Utf8Str strIPLower; + com::Utf8Str strIPUpper; + bool fEnabled; + DHCPConfig globalConfig; + DHCPGroupConfigVec vecGroupConfigs; + DHCPIndividualConfigMap mapIndividualConfigs; +}; +typedef std::list<DHCPServer> DHCPServersList; + + +/** + * NAT Networking settings (NAT service). + */ +struct NATNetwork +{ + NATNetwork(); + + com::Utf8Str strNetworkName; + com::Utf8Str strIPv4NetworkCidr; + com::Utf8Str strIPv6Prefix; + bool fEnabled; + bool fIPv6Enabled; + bool fAdvertiseDefaultIPv6Route; + bool fNeedDhcpServer; + uint32_t u32HostLoopback6Offset; + NATLoopbackOffsetList llHostLoopbackOffsetList; + NATRulesMap mapPortForwardRules4; + NATRulesMap mapPortForwardRules6; +}; + +typedef std::list<NATNetwork> NATNetworksList; + +#ifdef VBOX_WITH_VMNET +/** + * HostOnly Networking settings. + */ +struct HostOnlyNetwork +{ + HostOnlyNetwork(); + + com::Guid uuid; + com::Utf8Str strNetworkName; + com::Utf8Str strNetworkMask; + com::Utf8Str strIPLower; + com::Utf8Str strIPUpper; + bool fEnabled; +}; + +typedef std::list<HostOnlyNetwork> HostOnlyNetworksList; +#endif /* VBOX_WITH_VMNET */ + +#ifdef VBOX_WITH_CLOUD_NET +/** + * Cloud Networking settings. + */ +struct CloudNetwork +{ + CloudNetwork(); + + com::Utf8Str strNetworkName; + com::Utf8Str strProviderShortName; + com::Utf8Str strProfileName; + com::Utf8Str strNetworkId; + bool fEnabled; +}; + +typedef std::list<CloudNetwork> CloudNetworksList; +#endif /* VBOX_WITH_CLOUD_NET */ + + +class MainConfigFile : public ConfigFileBase +{ +public: + MainConfigFile(const com::Utf8Str *pstrFilename); + + void readMachineRegistry(const xml::ElementNode &elmMachineRegistry); + void readNATNetworks(const xml::ElementNode &elmNATNetworks); +#ifdef VBOX_WITH_VMNET + void readHostOnlyNetworks(const xml::ElementNode &elmHostOnlyNetworks); +#endif /* VBOX_WITH_VMNET */ +#ifdef VBOX_WITH_CLOUD_NET + void readCloudNetworks(const xml::ElementNode &elmCloudNetworks); +#endif /* VBOX_WITH_CLOUD_NET */ + + void write(const com::Utf8Str strFilename); + + Host host; + SystemProperties systemProperties; + MediaRegistry mediaRegistry; + MachinesRegistry llMachines; + DHCPServersList llDhcpServers; + NATNetworksList llNATNetworks; +#ifdef VBOX_WITH_VMNET + HostOnlyNetworksList llHostOnlyNetworks; +#endif /* VBOX_WITH_VMNET */ +#ifdef VBOX_WITH_CLOUD_NET + CloudNetworksList llCloudNetworks; +#endif /* VBOX_WITH_CLOUD_NET */ + StringsMap mapExtraDataItems; + +private: + void bumpSettingsVersionIfNeeded(); + void buildUSBDeviceSources(xml::ElementNode &elmParent, const USBDeviceSourcesList &ll); + void readUSBDeviceSources(const xml::ElementNode &elmDeviceSources, USBDeviceSourcesList &ll); + void buildDHCPServers(xml::ElementNode &elmDHCPServers, DHCPServersList const &ll); + void buildDHCPOptions(xml::ElementNode &elmOptions, DHCPConfig const &rConfig, bool fIgnoreSubnetMask); + void readDHCPServers(const xml::ElementNode &elmDHCPServers); + void readDHCPOptions(DHCPConfig &rConfig, const xml::ElementNode &elmOptions, bool fIgnoreSubnetMask); + bool convertGuiProxySettings(const com::Utf8Str &strUIProxySettings); +}; + +//////////////////////////////////////////////////////////////////////////////// +// +// Machine XML structures +// +//////////////////////////////////////////////////////////////////////////////// + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct VRDESettings +{ + VRDESettings(); + + bool areDefaultSettings(SettingsVersion_T sv) const; + + bool operator==(const VRDESettings& v) const; + + bool fEnabled; + AuthType_T authType; + uint32_t ulAuthTimeout; + com::Utf8Str strAuthLibrary; + bool fAllowMultiConnection, + fReuseSingleConnection; + com::Utf8Str strVrdeExtPack; + StringsMap mapProperties; +}; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct BIOSSettings +{ + BIOSSettings(); + + bool areDefaultSettings() const; + + bool operator==(const BIOSSettings &d) const; + + bool fACPIEnabled, + fIOAPICEnabled, + fLogoFadeIn, + fLogoFadeOut, + fPXEDebugEnabled, + fSmbiosUuidLittleEndian; + uint32_t ulLogoDisplayTime; + BIOSBootMenuMode_T biosBootMenuMode; + APICMode_T apicMode; // requires settings version 1.16 (VirtualBox 5.1) + int64_t llTimeOffset; + com::Utf8Str strLogoImagePath; +}; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct TpmSettings +{ + TpmSettings(); + + bool areDefaultSettings() const; + + bool operator==(const TpmSettings &d) const; + + TpmType_T tpmType; + com::Utf8Str strLocation; +}; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct NvramSettings +{ + NvramSettings(); + + bool areDefaultSettings() const; + + bool operator==(const NvramSettings &d) const; + + com::Utf8Str strNvramPath; + com::Utf8Str strKeyId; + com::Utf8Str strKeyStore; +}; + +/** List for keeping a recording feature list. */ +typedef std::map<RecordingFeature_T, bool> RecordingFeatureMap; + +/** + * Recording settings for a single screen (e.g. virtual monitor). + * + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct RecordingScreenSettings +{ + RecordingScreenSettings(uint32_t idScreen = UINT32_MAX); + + virtual ~RecordingScreenSettings(); + + void applyDefaults(void); + + bool areDefaultSettings(void) const; + + bool isFeatureEnabled(RecordingFeature_T enmFeature) const; + + static const char *getDefaultOptions(void); + + static int featuresFromString(const com::Utf8Str &strFeatures, RecordingFeatureMap &featureMap); + + static void featuresToString(const RecordingFeatureMap &featureMap, com::Utf8Str &strFeatures); + + static int audioCodecFromString(const com::Utf8Str &strCodec, RecordingAudioCodec_T &enmCodec); + + static void audioCodecToString(const RecordingAudioCodec_T &enmCodec, com::Utf8Str &strCodec); + + static int videoCodecFromString(const com::Utf8Str &strCodec, RecordingVideoCodec_T &enmCodec); + + static void videoCodecToString(const RecordingVideoCodec_T &enmCodec, com::Utf8Str &strCodec); + + bool operator==(const RecordingScreenSettings &d) const; + + /** Screen ID. + * UINT32_MAX if not set. */ + uint32_t idScreen; + /** Whether to record this screen or not. */ + bool fEnabled; // requires settings version 1.14 (VirtualBox 4.3) + /** Destination to record to. */ + RecordingDestination_T enmDest; + /** Which features are enable or not. */ + RecordingFeatureMap featureMap; // requires settings version 1.19 (VirtualBox 7.0) + /** Maximum time (in s) to record. If set to 0, no time limit is set. */ + uint32_t ulMaxTimeS; // requires settings version 1.14 (VirtualBox 4.3) + /** Options string for hidden / advanced / experimental features. + * Use RecordingScreenSettings::getDefaultOptions(). */ + com::Utf8Str strOptions; // new since VirtualBox 5.2. + + /** + * Structure holding settings for audio recording. + */ + struct Audio + { + /** The audio codec type to use. */ + RecordingAudioCodec_T enmCodec; // requires settings version 1.19 (VirtualBox 7.0) + /** Codec deadline to use. */ + RecordingCodecDeadline_T enmDeadline; // requires settings version 1.19 (VirtualBox 7.0) + /** Rate control mode to use. */ + RecordingRateControlMode_T + enmRateCtlMode;// requires settings version 1.19 (VirtualBox 7.0) + /** Hz rate. */ + uint16_t uHz; // requires settings version 1.19 (VirtualBox 7.0) + /** Bits per sample. */ + uint8_t cBits; // requires settings version 1.19 (VirtualBox 7.0) + /** Number of audio channels. */ + uint8_t cChannels; // requires settings version 1.19 (VirtualBox 7.0) + } Audio; + + /** + * Structure holding settings for video recording. + */ + struct Video + { + /** The codec to use. */ + RecordingVideoCodec_T enmCodec; // requires settings version 1.19 (VirtualBox 7.0) + /** Codec deadline to use. */ + RecordingCodecDeadline_T enmDeadline; // requires settings version 1.19 (VirtualBox 7.0) + /** Rate control mode to use. */ + RecordingRateControlMode_T + enmRateCtlMode; // requires settings version 1.19 (VirtualBox 7.0) + /** Rate control mode to use. */ + RecordingVideoScalingMode_T + enmScalingMode; // requires settings version 1.19 (VirtualBox 7.0) + /** Target frame width in pixels (X). */ + uint32_t ulWidth; // requires settings version 1.14 (VirtualBox 4.3) + /** Target frame height in pixels (Y). */ + uint32_t ulHeight; // requires settings version 1.14 (VirtualBox 4.3) + /** Encoding rate. */ + uint32_t ulRate; // requires settings version 1.14 (VirtualBox 4.3) + /** Frames per second (FPS). */ + uint32_t ulFPS; // requires settings version 1.14 (VirtualBox 4.3) + } Video; + + /** + * Structure holding settings if the destination is a file. + */ + struct File + { + /** Maximum size (in MB) the file is allowed to have. + * When reaching the limit, recording will stop. 0 means no limit. */ + uint32_t ulMaxSizeMB; // requires settings version 1.14 (VirtualBox 4.3) + /** Absolute file name path to use for recording. + * When empty, this is considered as being the default setting. */ + com::Utf8Str strName; // requires settings version 1.14 (VirtualBox 4.3) + } File; +}; + +/** Map for keeping settings per virtual screen. + * The key specifies the screen ID. */ +typedef std::map<uint32_t, RecordingScreenSettings> RecordingScreenSettingsMap; + +/** + * Common recording settings, shared among all per-screen recording settings. + * + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct RecordingCommonSettings +{ + RecordingCommonSettings(); + + void applyDefaults(void); + + bool areDefaultSettings(void) const; + + bool operator==(const RecordingCommonSettings &d) const; + + /** Whether recording as a whole is enabled or disabled. */ + bool fEnabled; // requires settings version 1.14 (VirtualBox 4.3) +}; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct RecordingSettings +{ + RecordingSettings(); + + void applyDefaults(void); + + bool areDefaultSettings(void) const; + + bool operator==(const RecordingSettings &that) const; + + /** Common settings for all per-screen recording settings. */ + RecordingCommonSettings common; + /** Map of handled recording screen settings. + * The key specifies the screen ID. */ + RecordingScreenSettingsMap mapScreens; +}; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct GraphicsAdapter +{ + GraphicsAdapter(); + + bool areDefaultSettings() const; + + bool operator==(const GraphicsAdapter &g) const; + + GraphicsControllerType_T graphicsControllerType; + uint32_t ulVRAMSizeMB; + uint32_t cMonitors; + bool fAccelerate3D, + fAccelerate2DVideo; // requires settings version 1.8 (VirtualBox 3.1) +}; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct USBController +{ + USBController(); + + bool operator==(const USBController &u) const; + + com::Utf8Str strName; + USBControllerType_T enmType; +}; + +typedef std::list<USBController> USBControllerList; + +struct USB +{ + USB(); + + bool operator==(const USB &u) const; + + /** List of USB controllers present. */ + USBControllerList llUSBControllers; + /** List of USB device filters. */ + USBDeviceFiltersList llDeviceFilters; +}; + +struct NAT +{ + NAT(); + + bool areDNSDefaultSettings() const; + bool areAliasDefaultSettings() const; + bool areTFTPDefaultSettings() const; + bool areLocalhostReachableDefaultSettings(SettingsVersion_T sv) const; + bool areDefaultSettings(SettingsVersion_T sv) const; + + bool operator==(const NAT &n) const; + + com::Utf8Str strNetwork; + com::Utf8Str strBindIP; + uint32_t u32Mtu; + uint32_t u32SockRcv; + uint32_t u32SockSnd; + uint32_t u32TcpRcv; + uint32_t u32TcpSnd; + com::Utf8Str strTFTPPrefix; + com::Utf8Str strTFTPBootFile; + com::Utf8Str strTFTPNextServer; + bool fDNSPassDomain; + bool fDNSProxy; + bool fDNSUseHostResolver; + bool fAliasLog; + bool fAliasProxyOnly; + bool fAliasUseSamePorts; + bool fLocalhostReachable; + NATRulesMap mapRules; +}; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct NetworkAdapter +{ + NetworkAdapter(); + + bool areGenericDriverDefaultSettings() const; + bool areDefaultSettings(SettingsVersion_T sv) const; + bool areDisabledDefaultSettings(SettingsVersion_T sv) const; + + bool operator==(const NetworkAdapter &n) const; + + uint32_t ulSlot; + + NetworkAdapterType_T type; + bool fEnabled; + com::Utf8Str strMACAddress; + bool fCableConnected; + uint32_t ulLineSpeed; + NetworkAdapterPromiscModePolicy_T enmPromiscModePolicy; + bool fTraceEnabled; + com::Utf8Str strTraceFile; + + NetworkAttachmentType_T mode; + NAT nat; + com::Utf8Str strBridgedName; + com::Utf8Str strHostOnlyName; +#ifdef VBOX_WITH_VMNET + com::Utf8Str strHostOnlyNetworkName; +#endif /* VBOX_WITH_VMNET */ + com::Utf8Str strInternalNetworkName; + com::Utf8Str strGenericDriver; + StringsMap genericProperties; + com::Utf8Str strNATNetworkName; +#ifdef VBOX_WITH_CLOUD_NET + com::Utf8Str strCloudNetworkName; +#endif /* VBOX_WITH_CLOUD_NET */ + uint32_t ulBootPriority; + com::Utf8Str strBandwidthGroup; // requires settings version 1.13 (VirtualBox 4.2) +}; + +typedef std::list<NetworkAdapter> NetworkAdaptersList; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct SerialPort +{ + SerialPort(); + + bool operator==(const SerialPort &n) const; + + uint32_t ulSlot; + + bool fEnabled; + uint32_t ulIOBase; + uint32_t ulIRQ; + PortMode_T portMode; + com::Utf8Str strPath; + bool fServer; + UartType_T uartType; +}; + +typedef std::list<SerialPort> SerialPortsList; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct ParallelPort +{ + ParallelPort(); + + bool operator==(const ParallelPort &d) const; + + uint32_t ulSlot; + + bool fEnabled; + uint32_t ulIOBase; + uint32_t ulIRQ; + com::Utf8Str strPath; +}; + +typedef std::list<ParallelPort> ParallelPortsList; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct AudioAdapter +{ + AudioAdapter(); + + bool areDefaultSettings(SettingsVersion_T sv) const; + + bool operator==(const AudioAdapter &a) const; + + bool fEnabled; + bool fEnabledIn; + bool fEnabledOut; + AudioControllerType_T controllerType; + AudioCodecType_T codecType; + AudioDriverType_T driverType; + settings::StringsMap properties; +}; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct SharedFolder +{ + SharedFolder(); + + bool operator==(const SharedFolder &a) const; + + com::Utf8Str strName, + strHostPath; + bool fWritable; + bool fAutoMount; + com::Utf8Str strAutoMountPoint; +}; + +typedef std::list<SharedFolder> SharedFoldersList; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct GuestProperty +{ + GuestProperty(); + + bool operator==(const GuestProperty &g) const; + + com::Utf8Str strName, + strValue; + uint64_t timestamp; + com::Utf8Str strFlags; +}; + +typedef std::list<GuestProperty> GuestPropertiesList; + +typedef std::map<uint32_t, DeviceType_T> BootOrderMap; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct CpuIdLeaf +{ + CpuIdLeaf(); + + bool operator==(const CpuIdLeaf &c) const; + + uint32_t idx; + uint32_t idxSub; + uint32_t uEax; + uint32_t uEbx; + uint32_t uEcx; + uint32_t uEdx; +}; + +typedef std::list<CpuIdLeaf> CpuIdLeafsList; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct Cpu +{ + Cpu(); + + bool operator==(const Cpu &c) const; + + uint32_t ulId; +}; + +typedef std::list<Cpu> CpuList; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct BandwidthGroup +{ + BandwidthGroup(); + + bool operator==(const BandwidthGroup &i) const; + + com::Utf8Str strName; + uint64_t cMaxBytesPerSec; + BandwidthGroupType_T enmType; +}; + +typedef std::list<BandwidthGroup> BandwidthGroupList; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct IOSettings +{ + IOSettings(); + + bool areIOCacheDefaultSettings() const; + bool areDefaultSettings() const; + + bool operator==(const IOSettings &i) const; + + bool fIOCacheEnabled; + uint32_t ulIOCacheSize; + BandwidthGroupList llBandwidthGroups; +}; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct HostPCIDeviceAttachment +{ + HostPCIDeviceAttachment(); + + bool operator==(const HostPCIDeviceAttachment &a) const; + + com::Utf8Str strDeviceName; + uint32_t uHostAddress; + uint32_t uGuestAddress; +}; + +typedef std::list<HostPCIDeviceAttachment> HostPCIDeviceAttachmentList; + +/** + * A device attached to a storage controller. This can either be a + * hard disk or a DVD drive or a floppy drive and also specifies + * which medium is "in" the drive; as a result, this is a combination + * of the Main IMedium and IMediumAttachment interfaces. + * + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct AttachedDevice +{ + AttachedDevice(); + + bool operator==(const AttachedDevice &a) const; + + DeviceType_T deviceType; // only HardDisk, DVD or Floppy are allowed + + // DVDs can be in pass-through mode: + bool fPassThrough; + + // Whether guest-triggered eject of DVDs will keep the medium in the + // VM config or not: + bool fTempEject; + + // Whether the medium is non-rotational: + bool fNonRotational; + + // Whether the medium supports discarding unused blocks: + bool fDiscard; + + // Whether the medium is hot-pluggable: + bool fHotPluggable; + + int32_t lPort; + int32_t lDevice; + + // if an image file is attached to the device (ISO, RAW, or hard disk image such as VDI), + // this is its UUID; it depends on deviceType which media registry this then needs to + // be looked up in. If no image file (only permitted for DVDs and floppies), then the UUID is NULL + com::Guid uuid; + + // for DVDs and floppies, the attachment can also be a host device: + com::Utf8Str strHostDriveSrc; // if != NULL, value of <HostDrive>/@src + + // Bandwidth group the device is attached to. + com::Utf8Str strBwGroup; +}; + +typedef std::list<AttachedDevice> AttachedDevicesList; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct StorageController +{ + StorageController(); + + bool operator==(const StorageController &s) const; + + com::Utf8Str strName; + StorageBus_T storageBus; // _SATA, _SCSI, _IDE, _SAS + StorageControllerType_T controllerType; + uint32_t ulPortCount; + uint32_t ulInstance; + bool fUseHostIOCache; + bool fBootable; + + // only for when controllerType == StorageControllerType_IntelAhci: + int32_t lIDE0MasterEmulationPort, + lIDE0SlaveEmulationPort, + lIDE1MasterEmulationPort, + lIDE1SlaveEmulationPort; + + AttachedDevicesList llAttachedDevices; +}; + +typedef std::list<StorageController> StorageControllersList; + +/** + * We wrap the storage controllers list into an extra struct so we can + * use an undefined struct without needing std::list<> in all the headers. + * + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct Storage +{ + bool operator==(const Storage &s) const; + + StorageControllersList llStorageControllers; +}; + +/** + * Representation of Machine hardware; this is used in the MachineConfigFile.hardwareMachine + * field. + * + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct Hardware +{ + Hardware(); + + bool areParavirtDefaultSettings(SettingsVersion_T sv) const; + bool areBootOrderDefaultSettings() const; + bool areDisplayDefaultSettings() const; + bool areAllNetworkAdaptersDefaultSettings(SettingsVersion_T sv) const; + + bool operator==(const Hardware&) const; + + com::Utf8Str strVersion; // hardware version, optional + com::Guid uuid; // hardware uuid, optional (null). + + bool fHardwareVirt, + fNestedPaging, + fLargePages, + fVPID, + fUnrestrictedExecution, + fHardwareVirtForce, + fUseNativeApi, + fSyntheticCpu, + fTripleFaultReset, + fPAE, + fAPIC, // requires settings version 1.16 (VirtualBox 5.1) + fX2APIC; // requires settings version 1.16 (VirtualBox 5.1) + bool fIBPBOnVMExit; //< added out of cycle, after 1.16 was out. + bool fIBPBOnVMEntry; //< added out of cycle, after 1.16 was out. + bool fSpecCtrl; //< added out of cycle, after 1.16 was out. + bool fSpecCtrlByHost; //< added out of cycle, after 1.16 was out. + bool fL1DFlushOnSched ; //< added out of cycle, after 1.16 was out. + bool fL1DFlushOnVMEntry ; //< added out of cycle, after 1.16 was out. + bool fMDSClearOnSched; //< added out of cycle, after 1.16 was out. + bool fMDSClearOnVMEntry; //< added out of cycle, after 1.16 was out. + bool fNestedHWVirt; //< requires settings version 1.17 (VirtualBox 6.0) + bool fVirtVmsaveVmload; //< requires settings version 1.18 (VirtualBox 6.1) + typedef enum LongModeType { LongMode_Enabled, LongMode_Disabled, LongMode_Legacy } LongModeType; + LongModeType enmLongMode; + uint32_t cCPUs; + bool fCpuHotPlug; // requires settings version 1.10 (VirtualBox 3.2) + CpuList llCpus; // requires settings version 1.10 (VirtualBox 3.2) + bool fHPETEnabled; // requires settings version 1.10 (VirtualBox 3.2) + uint32_t ulCpuExecutionCap; // requires settings version 1.11 (VirtualBox 3.3) + uint32_t uCpuIdPortabilityLevel; // requires settings version 1.15 (VirtualBox 5.0) + com::Utf8Str strCpuProfile; // requires settings version 1.16 (VirtualBox 5.1) + + CpuIdLeafsList llCpuIdLeafs; + + uint32_t ulMemorySizeMB; + + BootOrderMap mapBootOrder; // item 0 has highest priority + + FirmwareType_T firmwareType; // requires settings version 1.9 (VirtualBox 3.1) + + PointingHIDType_T pointingHIDType; // requires settings version 1.10 (VirtualBox 3.2) + KeyboardHIDType_T keyboardHIDType; // requires settings version 1.10 (VirtualBox 3.2) + + ChipsetType_T chipsetType; // requires settings version 1.11 (VirtualBox 4.0) + IommuType_T iommuType; // requires settings version 1.19 (VirtualBox 6.2) + ParavirtProvider_T paravirtProvider; // requires settings version 1.15 (VirtualBox 4.4) + com::Utf8Str strParavirtDebug; // requires settings version 1.16 (VirtualBox 5.1) + + bool fEmulatedUSBCardReader; // 1.12 (VirtualBox 4.1) + + VRDESettings vrdeSettings; + + BIOSSettings biosSettings; + NvramSettings nvramSettings; + GraphicsAdapter graphicsAdapter; + USB usbSettings; + TpmSettings tpmSettings; // requires settings version 1.19 (VirtualBox 6.2) + NetworkAdaptersList llNetworkAdapters; + SerialPortsList llSerialPorts; + ParallelPortsList llParallelPorts; + AudioAdapter audioAdapter; + Storage storage; + + // technically these two have no business in the hardware section, but for some + // clever reason <Hardware> is where they are in the XML.... + SharedFoldersList llSharedFolders; + + ClipboardMode_T clipboardMode; + bool fClipboardFileTransfersEnabled; + + DnDMode_T dndMode; + + uint32_t ulMemoryBalloonSize; + bool fPageFusionEnabled; + + GuestPropertiesList llGuestProperties; + + IOSettings ioSettings; // requires settings version 1.10 (VirtualBox 3.2) + HostPCIDeviceAttachmentList pciAttachments; // requires settings version 1.12 (VirtualBox 4.1) + + com::Utf8Str strDefaultFrontend; // requires settings version 1.14 (VirtualBox 4.3) +}; + +/** + * Settings that has to do with debugging. + */ +struct Debugging +{ + Debugging(); + + bool areDefaultSettings() const; + + bool operator==(const Debugging &rOther) const; + + bool fTracingEnabled; + bool fAllowTracingToAccessVM; + com::Utf8Str strTracingConfig; + GuestDebugProvider_T enmDbgProvider; + GuestDebugIoProvider_T enmIoProvider; + com::Utf8Str strAddress; + uint32_t ulPort; +}; + +/** + * Settings that has to do with autostart. + */ +struct Autostart +{ + Autostart(); + + bool areDefaultSettings() const; + + bool operator==(const Autostart &rOther) const; + + bool fAutostartEnabled; + uint32_t uAutostartDelay; + AutostopType_T enmAutostopType; +}; + +struct Snapshot; +typedef std::list<Snapshot> SnapshotsList; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct Snapshot +{ + Snapshot(); + + bool operator==(const Snapshot &s) const; + + com::Guid uuid; + com::Utf8Str strName, + strDescription; // optional + RTTIMESPEC timestamp; + + com::Utf8Str strStateFile; // for online snapshots only + + Hardware hardware; + + Debugging debugging; + Autostart autostart; + RecordingSettings recordingSettings; + + SnapshotsList llChildSnapshots; + + static const struct Snapshot Empty; +}; + +/** + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by MachineConfigFile::operator==(), or otherwise + * your settings might never get saved. + */ +struct MachineUserData +{ + MachineUserData(); + + bool operator==(const MachineUserData &c) const; + + com::Utf8Str strName; + bool fDirectoryIncludesUUID; + bool fNameSync; + com::Utf8Str strDescription; + StringsList llGroups; + com::Utf8Str strOsType; + com::Utf8Str strSnapshotFolder; + bool fTeleporterEnabled; + uint32_t uTeleporterPort; + com::Utf8Str strTeleporterAddress; + com::Utf8Str strTeleporterPassword; + bool fRTCUseUTC; + IconBlob ovIcon; + VMProcPriority_T enmVMPriority; +}; + + +/** + * MachineConfigFile represents an XML machine configuration. All the machine settings + * that go out to the XML (or are read from it) are in here. + * + * NOTE: If you add any fields in here, you must update a) the constructor and b) + * the operator== which is used by Machine::saveSettings(), or otherwise your settings + * might never get saved. + */ +class MachineConfigFile : public ConfigFileBase +{ +public: + com::Guid uuid; + + enum + { + ParseState_NotParsed, + ParseState_PasswordError, + ParseState_Parsed + } enmParseState; + + MachineUserData machineUserData; + + com::Utf8Str strStateKeyId; + com::Utf8Str strStateKeyStore; + com::Utf8Str strStateFile; + bool fCurrentStateModified; // optional, default is true + RTTIMESPEC timeLastStateChange; // optional, defaults to now + bool fAborted; // optional, default is false + + com::Guid uuidCurrentSnapshot; + + Hardware hardwareMachine; + MediaRegistry mediaRegistry; + Debugging debugging; + Autostart autostart; + RecordingSettings recordingSettings; + + StringsMap mapExtraDataItems; + + SnapshotsList llFirstSnapshot; // first snapshot or empty list if there's none + + com::Utf8Str strKeyId; + com::Utf8Str strKeyStore; // if not empty, the encryption is used + com::Utf8Str strLogKeyId; + com::Utf8Str strLogKeyStore; + + MachineConfigFile(const com::Utf8Str *pstrFilename, + PCVBOXCRYPTOIF pCryptoIf = NULL, + const char *pszPassword = NULL); + + bool operator==(const MachineConfigFile &m) const; + + bool canHaveOwnMediaRegistry() const; + + void importMachineXML(const xml::ElementNode &elmMachine); + + void write(const com::Utf8Str &strFilename, PCVBOXCRYPTOIF pCryptoIf = NULL, const char *pszPassword = NULL); + + enum + { + BuildMachineXML_IncludeSnapshots = 0x01, + BuildMachineXML_WriteVBoxVersionAttribute = 0x02, + BuildMachineXML_SkipRemovableMedia = 0x04, + BuildMachineXML_MediaRegistry = 0x08, + BuildMachineXML_SuppressSavedState = 0x10 + }; + + void copyEncryptionSettingsFrom(const MachineConfigFile &other); + void buildMachineXML(xml::ElementNode &elmMachine, + uint32_t fl, + std::list<xml::ElementNode*> *pllElementsWithUuidAttributes); + + static bool isAudioDriverAllowedOnThisHost(AudioDriverType_T enmDrvType); + static AudioDriverType_T getHostDefaultAudioDriver(); + +private: + void readNetworkAdapters(const xml::ElementNode &elmHardware, NetworkAdaptersList &ll); + void readAttachedNetworkMode(const xml::ElementNode &pelmMode, bool fEnabled, NetworkAdapter &nic); + void readCpuIdTree(const xml::ElementNode &elmCpuid, CpuIdLeafsList &ll); + void readCpuTree(const xml::ElementNode &elmCpu, CpuList &ll); + void readSerialPorts(const xml::ElementNode &elmUART, SerialPortsList &ll); + void readParallelPorts(const xml::ElementNode &elmLPT, ParallelPortsList &ll); + void readAudioAdapter(const xml::ElementNode &elmAudioAdapter, AudioAdapter &aa); + void readGuestProperties(const xml::ElementNode &elmGuestProperties, Hardware &hw); + void readStorageControllerAttributes(const xml::ElementNode &elmStorageController, StorageController &sctl); + void readHardware(const xml::ElementNode &elmHardware, Hardware &hw); + void readHardDiskAttachments_pre1_7(const xml::ElementNode &elmHardDiskAttachments, Storage &strg); + void readStorageControllers(const xml::ElementNode &elmStorageControllers, Storage &strg); + void readDVDAndFloppies_pre1_9(const xml::ElementNode &elmHardware, Storage &strg); + void readTeleporter(const xml::ElementNode &elmTeleporter, MachineUserData &userData); + void readDebugging(const xml::ElementNode &elmDbg, Debugging &dbg); + void readAutostart(const xml::ElementNode &elmAutostart, Autostart &autostrt); + void readRecordingSettings(const xml::ElementNode &elmRecording, uint32_t cMonitors, RecordingSettings &recording); + void readGroups(const xml::ElementNode &elmGroups, StringsList &llGroups); + bool readSnapshot(const com::Guid &curSnapshotUuid, const xml::ElementNode &elmSnapshot, Snapshot &snap); + void convertOldOSType_pre1_5(com::Utf8Str &str); + void readMachine(const xml::ElementNode &elmMachine); + void readMachineEncrypted(const xml::ElementNode &elmMachine, PCVBOXCRYPTOIF pCryptoIf, const char *pszPassword); + + void buildHardwareXML(xml::ElementNode &elmParent, const Hardware &hw, uint32_t fl, std::list<xml::ElementNode*> *pllElementsWithUuidAttributes); + void buildNetworkXML(NetworkAttachmentType_T mode, bool fEnabled, xml::ElementNode &elmParent, const NetworkAdapter &nic); + void buildStorageControllersXML(xml::ElementNode &elmParent, + const Storage &st, + bool fSkipRemovableMedia, + std::list<xml::ElementNode*> *pllElementsWithUuidAttributes); + void buildDebuggingXML(xml::ElementNode &elmParent, const Debugging &dbg); + void buildAutostartXML(xml::ElementNode &elmParent, const Autostart &autostrt); + void buildRecordingXML(xml::ElementNode &elmParent, const RecordingSettings &recording); + void buildGroupsXML(xml::ElementNode &elmParent, const StringsList &llGroups); + void buildSnapshotXML(xml::ElementNode &elmParent, const Snapshot &snap); + + void buildMachineEncryptedXML(xml::ElementNode &elmMachine, + uint32_t fl, + std::list<xml::ElementNode*> *pllElementsWithUuidAttributes, + PCVBOXCRYPTOIF pCryptoIf, + const char *pszPassword); + + void bumpSettingsVersionIfNeeded(); +}; + +} // namespace settings + + +#endif /* !VBOX_INCLUDED_settings_h */ |