horok/virtualbox
1
0
Fork 0
Code Activity
virtualbox/include/VBox/settings.h
Daniel Baumann df1bda4fe9
Adding upstream version 7.0.20-dfsg. 
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
2025-06-22 09:56:04 +02:00

1539 lines
52 KiB
C++
Raw Permalink Blame History

/** @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 &timestamp,
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 */
View git blame Copy permalink