settings.h@ 54506

Last change on this file since 54506 was 54314, checked in by vboxsync, 10 years ago

Main/DHCPServerImpl: for DHCP options keep not just the text
representation, but also encoding of that text representation.

When XML settings are read, interpret old format, without explicit
"encoding" attribute, as legacy encoding where we are expected to know
the actual format of the option from the option code itself. When
writing legacy options, write them in old format.

This is in preparation for using "de:ad:be:ef" hex-encoded option
values for non-standard options which format we can't know a priory.

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

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

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

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

Download in other formats: