settings.h@ 48093

Last change on this file since 48093 was 48093, checked in by vboxsync, 12 years ago

NAT/xml: loopback mappings introduces NATNetwork entities:

<Mappings>

<Loopback4 address="127.0.1.1" offset="6"/>
<Loopback4 address="127.0.1.2" offset="7"/>

</Mappings>

to describe mapppings any hostid in 127/8 network to our NAT network, e.g. in this case 127.0.1.1 corresponds to network id + 6 (network id here from CIDR defined on creation), for IPv6 (as soon localhost6 could be only one) attribute "loopback6" is reserved in NATNetwork tag.

operators: NATHostLoopbackOffset::operator == (const Utf8Str&) and NATHostLoopbackOffset::operator==(uint32_t) are introduced got using std::find on adding and modification operations in NATNetworkImpl.

Property svn:eol-style set to native
Property svn:keywords set to Date Revision Author Id

File size: 42.7 KB

Line
1	/** @file
2	* Settings file data structures.
3	*
4	* These structures are created by the settings file loader and filled with values
5	* copied from the raw XML data. This was all new with VirtualBox 3.1 and allows us
6	* to finally make the XML reader version-independent and read VirtualBox XML files
7	* from earlier and even newer (future) versions without requiring complicated,
8	* tedious and error-prone XSLT conversions.
9	*
10	* It is this file that defines all structures that map VirtualBox global and
11	* machine settings to XML files. These structures are used by the rest of Main,
12	* even though this header file does not require anything else in Main.
13	*
14	* Note: Headers in Main code have been tweaked to only declare the structures
15	* defined here so that this header need only be included from code files that
16	* actually use these structures.
17	*/
18
19	/*
20	* Copyright (C) 2007-2013 Oracle Corporation
21	*
22	* This file is part of VirtualBox Open Source Edition (OSE), as
23	* available from http://www.virtualbox.org. This file is free software;
24	* you can redistribute it and/or modify it under the terms of the GNU
25	* General Public License (GPL) as published by the Free Software
26	* Foundation, in version 2 as it comes in the "COPYING" file of the
27	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
28	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
29	*
30	* The contents of this file may alternatively be used under the terms
31	* of the Common Development and Distribution License Version 1.0
32	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
33	* VirtualBox OSE distribution, in which case the provisions of the
34	* CDDL are applicable instead of those of the GPL.
35	*
36	* You may elect to license modified versions of this file under the
37	* terms and conditions of either the GPL or the CDDL or both.
38	*/
39
40	#ifndef ___VBox_settings_h
41	#define ___VBox_settings_h
42
43	#include <iprt/time.h>
44
45	#include "VBox/com/VirtualBox.h"
46
47	#include <VBox/com/Guid.h>
48	#include <VBox/com/string.h>
49
50	#include <list>
51	#include <map>
52
53	/**
54	* Maximum depth of the snapshot tree, to prevent stack overflows.
55	* XPCOM has a relatively low stack size for its workers, and we have
56	* to avoid crashes due to exceeding the limit both on reading and
57	* writing config files.
58	*/
59	#define SETTINGS_SNAPSHOT_DEPTH_MAX 250
60
61	namespace xml
62	{
63	class ElementNode;
64	}
65
66	namespace settings
67	{
68
69	class ConfigFileError;
70
71	////////////////////////////////////////////////////////////////////////////////
72	//
73	// Structures shared between Machine XML and VirtualBox.xml
74	//
75	////////////////////////////////////////////////////////////////////////////////
76
77	/**
78	* USB device filter definition. This struct is used both in MainConfigFile
79	* (for global USB filters) and MachineConfigFile (for machine filters).
80	*
81	* NOTE: If you add any fields in here, you must update a) the constructor and b)
82	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
83	* your settings might never get saved.
84	*/
85	struct USBDeviceFilter
86	{
87	USBDeviceFilter()
88	: fActive(false),
89	action(USBDeviceFilterAction_Null),
90	ulMaskedInterfaces(0)
91	{}
92
93	bool operator==(const USBDeviceFilter&u) const;
94
95	com::Utf8Str strName;
96	bool fActive;
97	com::Utf8Str strVendorId,
98	strProductId,
99	strRevision,
100	strManufacturer,
101	strProduct,
102	strSerialNumber,
103	strPort;
104	USBDeviceFilterAction_T action; // only used with host USB filters
105	com::Utf8Str strRemote; // irrelevant for host USB objects
106	uint32_t ulMaskedInterfaces; // irrelevant for host USB objects
107	};
108
109	typedef std::map<com::Utf8Str, com::Utf8Str> StringsMap;
110	typedef std::list<com::Utf8Str> StringsList;
111
112	// ExtraDataItem (used by both VirtualBox.xml and machines XML)
113	struct USBDeviceFilter;
114	typedef std::list<USBDeviceFilter> USBDeviceFiltersList;
115
116	struct Medium;
117	typedef std::list<Medium> MediaList;
118
119	/**
120	* NOTE: If you add any fields in here, you must update a) the constructor and b)
121	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
122	* your settings might never get saved.
123	*/
124	struct Medium
125	{
126	Medium()
127	: fAutoReset(false),
128	hdType(MediumType_Normal)
129	{}
130
131	com::Guid uuid;
132	com::Utf8Str strLocation;
133	com::Utf8Str strDescription;
134
135	// the following are for hard disks only:
136	com::Utf8Str strFormat;
137	bool fAutoReset; // optional, only for diffs, default is false
138	StringsMap properties;
139	MediumType_T hdType;
140
141	MediaList llChildren; // only used with hard disks
142
143	bool operator==(const Medium &m) const;
144	};
145
146	/**
147	* A media registry. Starting with VirtualBox 3.3, this can appear in both the
148	* VirtualBox.xml file as well as machine XML files with settings version 1.11
149	* or higher, so these lists are now in ConfigFileBase.
150	*
151	* NOTE: If you add any fields in here, you must update a) the constructor and b)
152	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
153	* your settings might never get saved.
154	*/
155	struct MediaRegistry
156	{
157	MediaList llHardDisks,
158	llDvdImages,
159	llFloppyImages;
160
161	bool operator==(const MediaRegistry &m) const;
162	};
163
164	/**
165	*
166	*/
167	struct NATRule
168	{
169	NATRule()
170	: proto(NATProtocol_TCP),
171	u16HostPort(0),
172	u16GuestPort(0)
173	{}
174
175	bool operator==(const NATRule &r) const
176	{
177	return strName == r.strName
178	&& proto == r.proto
179	&& u16HostPort == r.u16HostPort
180	&& strHostIP == r.strHostIP
181	&& u16GuestPort == r.u16GuestPort
182	&& strGuestIP == r.strGuestIP;
183	}
184
185	com::Utf8Str strName;
186	NATProtocol_T proto;
187	uint16_t u16HostPort;
188	com::Utf8Str strHostIP;
189	uint16_t u16GuestPort;
190	com::Utf8Str strGuestIP;
191	};
192	typedef std::list<NATRule> NATRuleList;
193
194	struct NATHostLoopbackOffset
195	{
196	/** Note: 128/8 is only acceptable */
197	com::Utf8Str strLoopbackHostAddress;
198	uint32_t u32Offset;
199	bool operator == (const com::Utf8Str& strAddr)
200	{
201	return (strLoopbackHostAddress == strAddr);
202	}
203
204	bool operator == (uint32_t off)
205	{
206	return (this->u32Offset == off);
207	}
208	};
209	typedef std::list<NATHostLoopbackOffset> NATLoopbackOffsetList;
210
211	/**
212	* Common base class for both MainConfigFile and MachineConfigFile
213	* which contains some common logic for both.
214	*/
215	class ConfigFileBase
216	{
217	public:
218	bool fileExists();
219
220	void copyBaseFrom(const ConfigFileBase &b);
221
222	protected:
223	ConfigFileBase(const com::Utf8Str *pstrFilename);
224	/* Note: this copy constructor doesn't create a full copy of other, cause
225	* the file based stuff (xml doc) could not be copied. */
226	ConfigFileBase(const ConfigFileBase &other);
227
228	~ConfigFileBase();
229
230	void parseUUID(com::Guid &guid,
231	const com::Utf8Str &strUUID) const;
232	void parseTimestamp(RTTIMESPEC &timestamp,
233	const com::Utf8Str &str) const;
234
235	com::Utf8Str makeString(const RTTIMESPEC &tm);
236
237	void readExtraData(const xml::ElementNode &elmExtraData,
238	StringsMap &map);
239	void readUSBDeviceFilters(const xml::ElementNode &elmDeviceFilters,
240	USBDeviceFiltersList &ll);
241	typedef enum {Error, HardDisk, DVDImage, FloppyImage} MediaType;
242	void readMedium(MediaType t, const xml::ElementNode &elmMedium, MediaList &llMedia);
243	void readMediaRegistry(const xml::ElementNode &elmMediaRegistry, MediaRegistry &mr);
244	void readNATForwardRuleList(const xml::ElementNode &elmParent, NATRuleList &llRules);
245	void readNATLoopbacks(const xml::ElementNode &elmParent, NATLoopbackOffsetList &llLoopBacks);
246
247	void setVersionAttribute(xml::ElementNode &elm);
248	void createStubDocument();
249
250	void buildExtraData(xml::ElementNode &elmParent, const StringsMap &me);
251	void buildUSBDeviceFilters(xml::ElementNode &elmParent,
252	const USBDeviceFiltersList &ll,
253	bool fHostMode);
254	void buildMedium(xml::ElementNode &elmMedium,
255	DeviceType_T devType,
256	const Medium &m,
257	uint32_t level);
258	void buildMediaRegistry(xml::ElementNode &elmParent,
259	const MediaRegistry &mr);
260	void buildNATForwardRuleList(xml::ElementNode &elmParent, const NATRuleList &natRuleList);
261	void buildNATLoopbacks(xml::ElementNode &elmParent, const NATLoopbackOffsetList &natLoopbackList);
262	void clearDocument();
263
264	struct Data;
265	Data *m;
266
267	friend class ConfigFileError;
268	};
269
270	////////////////////////////////////////////////////////////////////////////////
271	//
272	// VirtualBox.xml structures
273	//
274	////////////////////////////////////////////////////////////////////////////////
275
276	struct Host
277	{
278	USBDeviceFiltersList llUSBDeviceFilters;
279	};
280
281	struct SystemProperties
282	{
283	SystemProperties()
284	: ulLogHistoryCount(3)
285	#if defined(RT_OS_DARWIN) \|\| defined(RT_OS_WINDOWS)
286	, fExclusiveHwVirt(false)
287	#else
288	, fExclusiveHwVirt(true)
289	#endif
290	{}
291
292	com::Utf8Str strDefaultMachineFolder;
293	com::Utf8Str strDefaultHardDiskFolder;
294	com::Utf8Str strDefaultHardDiskFormat;
295	com::Utf8Str strVRDEAuthLibrary;
296	com::Utf8Str strWebServiceAuthLibrary;
297	com::Utf8Str strDefaultVRDEExtPack;
298	com::Utf8Str strAutostartDatabasePath;
299	com::Utf8Str strDefaultAdditionsISO;
300	com::Utf8Str strDefaultFrontend;
301	com::Utf8Str strLoggingLevel;
302	uint32_t ulLogHistoryCount;
303	bool fExclusiveHwVirt;
304	};
305
306	struct MachineRegistryEntry
307	{
308	com::Guid uuid;
309	com::Utf8Str strSettingsFile;
310	};
311	typedef std::list<MachineRegistryEntry> MachinesRegistry;
312
313	typedef std::map<DhcpOpt_T, com::Utf8Str> DhcpOptionMap;
314	typedef DhcpOptionMap::value_type DhcpOptValuePair;
315	typedef DhcpOptionMap::iterator DhcpOptIterator;
316	typedef DhcpOptionMap::const_iterator DhcpOptConstIterator;
317
318	typedef struct VmNameSlotKey
319	{
320	VmNameSlotKey(const com::Utf8Str& aVmName, LONG aSlot): VmName(aVmName),
321	Slot(aSlot){}
322	const com::Utf8Str VmName;
323	LONG Slot;
324	bool operator< (const VmNameSlotKey& that) const
325	{
326	if (VmName == that.VmName)
327	return Slot < that.Slot;
328	else return VmName < that.VmName;
329	}
330	} VmNameSlotKey;
331	typedef std::map<VmNameSlotKey, DhcpOptionMap> VmSlot2OptionsMap;
332	typedef VmSlot2OptionsMap::value_type VmSlot2OptionsPair;
333	typedef VmSlot2OptionsMap::iterator VmSlot2OptionsIterator;
334	typedef VmSlot2OptionsMap::const_iterator VmSlot2OptionsConstIterator;
335
336	struct DHCPServer
337	{
338	DHCPServer()
339	: fEnabled(false)
340	{}
341
342	com::Utf8Str strNetworkName,
343	strIPAddress,
344	strIPLower,
345	strIPUpper;
346	bool fEnabled;
347	std::map<DhcpOpt_T, com::Utf8Str> GlobalDhcpOptions;
348	VmSlot2OptionsMap VmSlot2OptionsM;
349	};
350	typedef std::list<DHCPServer> DHCPServersList;
351
352
353	/**
354	* Nat Networking settings (NAT service).
355	*/
356	struct NATNetwork
357	{
358	com::Utf8Str strNetworkName;
359	bool fEnabled;
360	com::Utf8Str strNetwork;
361	bool fIPv6;
362	com::Utf8Str strIPv6Prefix;
363	uint32_t u32HostLoopback6Offset;
364	NATLoopbackOffsetList llHostLoopbackOffsetList;
365	bool fAdvertiseDefaultIPv6Route;
366	bool fNeedDhcpServer;
367	NATRuleList llPortForwardRules4;
368	NATRuleList llPortForwardRules6;
369	NATNetwork():fEnabled(false),
370	fAdvertiseDefaultIPv6Route(false),
371	fNeedDhcpServer(false)
372	{}
373	bool operator==(const NATNetwork &n) const
374	{
375	return strNetworkName == n.strNetworkName
376	&& strNetwork == n.strNetwork;
377	}
378
379	};
380	typedef std::list<NATNetwork> NATNetworksList;
381
382
383	class MainConfigFile : public ConfigFileBase
384	{
385	public:
386	MainConfigFile(const com::Utf8Str *pstrFilename);
387
388	void readMachineRegistry(const xml::ElementNode &elmMachineRegistry);
389	void readDHCPServers(const xml::ElementNode &elmDHCPServers);
390	void readDhcpOptions(DhcpOptionMap& map, const xml::ElementNode& options);
391	void readNATNetworks(const xml::ElementNode &elmNATNetworks);
392
393	void write(const com::Utf8Str strFilename);
394
395	Host host;
396	SystemProperties systemProperties;
397	MediaRegistry mediaRegistry;
398	MachinesRegistry llMachines;
399	DHCPServersList llDhcpServers;
400	NATNetworksList llNATNetworks;
401	StringsMap mapExtraDataItems;
402
403	private:
404	void bumpSettingsVersionIfNeeded();
405	};
406
407	////////////////////////////////////////////////////////////////////////////////
408	//
409	// Machine XML structures
410	//
411	////////////////////////////////////////////////////////////////////////////////
412
413	/**
414	* NOTE: If you add any fields in here, you must update a) the constructor and b)
415	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
416	* your settings might never get saved.
417	*/
418	struct VRDESettings
419	{
420	VRDESettings()
421	: fEnabled(true),
422	authType(AuthType_Null),
423	ulAuthTimeout(5000),
424	fAllowMultiConnection(false),
425	fReuseSingleConnection(false)
426	{}
427
428	bool operator==(const VRDESettings& v) const;
429
430	bool fEnabled;
431	AuthType_T authType;
432	uint32_t ulAuthTimeout;
433	com::Utf8Str strAuthLibrary;
434	bool fAllowMultiConnection,
435	fReuseSingleConnection;
436	com::Utf8Str strVrdeExtPack;
437	StringsMap mapProperties;
438	};
439
440	/**
441	* NOTE: If you add any fields in here, you must update a) the constructor and b)
442	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
443	* your settings might never get saved.
444	*/
445	struct BIOSSettings
446	{
447	BIOSSettings()
448	: fACPIEnabled(true),
449	fIOAPICEnabled(false),
450	fLogoFadeIn(true),
451	fLogoFadeOut(true),
452	ulLogoDisplayTime(0),
453	biosBootMenuMode(BIOSBootMenuMode_MessageAndMenu),
454	fPXEDebugEnabled(false),
455	llTimeOffset(0)
456	{}
457
458	bool operator==(const BIOSSettings &d) const;
459
460	bool fACPIEnabled,
461	fIOAPICEnabled,
462	fLogoFadeIn,
463	fLogoFadeOut;
464	uint32_t ulLogoDisplayTime;
465	com::Utf8Str strLogoImagePath;
466	BIOSBootMenuMode_T biosBootMenuMode;
467	bool fPXEDebugEnabled;
468	int64_t llTimeOffset;
469	};
470
471	/**
472	* NOTE: If you add any fields in here, you must update a) the constructor and b)
473	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
474	* your settings might never get saved.
475	*/
476	struct USBController
477	{
478	USBController()
479	: enmType(USBControllerType_Null)
480	{}
481
482	bool operator==(const USBController &u) const;
483
484	com::Utf8Str strName;
485	USBControllerType_T enmType;
486	};
487	typedef std::list<USBController> USBControllerList;
488
489	struct USB
490	{
491	USB() {}
492
493	bool operator==(const USB &u) const;
494
495	/** List of USB controllers present. */
496	USBControllerList llUSBControllers;
497	/** List of USB device filters. */
498	USBDeviceFiltersList llDeviceFilters;
499	};
500
501	struct NAT
502	{
503	NAT()
504	: u32Mtu(0),
505	u32SockRcv(0),
506	u32SockSnd(0),
507	u32TcpRcv(0),
508	u32TcpSnd(0),
509	fDNSPassDomain(true), /* historically this value is true */
510	fDNSProxy(false),
511	fDNSUseHostResolver(false),
512	fAliasLog(false),
513	fAliasProxyOnly(false),
514	fAliasUseSamePorts(false)
515	{}
516
517	bool operator==(const NAT &n) const
518	{
519	return strNetwork == n.strNetwork
520	&& strBindIP == n.strBindIP
521	&& u32Mtu == n.u32Mtu
522	&& u32SockRcv == n.u32SockRcv
523	&& u32SockSnd == n.u32SockSnd
524	&& u32TcpSnd == n.u32TcpSnd
525	&& u32TcpRcv == n.u32TcpRcv
526	&& strTFTPPrefix == n.strTFTPPrefix
527	&& strTFTPBootFile == n.strTFTPBootFile
528	&& strTFTPNextServer == n.strTFTPNextServer
529	&& fDNSPassDomain == n.fDNSPassDomain
530	&& fDNSProxy == n.fDNSProxy
531	&& fDNSUseHostResolver == n.fDNSUseHostResolver
532	&& fAliasLog == n.fAliasLog
533	&& fAliasProxyOnly == n.fAliasProxyOnly
534	&& fAliasUseSamePorts == n.fAliasUseSamePorts
535	&& llRules == n.llRules;
536	}
537
538	com::Utf8Str strNetwork;
539	com::Utf8Str strBindIP;
540	uint32_t u32Mtu;
541	uint32_t u32SockRcv;
542	uint32_t u32SockSnd;
543	uint32_t u32TcpRcv;
544	uint32_t u32TcpSnd;
545	com::Utf8Str strTFTPPrefix;
546	com::Utf8Str strTFTPBootFile;
547	com::Utf8Str strTFTPNextServer;
548	bool fDNSPassDomain;
549	bool fDNSProxy;
550	bool fDNSUseHostResolver;
551	bool fAliasLog;
552	bool fAliasProxyOnly;
553	bool fAliasUseSamePorts;
554	NATRuleList llRules;
555	};
556
557	/**
558	* NOTE: If you add any fields in here, you must update a) the constructor and b)
559	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
560	* your settings might never get saved.
561	*/
562	struct NetworkAdapter
563	{
564	NetworkAdapter()
565	: ulSlot(0),
566	type(NetworkAdapterType_Am79C970A),
567	fEnabled(false),
568	fCableConnected(false),
569	ulLineSpeed(0),
570	enmPromiscModePolicy(NetworkAdapterPromiscModePolicy_Deny),
571	fTraceEnabled(false),
572	mode(NetworkAttachmentType_Null),
573	ulBootPriority(0)
574	{}
575
576	bool operator==(const NetworkAdapter &n) const;
577
578	uint32_t ulSlot;
579
580	NetworkAdapterType_T type;
581	bool fEnabled;
582	com::Utf8Str strMACAddress;
583	bool fCableConnected;
584	uint32_t ulLineSpeed;
585	NetworkAdapterPromiscModePolicy_T enmPromiscModePolicy;
586	bool fTraceEnabled;
587	com::Utf8Str strTraceFile;
588
589	NetworkAttachmentType_T mode;
590	NAT nat;
591	com::Utf8Str strBridgedName;
592	com::Utf8Str strHostOnlyName;
593	com::Utf8Str strInternalNetworkName;
594	com::Utf8Str strGenericDriver;
595	StringsMap genericProperties;
596	uint32_t ulBootPriority;
597	com::Utf8Str strBandwidthGroup; // requires settings version 1.13 (VirtualBox 4.2)
598	};
599	typedef std::list<NetworkAdapter> NetworkAdaptersList;
600
601	/**
602	* NOTE: If you add any fields in here, you must update a) the constructor and b)
603	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
604	* your settings might never get saved.
605	*/
606	struct SerialPort
607	{
608	SerialPort()
609	: ulSlot(0),
610	fEnabled(false),
611	ulIOBase(0x3f8),
612	ulIRQ(4),
613	portMode(PortMode_Disconnected),
614	fServer(false)
615	{}
616
617	bool operator==(const SerialPort &n) const;
618
619	uint32_t ulSlot;
620
621	bool fEnabled;
622	uint32_t ulIOBase;
623	uint32_t ulIRQ;
624	PortMode_T portMode;
625	com::Utf8Str strPath;
626	bool fServer;
627	};
628	typedef std::list<SerialPort> SerialPortsList;
629
630	/**
631	* NOTE: If you add any fields in here, you must update a) the constructor and b)
632	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
633	* your settings might never get saved.
634	*/
635	struct ParallelPort
636	{
637	ParallelPort()
638	: ulSlot(0),
639	fEnabled(false),
640	ulIOBase(0x378),
641	ulIRQ(7)
642	{}
643
644	bool operator==(const ParallelPort &d) const;
645
646	uint32_t ulSlot;
647
648	bool fEnabled;
649	uint32_t ulIOBase;
650	uint32_t ulIRQ;
651	com::Utf8Str strPath;
652	};
653	typedef std::list<ParallelPort> ParallelPortsList;
654
655	/**
656	* NOTE: If you add any fields in here, you must update a) the constructor and b)
657	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
658	* your settings might never get saved.
659	*/
660	struct AudioAdapter
661	{
662	AudioAdapter()
663	: fEnabled(true),
664	controllerType(AudioControllerType_AC97),
665	driverType(AudioDriverType_Null)
666	{}
667
668	bool operator==(const AudioAdapter &a) const
669	{
670	return (this == &a)
671	\|\| ( (fEnabled == a.fEnabled)
672	&& (controllerType == a.controllerType)
673	&& (driverType == a.driverType)
674	);
675	}
676
677	bool fEnabled;
678	AudioControllerType_T controllerType;
679	AudioDriverType_T driverType;
680	};
681
682	/**
683	* NOTE: If you add any fields in here, you must update a) the constructor and b)
684	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
685	* your settings might never get saved.
686	*/
687	struct SharedFolder
688	{
689	SharedFolder()
690	: fWritable(false)
691	, fAutoMount(false)
692	{}
693
694	bool operator==(const SharedFolder &a) const;
695
696	com::Utf8Str strName,
697	strHostPath;
698	bool fWritable;
699	bool fAutoMount;
700	};
701	typedef std::list<SharedFolder> SharedFoldersList;
702
703	/**
704	* NOTE: If you add any fields in here, you must update a) the constructor and b)
705	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
706	* your settings might never get saved.
707	*/
708	struct GuestProperty
709	{
710	GuestProperty()
711	: timestamp(0)
712	{};
713
714	bool operator==(const GuestProperty &g) const;
715
716	com::Utf8Str strName,
717	strValue;
718	uint64_t timestamp;
719	com::Utf8Str strFlags;
720	};
721	typedef std::list<GuestProperty> GuestPropertiesList;
722
723	typedef std::map<uint32_t, DeviceType_T> BootOrderMap;
724
725	/**
726	* NOTE: If you add any fields in here, you must update a) the constructor and b)
727	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
728	* your settings might never get saved.
729	*/
730	struct CpuIdLeaf
731	{
732	CpuIdLeaf()
733	: ulId(UINT32_MAX),
734	ulEax(0),
735	ulEbx(0),
736	ulEcx(0),
737	ulEdx(0)
738	{}
739
740	bool operator==(const CpuIdLeaf &c) const
741	{
742	return ( (this == &c)
743	\|\| ( (ulId == c.ulId)
744	&& (ulEax == c.ulEax)
745	&& (ulEbx == c.ulEbx)
746	&& (ulEcx == c.ulEcx)
747	&& (ulEdx == c.ulEdx)
748	)
749	);
750	}
751
752	uint32_t ulId;
753	uint32_t ulEax;
754	uint32_t ulEbx;
755	uint32_t ulEcx;
756	uint32_t ulEdx;
757	};
758	typedef std::list<CpuIdLeaf> CpuIdLeafsList;
759
760	/**
761	* NOTE: If you add any fields in here, you must update a) the constructor and b)
762	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
763	* your settings might never get saved.
764	*/
765	struct Cpu
766	{
767	Cpu()
768	: ulId(UINT32_MAX)
769	{}
770
771	bool operator==(const Cpu &c) const
772	{
773	return (ulId == c.ulId);
774	}
775
776	uint32_t ulId;
777	};
778	typedef std::list<Cpu> CpuList;
779
780	/**
781	* NOTE: If you add any fields in here, you must update a) the constructor and b)
782	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
783	* your settings might never get saved.
784	*/
785	struct BandwidthGroup
786	{
787	BandwidthGroup()
788	: cMaxBytesPerSec(0),
789	enmType(BandwidthGroupType_Null)
790	{}
791
792	bool operator==(const BandwidthGroup &i) const
793	{
794	return ( (strName == i.strName)
795	&& (cMaxBytesPerSec == i.cMaxBytesPerSec)
796	&& (enmType == i.enmType));
797	}
798
799	com::Utf8Str strName;
800	uint64_t cMaxBytesPerSec;
801	BandwidthGroupType_T enmType;
802	};
803	typedef std::list<BandwidthGroup> BandwidthGroupList;
804
805	/**
806	* NOTE: If you add any fields in here, you must update a) the constructor and b)
807	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
808	* your settings might never get saved.
809	*/
810	struct IOSettings
811	{
812	IOSettings();
813
814	bool operator==(const IOSettings &i) const
815	{
816	return ( (fIOCacheEnabled == i.fIOCacheEnabled)
817	&& (ulIOCacheSize == i.ulIOCacheSize)
818	&& (llBandwidthGroups == i.llBandwidthGroups));
819	}
820
821	bool fIOCacheEnabled;
822	uint32_t ulIOCacheSize;
823	BandwidthGroupList llBandwidthGroups;
824	};
825
826	/**
827	* NOTE: If you add any fields in here, you must update a) the constructor and b)
828	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
829	* your settings might never get saved.
830	*/
831	struct HostPCIDeviceAttachment
832	{
833	HostPCIDeviceAttachment()
834	: uHostAddress(0),
835	uGuestAddress(0)
836	{}
837
838	bool operator==(const HostPCIDeviceAttachment &a) const
839	{
840	return ( (uHostAddress == a.uHostAddress)
841	&& (uGuestAddress == a.uGuestAddress)
842	&& (strDeviceName == a.strDeviceName)
843	);
844	}
845
846	com::Utf8Str strDeviceName;
847	uint32_t uHostAddress;
848	uint32_t uGuestAddress;
849	};
850	typedef std::list<HostPCIDeviceAttachment> HostPCIDeviceAttachmentList;
851
852	/**
853	* Representation of Machine hardware; this is used in the MachineConfigFile.hardwareMachine
854	* field.
855	*
856	* NOTE: If you add any fields in here, you must update a) the constructor and b)
857	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
858	* your settings might never get saved.
859	*/
860	struct Hardware
861	{
862	Hardware();
863
864	bool operator==(const Hardware&) const;
865
866	com::Utf8Str strVersion; // hardware version, optional
867	com::Guid uuid; // hardware uuid, optional (null).
868
869	bool fHardwareVirt,
870	fNestedPaging,
871	fLargePages,
872	fVPID,
873	fUnrestrictedExecution,
874	fHardwareVirtForce,
875	fSyntheticCpu,
876	fPAE;
877	typedef enum LongModeType { LongMode_Enabled, LongMode_Disabled, LongMode_Legacy } LongModeType;
878	LongModeType enmLongMode;
879	uint32_t cCPUs;
880	bool fCpuHotPlug; // requires settings version 1.10 (VirtualBox 3.2)
881	CpuList llCpus; // requires settings version 1.10 (VirtualBox 3.2)
882	bool fHPETEnabled; // requires settings version 1.10 (VirtualBox 3.2)
883	uint32_t ulCpuExecutionCap; // requires settings version 1.11 (VirtualBox 3.3)
884
885	CpuIdLeafsList llCpuIdLeafs;
886
887	uint32_t ulMemorySizeMB;
888
889	BootOrderMap mapBootOrder; // item 0 has highest priority
890
891	GraphicsControllerType_T graphicsControllerType;
892	uint32_t ulVRAMSizeMB;
893	uint32_t cMonitors;
894	bool fAccelerate3D,
895	fAccelerate2DVideo; // requires settings version 1.8 (VirtualBox 3.1)
896
897	uint32_t ulVideoCaptureHorzRes; // requires settings version 1.14 (VirtualBox 4.3)
898	uint32_t ulVideoCaptureVertRes; // requires settings version 1.14 (VirtualBox 4.3)
899	uint32_t ulVideoCaptureRate; // requires settings version 1.14 (VirtualBox 4.3)
900	uint32_t ulVideoCaptureFPS; // requires settings version 1.14 (VirtualBox 4.3)
901	bool fVideoCaptureEnabled; // requires settings version 1.14 (VirtualBox 4.3)
902	uint64_t u64VideoCaptureScreens; // requires settings version 1.14 (VirtualBox 4.3)
903	com::Utf8Str strVideoCaptureFile; // requires settings version 1.14 (VirtualBox 4.3)
904
905	FirmwareType_T firmwareType; // requires settings version 1.9 (VirtualBox 3.1)
906
907	PointingHIDType_T pointingHIDType; // requires settings version 1.10 (VirtualBox 3.2)
908	KeyboardHIDType_T keyboardHIDType; // requires settings version 1.10 (VirtualBox 3.2)
909
910	ChipsetType_T chipsetType; // requires settings version 1.11 (VirtualBox 4.0)
911
912	bool fEmulatedUSBWebcam; // 1.13 (VirtualBox 4.2)
913	bool fEmulatedUSBCardReader; // 1.12 (VirtualBox 4.1)
914
915	VRDESettings vrdeSettings;
916
917	BIOSSettings biosSettings;
918	USB usbSettings;
919	NetworkAdaptersList llNetworkAdapters;
920	SerialPortsList llSerialPorts;
921	ParallelPortsList llParallelPorts;
922	AudioAdapter audioAdapter;
923
924	// technically these two have no business in the hardware section, but for some
925	// clever reason <Hardware> is where they are in the XML....
926	SharedFoldersList llSharedFolders;
927	ClipboardMode_T clipboardMode;
928	DragAndDropMode_T dragAndDropMode;
929
930	uint32_t ulMemoryBalloonSize;
931	bool fPageFusionEnabled;
932
933	GuestPropertiesList llGuestProperties;
934	com::Utf8Str strNotificationPatterns;
935
936	IOSettings ioSettings; // requires settings version 1.10 (VirtualBox 3.2)
937	HostPCIDeviceAttachmentList pciAttachments; // requires settings version 1.12 (VirtualBox 4.1)
938
939	com::Utf8Str strDefaultFrontend; // requires settings version 1.14 (VirtualBox 4.3)
940	};
941
942	/**
943	* A device attached to a storage controller. This can either be a
944	* hard disk or a DVD drive or a floppy drive and also specifies
945	* which medium is "in" the drive; as a result, this is a combination
946	* of the Main IMedium and IMediumAttachment interfaces.
947	*
948	* NOTE: If you add any fields in here, you must update a) the constructor and b)
949	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
950	* your settings might never get saved.
951	*/
952	struct AttachedDevice
953	{
954	AttachedDevice()
955	: deviceType(DeviceType_Null),
956	fPassThrough(false),
957	fTempEject(false),
958	fNonRotational(false),
959	lPort(0),
960	lDevice(0)
961	{}
962
963	bool operator==(const AttachedDevice &a) const;
964
965	DeviceType_T deviceType; // only HardDisk, DVD or Floppy are allowed
966
967	// DVDs can be in pass-through mode:
968	bool fPassThrough;
969
970	// Whether guest-triggered eject of DVDs will keep the medium in the
971	// VM config or not:
972	bool fTempEject;
973
974	// Whether the medium is non-rotational:
975	bool fNonRotational;
976
977	// Whether the medium supports discarding unused blocks:
978	bool fDiscard;
979
980	int32_t lPort;
981	int32_t lDevice;
982
983	// if an image file is attached to the device (ISO, RAW, or hard disk image such as VDI),
984	// this is its UUID; it depends on deviceType which media registry this then needs to
985	// be looked up in. If no image file (only permitted for DVDs and floppies), then the UUID is NULL
986	com::Guid uuid;
987
988	// for DVDs and floppies, the attachment can also be a host device:
989	com::Utf8Str strHostDriveSrc; // if != NULL, value of <HostDrive>/@src
990
991	// Bandwidth group the device is attached to.
992	com::Utf8Str strBwGroup;
993	};
994	typedef std::list<AttachedDevice> AttachedDevicesList;
995
996	/**
997	* NOTE: If you add any fields in here, you must update a) the constructor and b)
998	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
999	* your settings might never get saved.
1000	*/
1001	struct StorageController
1002	{
1003	StorageController()
1004	: storageBus(StorageBus_IDE),
1005	controllerType(StorageControllerType_PIIX3),
1006	ulPortCount(2),
1007	ulInstance(0),
1008	fUseHostIOCache(true),
1009	fBootable(true),
1010	lIDE0MasterEmulationPort(0),
1011	lIDE0SlaveEmulationPort(0),
1012	lIDE1MasterEmulationPort(0),
1013	lIDE1SlaveEmulationPort(0)
1014	{}
1015
1016	bool operator==(const StorageController &s) const;
1017
1018	com::Utf8Str strName;
1019	StorageBus_T storageBus; // _SATA, _SCSI, _IDE, _SAS
1020	StorageControllerType_T controllerType;
1021	uint32_t ulPortCount;
1022	uint32_t ulInstance;
1023	bool fUseHostIOCache;
1024	bool fBootable;
1025
1026	// only for when controllerType == StorageControllerType_IntelAhci:
1027	int32_t lIDE0MasterEmulationPort,
1028	lIDE0SlaveEmulationPort,
1029	lIDE1MasterEmulationPort,
1030	lIDE1SlaveEmulationPort;
1031
1032	AttachedDevicesList llAttachedDevices;
1033	};
1034	typedef std::list<StorageController> StorageControllersList;
1035
1036	/**
1037	* We wrap the storage controllers list into an extra struct so we can
1038	* use an undefined struct without needing std::list<> in all the headers.
1039	*
1040	* NOTE: If you add any fields in here, you must update a) the constructor and b)
1041	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
1042	* your settings might never get saved.
1043	*/
1044	struct Storage
1045	{
1046	bool operator==(const Storage &s) const;
1047
1048	StorageControllersList llStorageControllers;
1049	};
1050
1051	/**
1052	* Settings that has to do with debugging.
1053	*/
1054	struct Debugging
1055	{
1056	Debugging()
1057	: fTracingEnabled(false),
1058	fAllowTracingToAccessVM(false),
1059	strTracingConfig()
1060	{ }
1061
1062	bool operator==(const Debugging &rOther) const
1063	{
1064	return fTracingEnabled == rOther.fTracingEnabled
1065	&& fAllowTracingToAccessVM == rOther.fAllowTracingToAccessVM
1066	&& strTracingConfig == rOther.strTracingConfig;
1067	}
1068
1069	bool areDefaultSettings() const
1070	{
1071	return !fTracingEnabled
1072	&& !fAllowTracingToAccessVM
1073	&& strTracingConfig.isEmpty();
1074	}
1075
1076	bool fTracingEnabled;
1077	bool fAllowTracingToAccessVM;
1078	com::Utf8Str strTracingConfig;
1079	};
1080
1081	/**
1082	* Settings that has to do with autostart.
1083	*/
1084	struct Autostart
1085	{
1086	Autostart()
1087	: fAutostartEnabled(false),
1088	uAutostartDelay(0),
1089	enmAutostopType(AutostopType_Disabled)
1090	{ }
1091
1092	bool operator==(const Autostart &rOther) const
1093	{
1094	return fAutostartEnabled == rOther.fAutostartEnabled
1095	&& uAutostartDelay == rOther.uAutostartDelay
1096	&& enmAutostopType == rOther.enmAutostopType;
1097	}
1098
1099	bool areDefaultSettings() const
1100	{
1101	return !fAutostartEnabled
1102	&& !uAutostartDelay
1103	&& enmAutostopType == AutostopType_Disabled;
1104	}
1105
1106	bool fAutostartEnabled;
1107	uint32_t uAutostartDelay;
1108	AutostopType_T enmAutostopType;
1109	};
1110
1111	struct Snapshot;
1112	typedef std::list<Snapshot> SnapshotsList;
1113
1114	/**
1115	* NOTE: If you add any fields in here, you must update a) the constructor and b)
1116	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
1117	* your settings might never get saved.
1118	*/
1119	struct Snapshot
1120	{
1121	bool operator==(const Snapshot &s) const;
1122
1123	com::Guid uuid;
1124	com::Utf8Str strName,
1125	strDescription; // optional
1126	RTTIMESPEC timestamp;
1127
1128	com::Utf8Str strStateFile; // for online snapshots only
1129
1130	Hardware hardware;
1131	Storage storage;
1132
1133	Debugging debugging;
1134	Autostart autostart;
1135
1136	SnapshotsList llChildSnapshots;
1137	};
1138
1139	struct MachineUserData
1140	{
1141	MachineUserData()
1142	: fDirectoryIncludesUUID(false),
1143	fNameSync(true),
1144	fTeleporterEnabled(false),
1145	uTeleporterPort(0),
1146	enmFaultToleranceState(FaultToleranceState_Inactive),
1147	uFaultTolerancePort(0),
1148	uFaultToleranceInterval(0),
1149	fRTCUseUTC(false)
1150	{
1151	llGroups.push_back("/");
1152	}
1153
1154	bool operator==(const MachineUserData &c) const
1155	{
1156	return (strName == c.strName)
1157	&& (fDirectoryIncludesUUID == c.fDirectoryIncludesUUID)
1158	&& (fNameSync == c.fNameSync)
1159	&& (strDescription == c.strDescription)
1160	&& (llGroups == c.llGroups)
1161	&& (strOsType == c.strOsType)
1162	&& (strSnapshotFolder == c.strSnapshotFolder)
1163	&& (fTeleporterEnabled == c.fTeleporterEnabled)
1164	&& (uTeleporterPort == c.uTeleporterPort)
1165	&& (strTeleporterAddress == c.strTeleporterAddress)
1166	&& (strTeleporterPassword == c.strTeleporterPassword)
1167	&& (enmFaultToleranceState == c.enmFaultToleranceState)
1168	&& (uFaultTolerancePort == c.uFaultTolerancePort)
1169	&& (uFaultToleranceInterval == c.uFaultToleranceInterval)
1170	&& (strFaultToleranceAddress == c.strFaultToleranceAddress)
1171	&& (strFaultTolerancePassword == c.strFaultTolerancePassword)
1172	&& (fRTCUseUTC == c.fRTCUseUTC)
1173	&& (ovIcon == c.ovIcon);
1174	}
1175
1176	com::Utf8Str strName;
1177	bool fDirectoryIncludesUUID;
1178	bool fNameSync;
1179	com::Utf8Str strDescription;
1180	StringsList llGroups;
1181	com::Utf8Str strOsType;
1182	com::Utf8Str strSnapshotFolder;
1183	bool fTeleporterEnabled;
1184	uint32_t uTeleporterPort;
1185	com::Utf8Str strTeleporterAddress;
1186	com::Utf8Str strTeleporterPassword;
1187	FaultToleranceState_T enmFaultToleranceState;
1188	uint32_t uFaultTolerancePort;
1189	com::Utf8Str strFaultToleranceAddress;
1190	com::Utf8Str strFaultTolerancePassword;
1191	uint32_t uFaultToleranceInterval;
1192	bool fRTCUseUTC;
1193	com::Utf8Str ovIcon;
1194	};
1195
1196	/**
1197	* MachineConfigFile represents an XML machine configuration. All the machine settings
1198	* that go out to the XML (or are read from it) are in here.
1199	*
1200	* NOTE: If you add any fields in here, you must update a) the constructor and b)
1201	* the operator== which is used by Machine::saveSettings(), or otherwise your settings
1202	* might never get saved.
1203	*/
1204	class MachineConfigFile : public ConfigFileBase
1205	{
1206	public:
1207	com::Guid uuid;
1208
1209	MachineUserData machineUserData;
1210
1211	com::Utf8Str strStateFile;
1212	bool fCurrentStateModified; // optional, default is true
1213	RTTIMESPEC timeLastStateChange; // optional, defaults to now
1214	bool fAborted; // optional, default is false
1215
1216	com::Guid uuidCurrentSnapshot;
1217
1218	Hardware hardwareMachine;
1219	Storage storageMachine;
1220	MediaRegistry mediaRegistry;
1221	Debugging debugging;
1222	Autostart autostart;
1223
1224	StringsMap mapExtraDataItems;
1225
1226	SnapshotsList llFirstSnapshot; // first snapshot or empty list if there's none
1227
1228	MachineConfigFile(const com::Utf8Str *pstrFilename);
1229
1230	bool operator==(const MachineConfigFile &m) const;
1231
1232	bool canHaveOwnMediaRegistry() const;
1233
1234	void importMachineXML(const xml::ElementNode &elmMachine);
1235
1236	void write(const com::Utf8Str &strFilename);
1237
1238	enum
1239	{
1240	BuildMachineXML_IncludeSnapshots = 0x01,
1241	BuildMachineXML_WriteVboxVersionAttribute = 0x02,
1242	BuildMachineXML_SkipRemovableMedia = 0x04,
1243	BuildMachineXML_MediaRegistry = 0x08,
1244	BuildMachineXML_SuppressSavedState = 0x10
1245	};
1246	void buildMachineXML(xml::ElementNode &elmMachine,
1247	uint32_t fl,
1248	std::list<xml::ElementNode> pllElementsWithUuidAttributes);
1249
1250	static bool isAudioDriverAllowedOnThisHost(AudioDriverType_T drv);
1251	static AudioDriverType_T getHostDefaultAudioDriver();
1252
1253	private:
1254	void readNetworkAdapters(const xml::ElementNode &elmHardware, NetworkAdaptersList &ll);
1255	void readAttachedNetworkMode(const xml::ElementNode &pelmMode, bool fEnabled, NetworkAdapter &nic);
1256	void readCpuIdTree(const xml::ElementNode &elmCpuid, CpuIdLeafsList &ll);
1257	void readCpuTree(const xml::ElementNode &elmCpu, CpuList &ll);
1258	void readSerialPorts(const xml::ElementNode &elmUART, SerialPortsList &ll);
1259	void readParallelPorts(const xml::ElementNode &elmLPT, ParallelPortsList &ll);
1260	void readAudioAdapter(const xml::ElementNode &elmAudioAdapter, AudioAdapter &aa);
1261	void readGuestProperties(const xml::ElementNode &elmGuestProperties, Hardware &hw);
1262	void readStorageControllerAttributes(const xml::ElementNode &elmStorageController, StorageController &sctl);
1263	void readHardware(const xml::ElementNode &elmHardware, Hardware &hw, Storage &strg);
1264	void readHardDiskAttachments_pre1_7(const xml::ElementNode &elmHardDiskAttachments, Storage &strg);
1265	void readStorageControllers(const xml::ElementNode &elmStorageControllers, Storage &strg);
1266	void readDVDAndFloppies_pre1_9(const xml::ElementNode &elmHardware, Storage &strg);
1267	void readTeleporter(const xml::ElementNode pElmTeleporter, MachineUserData pUserData);
1268	void readDebugging(const xml::ElementNode pElmDbg, Debugging pDbg);
1269	void readAutostart(const xml::ElementNode pElmAutostart, Autostart pAutostart);
1270	void readGroups(const xml::ElementNode elmGroups, StringsList pllGroups);
1271	void readSnapshot(uint32_t depth, const xml::ElementNode &elmSnapshot, Snapshot &snap);
1272	void convertOldOSType_pre1_5(com::Utf8Str &str);
1273	void readMachine(const xml::ElementNode &elmMachine);
1274
1275	void buildHardwareXML(xml::ElementNode &elmParent, const Hardware &hw, const Storage &strg);
1276	void buildNetworkXML(NetworkAttachmentType_T mode, xml::ElementNode &elmParent, bool fEnabled, const NetworkAdapter &nic);
1277	void buildStorageControllersXML(xml::ElementNode &elmParent,
1278	const Storage &st,
1279	bool fSkipRemovableMedia,
1280	std::list<xml::ElementNode> pllElementsWithUuidAttributes);
1281	void buildDebuggingXML(xml::ElementNode pElmParent, const Debugging pDbg);
1282	void buildAutostartXML(xml::ElementNode pElmParent, const Autostart pAutostart);
1283	void buildGroupsXML(xml::ElementNode pElmParent, const StringsList pllGroups);
1284	void buildSnapshotXML(uint32_t depth, xml::ElementNode &elmParent, const Snapshot &snap);
1285
1286	void bumpSettingsVersionIfNeeded();
1287	};
1288
1289	} // namespace settings
1290
1291
1292	#endif /* ___VBox_settings_h */

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/include/VBox/settings.h@ 48093

Download in other formats: