d10b594ea1bfbfb3dbd7132080ab860abe618cb4vboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync#ifndef ___VBox_settings_h

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync#define ___VBox_settings_h

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync#include <iprt/time.h>

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync#include "VBox/com/VirtualBox.h"

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync#include <VBox/com/Guid.h>

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync#include <VBox/com/string.h>

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

b67986b52286959154244a144c62c9f40091fbbbvboxsync#include <list>

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync#include <map>

b67986b52286959154244a144c62c9f40091fbbbvboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsyncnamespace xml

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync{

b67986b52286959154244a144c62c9f40091fbbbvboxsync class ElementNode;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync}

b67986b52286959154244a144c62c9f40091fbbbvboxsync

b67986b52286959154244a144c62c9f40091fbbbvboxsyncnamespace settings

b67986b52286959154244a144c62c9f40091fbbbvboxsync{

b67986b52286959154244a144c62c9f40091fbbbvboxsync

b67986b52286959154244a144c62c9f40091fbbbvboxsyncclass ConfigFileError;

b67986b52286959154244a144c62c9f40091fbbbvboxsync

3b6727bcf40d710e50ad98533cc3f05adaae0226vboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsyncstruct USBDeviceFilter

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync{

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync USBDeviceFilter()

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync : fActive(false),

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync action(USBDeviceFilterAction_Null),

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync ulMaskedInterfaces(0)

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync {}

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync bool operator==(const USBDeviceFilter&u) const;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync com::Utf8Str strName;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync bool fActive;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync com::Utf8Str strVendorId,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync strProductId,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync strRevision,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync strManufacturer,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync strProduct,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync strSerialNumber,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync strPort;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync USBDeviceFilterAction_T action; // only used with host USB filters

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync com::Utf8Str strRemote; // irrelevant for host USB objects

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync uint32_t ulMaskedInterfaces; // irrelevant for host USB objects

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync};

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsynctypedef std::map<com::Utf8Str, com::Utf8Str> StringsMap;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsyncstruct USBDeviceFilter;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsynctypedef std::list<USBDeviceFilter> USBDeviceFiltersList;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsyncstruct Medium;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsynctypedef std::list<Medium> MediaList;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsyncstruct Medium

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync{

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync com::Guid uuid;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync com::Utf8Str strLocation;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync com::Utf8Str strDescription;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync // the following are for hard disks only:

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync com::Utf8Str strFormat;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync bool fAutoReset; // optional, only for diffs, default is false

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync StringsMap properties;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync MediumType_T hdType;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync MediaList llChildren; // only used with hard disks

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync bool operator==(const Medium &m) const;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync};

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsyncstruct MediaRegistry

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync{

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync MediaList llHardDisks,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync llDvdImages,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync llFloppyImages;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync bool operator==(const MediaRegistry &m) const;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync};

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsyncclass ConfigFileBase

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync{

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsyncpublic:

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync bool fileExists();

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync void copyBaseFrom(const ConfigFileBase &b);

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsyncprotected:

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync ConfigFileBase(const com::Utf8Str *pstrFilename);

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync /* Note: this copy constructor doesn't create a full copy of other, cause

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync ConfigFileBase(const ConfigFileBase &other);

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync ~ConfigFileBase();

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync void parseUUID(com::Guid &guid,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync const com::Utf8Str &strUUID) const;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync void parseTimestamp(RTTIMESPEC &timestamp,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync const com::Utf8Str &str) const;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync com::Utf8Str makeString(const RTTIMESPEC &tm);

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync void readExtraData(const xml::ElementNode &elmExtraData,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync StringsMap &map);

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync void readUSBDeviceFilters(const xml::ElementNode &elmDeviceFilters,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync USBDeviceFiltersList &ll);

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync typedef enum {Error, HardDisk, DVDImage, FloppyImage} MediaType;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync void readMedium(MediaType t, const xml::ElementNode &elmMedium, MediaList &llMedia);

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync void readMediaRegistry(const xml::ElementNode &elmMediaRegistry, MediaRegistry &mr);

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync void setVersionAttribute(xml::ElementNode &elm);

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync void createStubDocument();

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync void buildExtraData(xml::ElementNode &elmParent, const StringsMap &me);

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync void buildUSBDeviceFilters(xml::ElementNode &elmParent,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync const USBDeviceFiltersList &ll,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync bool fHostMode);

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync void buildMedium(xml::ElementNode &elmMedium,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync DeviceType_T devType,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync const Medium &m,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync uint32_t level);

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync void buildMediaRegistry(xml::ElementNode &elmParent,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync const MediaRegistry &mr);

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync void clearDocument();

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync struct Data;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync Data *m;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync friend class ConfigFileError;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync};

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsyncstruct Host

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync{

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync USBDeviceFiltersList llUSBDeviceFilters;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync};

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsyncstruct SystemProperties

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync{

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync SystemProperties()

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync : ulLogHistoryCount(3)

241541868b26b18d777209f5e6c2c0c6ad9d02eevboxsync {}

241541868b26b18d777209f5e6c2c0c6ad9d02eevboxsync

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync com::Utf8Str strDefaultMachineFolder;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync com::Utf8Str strDefaultHardDiskFolder;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync com::Utf8Str strDefaultHardDiskFormat;

241541868b26b18d777209f5e6c2c0c6ad9d02eevboxsync com::Utf8Str strVRDEAuthLibrary;

241541868b26b18d777209f5e6c2c0c6ad9d02eevboxsync com::Utf8Str strWebServiceAuthLibrary;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync com::Utf8Str strDefaultVRDEExtPack;

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync uint32_t ulLogHistoryCount;

241541868b26b18d777209f5e6c2c0c6ad9d02eevboxsync};

c5cae649a77841287fd1e032d8e1e95e996e32cavboxsync

c5cae649a77841287fd1e032d8e1e95e996e32cavboxsyncstruct MachineRegistryEntry

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync{

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync com::Guid uuid;

241541868b26b18d777209f5e6c2c0c6ad9d02eevboxsync com::Utf8Str strSettingsFile;

241541868b26b18d777209f5e6c2c0c6ad9d02eevboxsync};

241541868b26b18d777209f5e6c2c0c6ad9d02eevboxsynctypedef std::list<MachineRegistryEntry> MachinesRegistry;

241541868b26b18d777209f5e6c2c0c6ad9d02eevboxsync

241541868b26b18d777209f5e6c2c0c6ad9d02eevboxsyncstruct DHCPServer

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync{

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync com::Utf8Str strNetworkName,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync strIPAddress,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync strIPNetworkMask,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync strIPLower,

3c3a5ab35783f4d31cb5d3a15db9daadeb804daavboxsync strIPUpper;

bool fEnabled;

};

typedef std::list<DHCPServer> DHCPServersList;

class MainConfigFile : public ConfigFileBase

{

public:

MainConfigFile(const com::Utf8Str *pstrFilename);

void readMachineRegistry(const xml::ElementNode &elmMachineRegistry);

void readDHCPServers(const xml::ElementNode &elmDHCPServers);

void write(const com::Utf8Str strFilename);

Host host;

SystemProperties systemProperties;

MediaRegistry mediaRegistry;

MachinesRegistry llMachines;

DHCPServersList llDhcpServers;

StringsMap mapExtraDataItems;

};

struct VRDESettings

{

VRDESettings()

: fEnabled(true),

authType(AuthType_Null),

ulAuthTimeout(5000),

fAllowMultiConnection(false),

fReuseSingleConnection(false)

{}

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;

};

struct BIOSSettings

{

BIOSSettings()

: fACPIEnabled(true),

fIOAPICEnabled(false),

fLogoFadeIn(true),

fLogoFadeOut(true),

ulLogoDisplayTime(0),

biosBootMenuMode(BIOSBootMenuMode_MessageAndMenu),

fPXEDebugEnabled(false),

llTimeOffset(0)

{}

bool operator==(const BIOSSettings &d) const;

bool fACPIEnabled,

fIOAPICEnabled,

fLogoFadeIn,

fLogoFadeOut;

uint32_t ulLogoDisplayTime;

com::Utf8Str strLogoImagePath;

BIOSBootMenuMode_T biosBootMenuMode;

bool fPXEDebugEnabled;

int64_t llTimeOffset;

};

struct USBController

{

USBController()

: fEnabled(false),

fEnabledEHCI(false)

{}

bool operator==(const USBController &u) const;

bool fEnabled;

bool fEnabledEHCI;

USBDeviceFiltersList llDeviceFilters;

};

struct NATRule

{

NATRule(): proto(NATProtocol_TCP),

u16HostPort(0),

u16GuestPort(0){}

com::Utf8Str strName;

NATProtocol_T proto;

uint16_t u16HostPort;

com::Utf8Str strHostIP;

uint16_t u16GuestPort;

com::Utf8Str strGuestIP;

bool operator==(const NATRule &r) const

{

return strName == r.strName

&& proto == r.proto

&& u16HostPort == r.u16HostPort

&& strHostIP == r.strHostIP

&& u16GuestPort == r.u16GuestPort

&& strGuestIP == r.strGuestIP;

}

};

typedef std::list<NATRule> NATRuleList;

struct NAT

{

NAT() : u32Mtu(0),

u32SockRcv(0),

u32SockSnd(0),

u32TcpRcv(0),

u32TcpSnd(0),

fDnsPassDomain(true), /* historically this value is true */

fDnsProxy(false),

fDnsUseHostResolver(false),

fAliasLog(false),

fAliasProxyOnly(false),

fAliasUseSamePorts(false)

{}

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;

NATRuleList llRules;

bool operator==(const NAT &n) const

{

return strNetwork == n.strNetwork

&& strBindIP == n.strBindIP

&& u32Mtu == n.u32Mtu

&& u32SockRcv == n.u32SockRcv

&& u32SockSnd == n.u32SockSnd

&& u32TcpSnd == n.u32TcpSnd

&& u32TcpRcv == n.u32TcpRcv

&& strTftpPrefix == n.strTftpPrefix

&& strTftpBootFile == n.strTftpBootFile

&& strTftpNextServer == n.strTftpNextServer

&& fDnsPassDomain == n.fDnsPassDomain

&& fDnsProxy == n.fDnsProxy

&& fDnsUseHostResolver == n.fDnsUseHostResolver

&& fAliasLog == n.fAliasLog

&& fAliasProxyOnly == n.fAliasProxyOnly

&& fAliasUseSamePorts == n.fAliasUseSamePorts

&& llRules == n.llRules;

}

};

struct NetworkAdapter

{

NetworkAdapter()

: ulSlot(0),

type(NetworkAdapterType_Am79C970A),

fEnabled(false),

fCableConnected(false),

ulLineSpeed(0),

enmPromiscModePolicy(NetworkAdapterPromiscModePolicy_Deny),

fTraceEnabled(false),

mode(NetworkAttachmentType_Null),

ulBootPriority(0)

{}

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;

com::Utf8Str strInternalNetworkName;

com::Utf8Str strGenericDriver;

StringsMap genericProperties;

uint32_t ulBootPriority;

com::Utf8Str strBandwidthGroup; // requires settings version 1.13 (VirtualBox 4.2)

};

typedef std::list<NetworkAdapter> NetworkAdaptersList;

struct SerialPort

{

SerialPort()

: ulSlot(0),

fEnabled(false),

ulIOBase(0x3f8),

ulIRQ(4),

portMode(PortMode_Disconnected),

fServer(false)

{}

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;

};

typedef std::list<SerialPort> SerialPortsList;

struct ParallelPort

{

ParallelPort()

: ulSlot(0),

fEnabled(false),

ulIOBase(0x378),

ulIRQ(4)

{}

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;

struct AudioAdapter

{

AudioAdapter()

: fEnabled(true),

controllerType(AudioControllerType_AC97),

driverType(AudioDriverType_Null)

{}

bool operator==(const AudioAdapter &a) const

{

return (this == &a)

|| ( (fEnabled == a.fEnabled)

&& (controllerType == a.controllerType)

&& (driverType == a.driverType)

);

}

bool fEnabled;

AudioControllerType_T controllerType;

AudioDriverType_T driverType;

};

struct SharedFolder

{

SharedFolder()

: fWritable(false)

, fAutoMount(false)

{}

bool operator==(const SharedFolder &a) const;

com::Utf8Str strName,

strHostPath;

bool fWritable;

bool fAutoMount;

};

typedef std::list<SharedFolder> SharedFoldersList;

struct GuestProperty

{

GuestProperty()

: timestamp(0)

{};

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;

struct CpuIdLeaf

{

CpuIdLeaf()

: ulId(UINT32_MAX),

ulEax(0),

ulEbx(0),

ulEcx(0),

ulEdx(0)

{}

bool operator==(const CpuIdLeaf &c) const

{

return ( (this == &c)

|| ( (ulId == c.ulId)

&& (ulEax == c.ulEax)

&& (ulEbx == c.ulEbx)

&& (ulEcx == c.ulEcx)

&& (ulEdx == c.ulEdx)

)

);

}

uint32_t ulId;

uint32_t ulEax;

uint32_t ulEbx;

uint32_t ulEcx;

uint32_t ulEdx;

};

typedef std::list<CpuIdLeaf> CpuIdLeafsList;

struct Cpu

{

Cpu()

: ulId(UINT32_MAX)

{}

bool operator==(const Cpu &c) const

{

return (ulId == c.ulId);

}

uint32_t ulId;

};

typedef std::list<Cpu> CpuList;

struct BandwidthGroup

{

BandwidthGroup()

: cMaxMbPerSec(0),

enmType(BandwidthGroupType_Null)

{}

bool operator==(const BandwidthGroup &i) const

{

return ( (strName == i.strName)

&& (cMaxMbPerSec == i.cMaxMbPerSec)

&& (enmType == i.enmType));

}

com::Utf8Str strName;

uint32_t cMaxMbPerSec;

BandwidthGroupType_T enmType;

};

typedef std::list<BandwidthGroup> BandwidthGroupList;

struct IoSettings

{

IoSettings();

bool operator==(const IoSettings &i) const

{

return ( (fIoCacheEnabled == i.fIoCacheEnabled)

&& (ulIoCacheSize == i.ulIoCacheSize)

&& (llBandwidthGroups == i.llBandwidthGroups));

}

bool fIoCacheEnabled;

uint32_t ulIoCacheSize;

BandwidthGroupList llBandwidthGroups;

};

struct HostPciDeviceAttachment

{

HostPciDeviceAttachment()

: uHostAddress(0),

uGuestAddress(0)

{}

bool operator==(const HostPciDeviceAttachment &a) const

{

return ( (uHostAddress == a.uHostAddress)

&& (uGuestAddress == a.uGuestAddress)

&& (strDeviceName == a.strDeviceName)

);

}

com::Utf8Str strDeviceName;

uint32_t uHostAddress;

uint32_t uGuestAddress;

};

typedef std::list<HostPciDeviceAttachment> HostPciDeviceAttachmentList;

struct Hardware

{

Hardware();

bool operator==(const Hardware&) const;

com::Utf8Str strVersion; // hardware version, optional

com::Guid uuid; // hardware uuid, optional (null).

bool fHardwareVirt,

fHardwareVirtExclusive,

fNestedPaging,

fLargePages,

fVPID,

fHardwareVirtForce,

fSyntheticCpu,

fPAE;

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)

CpuIdLeafsList llCpuIdLeafs;

uint32_t ulMemorySizeMB;

BootOrderMap mapBootOrder; // item 0 has highest priority

uint32_t ulVRAMSizeMB;

uint32_t cMonitors;

bool fAccelerate3D,

fAccelerate2DVideo; // requires settings version 1.8 (VirtualBox 3.1)

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)

VRDESettings vrdeSettings;

BIOSSettings biosSettings;

USBController usbController;

NetworkAdaptersList llNetworkAdapters;

SerialPortsList llSerialPorts;

ParallelPortsList llParallelPorts;

AudioAdapter audioAdapter;

// 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;

uint32_t ulMemoryBalloonSize;

bool fPageFusionEnabled;

GuestPropertiesList llGuestProperties;

com::Utf8Str strNotificationPatterns;

IoSettings ioSettings; // requires settings version 1.10 (VirtualBox 3.2)

HostPciDeviceAttachmentList pciAttachments; // requires settings version 1.12 (VirtualBox 4.1)

};

struct AttachedDevice

{

AttachedDevice()

: deviceType(DeviceType_Null),

fPassThrough(false),

fTempEject(false),

fNonRotational(false),

lPort(0),

lDevice(0)

{}

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;

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;

struct StorageController

{

StorageController()

: storageBus(StorageBus_IDE),

controllerType(StorageControllerType_PIIX3),

ulPortCount(2),

ulInstance(0),

fUseHostIOCache(true),

fBootable(true),

lIDE0MasterEmulationPort(0),

lIDE0SlaveEmulationPort(0),

lIDE1MasterEmulationPort(0),

lIDE1SlaveEmulationPort(0)

{}

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;

struct Storage

{

bool operator==(const Storage &s) const;

StorageControllersList llStorageControllers;

};

struct Snapshot;

typedef std::list<Snapshot> SnapshotsList;

struct 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;

Storage storage;

SnapshotsList llChildSnapshots;

};

struct MachineUserData

{

MachineUserData()

: fNameSync(true),

fTeleporterEnabled(false),

uTeleporterPort(0),

enmFaultToleranceState(FaultToleranceState_Inactive),

uFaultTolerancePort(0),

uFaultToleranceInterval(0),

fRTCUseUTC(false)

{ }

bool operator==(const MachineUserData &c) const

{

return (strName == c.strName)

&& (fNameSync == c.fNameSync)

&& (strDescription == c.strDescription)

&& (strOsType == c.strOsType)

&& (strSnapshotFolder == c.strSnapshotFolder)

&& (fTeleporterEnabled == c.fTeleporterEnabled)

&& (uTeleporterPort == c.uTeleporterPort)

&& (strTeleporterAddress == c.strTeleporterAddress)

&& (strTeleporterPassword == c.strTeleporterPassword)

&& (enmFaultToleranceState == c.enmFaultToleranceState)

&& (uFaultTolerancePort == c.uFaultTolerancePort)

&& (uFaultToleranceInterval == c.uFaultToleranceInterval)

&& (strFaultToleranceAddress == c.strFaultToleranceAddress)

&& (strFaultTolerancePassword == c.strFaultTolerancePassword)

&& (fRTCUseUTC == c.fRTCUseUTC);

}

com::Utf8Str strName;

bool fNameSync;

com::Utf8Str strDescription;

com::Utf8Str strOsType;

com::Utf8Str strSnapshotFolder;

bool fTeleporterEnabled;

uint32_t uTeleporterPort;

com::Utf8Str strTeleporterAddress;

com::Utf8Str strTeleporterPassword;

FaultToleranceState_T enmFaultToleranceState;

uint32_t uFaultTolerancePort;

com::Utf8Str strFaultToleranceAddress;

com::Utf8Str strFaultTolerancePassword;

uint32_t uFaultToleranceInterval;

bool fRTCUseUTC;

};

class MachineConfigFile : public ConfigFileBase

{

public:

com::Guid uuid;

MachineUserData machineUserData;

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;

Storage storageMachine;

MediaRegistry mediaRegistry;

StringsMap mapExtraDataItems;

SnapshotsList llFirstSnapshot; // first snapshot or empty list if there's none

MachineConfigFile(const com::Utf8Str *pstrFilename);

bool operator==(const MachineConfigFile &m) const;

bool canHaveOwnMediaRegistry() const;

void importMachineXML(const xml::ElementNode &elmMachine);

void write(const com::Utf8Str &strFilename);

enum

{

BuildMachineXML_IncludeSnapshots = 0x01,

BuildMachineXML_WriteVboxVersionAttribute = 0x02,

BuildMachineXML_SkipRemovableMedia = 0x04,

BuildMachineXML_MediaRegistry = 0x08,

BuildMachineXML_SuppressSavedState = 0x10

};

void buildMachineXML(xml::ElementNode &elmMachine,

uint32_t fl,

std::list<xml::ElementNode*> *pllElementsWithUuidAttributes);

static bool isAudioDriverAllowedOnThisHost(AudioDriverType_T drv);

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, Storage &strg);

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 readSnapshot(const xml::ElementNode &elmSnapshot, Snapshot &snap);

void convertOldOSType_pre1_5(com::Utf8Str &str);

void readMachine(const xml::ElementNode &elmMachine);

void buildHardwareXML(xml::ElementNode &elmParent, const Hardware &hw, const Storage &strg);

void buildNetworkXML(NetworkAttachmentType_T mode, xml::ElementNode &elmParent, bool fEnabled, const NetworkAdapter &nic);

void buildStorageControllersXML(xml::ElementNode &elmParent,

const Storage &st,

bool fSkipRemovableMedia,

std::list<xml::ElementNode*> *pllElementsWithUuidAttributes);

void buildSnapshotXML(xml::ElementNode &elmParent, const Snapshot &snap);

void bumpSettingsVersionIfNeeded();

};

} // namespace settings

#endif /* ___VBox_settings_h */