settings.h@ 48004

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

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

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

Download in other formats: