settings.h@ 53425

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

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

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

Download in other formats: