settings.h@ 42136

Last change on this file since 42136 was 42129, checked in by vboxsync, 13 years ago
Main/VirtualBox+Machine: add support for VM groups (incomplete, saving of settings is not implemented), remaining code adjusted accordingly, use better parameter checking macros, make XSLT generators process setter attributes using safearrays correctly, various cleanups and warning fixes Frontends/VBoxManage: first traces of groups support
Property svn:eol-style set to `native` Property svn:keywords set to `Date Revision Author Id`
File size: 37.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-2012 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	namespace xml
54	{
55	class ElementNode;
56	}
57
58	namespace settings
59	{
60
61	class ConfigFileError;
62
63	////////////////////////////////////////////////////////////////////////////////
64	//
65	// Structures shared between Machine XML and VirtualBox.xml
66	//
67	////////////////////////////////////////////////////////////////////////////////
68
69	/**
70	* USB device filter definition. This struct is used both in MainConfigFile
71	* (for global USB filters) and MachineConfigFile (for machine filters).
72	*
73	* NOTE: If you add any fields in here, you must update a) the constructor and b)
74	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
75	* your settings might never get saved.
76	*/
77	struct USBDeviceFilter
78	{
79	USBDeviceFilter()
80	: fActive(false),
81	action(USBDeviceFilterAction_Null),
82	ulMaskedInterfaces(0)
83	{}
84
85	bool operator==(const USBDeviceFilter&u) const;
86
87	com::Utf8Str strName;
88	bool fActive;
89	com::Utf8Str strVendorId,
90	strProductId,
91	strRevision,
92	strManufacturer,
93	strProduct,
94	strSerialNumber,
95	strPort;
96	USBDeviceFilterAction_T action; // only used with host USB filters
97	com::Utf8Str strRemote; // irrelevant for host USB objects
98	uint32_t ulMaskedInterfaces; // irrelevant for host USB objects
99	};
100
101	typedef std::map<com::Utf8Str, com::Utf8Str> StringsMap;
102	typedef std::list<com::Utf8Str> StringsList;
103
104	// ExtraDataItem (used by both VirtualBox.xml and machines XML)
105	struct USBDeviceFilter;
106	typedef std::list<USBDeviceFilter> USBDeviceFiltersList;
107
108	struct Medium;
109	typedef std::list<Medium> MediaList;
110
111	/**
112	* NOTE: If you add any fields in here, you must update a) the constructor and b)
113	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
114	* your settings might never get saved.
115	*/
116	struct Medium
117	{
118	Medium()
119	: fAutoReset(false),
120	hdType(MediumType_Normal)
121	{}
122
123	com::Guid uuid;
124	com::Utf8Str strLocation;
125	com::Utf8Str strDescription;
126
127	// the following are for hard disks only:
128	com::Utf8Str strFormat;
129	bool fAutoReset; // optional, only for diffs, default is false
130	StringsMap properties;
131	MediumType_T hdType;
132
133	MediaList llChildren; // only used with hard disks
134
135	bool operator==(const Medium &m) const;
136	};
137
138	/**
139	* A media registry. Starting with VirtualBox 3.3, this can appear in both the
140	* VirtualBox.xml file as well as machine XML files with settings version 1.11
141	* or higher, so these lists are now in ConfigFileBase.
142	*
143	* NOTE: If you add any fields in here, you must update a) the constructor and b)
144	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
145	* your settings might never get saved.
146	*/
147	struct MediaRegistry
148	{
149	MediaList llHardDisks,
150	llDvdImages,
151	llFloppyImages;
152
153	bool operator==(const MediaRegistry &m) const;
154	};
155
156	/**
157	* Common base class for both MainConfigFile and MachineConfigFile
158	* which contains some common logic for both.
159	*/
160	class ConfigFileBase
161	{
162	public:
163	bool fileExists();
164
165	void copyBaseFrom(const ConfigFileBase &b);
166
167	protected:
168	ConfigFileBase(const com::Utf8Str *pstrFilename);
169	/* Note: this copy constructor doesn't create a full copy of other, cause
170	* the file based stuff (xml doc) could not be copied. */
171	ConfigFileBase(const ConfigFileBase &other);
172
173	~ConfigFileBase();
174
175	void parseUUID(com::Guid &guid,
176	const com::Utf8Str &strUUID) const;
177	void parseTimestamp(RTTIMESPEC &timestamp,
178	const com::Utf8Str &str) const;
179
180	com::Utf8Str makeString(const RTTIMESPEC &tm);
181
182	void readExtraData(const xml::ElementNode &elmExtraData,
183	StringsMap &map);
184	void readUSBDeviceFilters(const xml::ElementNode &elmDeviceFilters,
185	USBDeviceFiltersList &ll);
186	typedef enum {Error, HardDisk, DVDImage, FloppyImage} MediaType;
187	void readMedium(MediaType t, const xml::ElementNode &elmMedium, MediaList &llMedia);
188	void readMediaRegistry(const xml::ElementNode &elmMediaRegistry, MediaRegistry &mr);
189
190	void setVersionAttribute(xml::ElementNode &elm);
191	void createStubDocument();
192
193	void buildExtraData(xml::ElementNode &elmParent, const StringsMap &me);
194	void buildUSBDeviceFilters(xml::ElementNode &elmParent,
195	const USBDeviceFiltersList &ll,
196	bool fHostMode);
197	void buildMedium(xml::ElementNode &elmMedium,
198	DeviceType_T devType,
199	const Medium &m,
200	uint32_t level);
201	void buildMediaRegistry(xml::ElementNode &elmParent,
202	const MediaRegistry &mr);
203	void clearDocument();
204
205	struct Data;
206	Data *m;
207
208	friend class ConfigFileError;
209	};
210
211	////////////////////////////////////////////////////////////////////////////////
212	//
213	// VirtualBox.xml structures
214	//
215	////////////////////////////////////////////////////////////////////////////////
216
217	struct Host
218	{
219	USBDeviceFiltersList llUSBDeviceFilters;
220	};
221
222	struct SystemProperties
223	{
224	SystemProperties()
225	: ulLogHistoryCount(3)
226	{}
227
228	com::Utf8Str strDefaultMachineFolder;
229	com::Utf8Str strDefaultHardDiskFolder;
230	com::Utf8Str strDefaultHardDiskFormat;
231	com::Utf8Str strVRDEAuthLibrary;
232	com::Utf8Str strWebServiceAuthLibrary;
233	com::Utf8Str strDefaultVRDEExtPack;
234	uint32_t ulLogHistoryCount;
235	};
236
237	struct MachineRegistryEntry
238	{
239	com::Guid uuid;
240	com::Utf8Str strSettingsFile;
241	};
242	typedef std::list<MachineRegistryEntry> MachinesRegistry;
243
244	struct DHCPServer
245	{
246	DHCPServer()
247	: fEnabled(false)
248	{}
249
250	com::Utf8Str strNetworkName,
251	strIPAddress,
252	strIPNetworkMask,
253	strIPLower,
254	strIPUpper;
255	bool fEnabled;
256	};
257	typedef std::list<DHCPServer> DHCPServersList;
258
259	class MainConfigFile : public ConfigFileBase
260	{
261	public:
262	MainConfigFile(const com::Utf8Str *pstrFilename);
263
264	void readMachineRegistry(const xml::ElementNode &elmMachineRegistry);
265	void readDHCPServers(const xml::ElementNode &elmDHCPServers);
266
267	void write(const com::Utf8Str strFilename);
268
269	Host host;
270	SystemProperties systemProperties;
271	MediaRegistry mediaRegistry;
272	MachinesRegistry llMachines;
273	DHCPServersList llDhcpServers;
274	StringsMap mapExtraDataItems;
275	};
276
277	////////////////////////////////////////////////////////////////////////////////
278	//
279	// Machine XML structures
280	//
281	////////////////////////////////////////////////////////////////////////////////
282
283	/**
284	* NOTE: If you add any fields in here, you must update a) the constructor and b)
285	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
286	* your settings might never get saved.
287	*/
288	struct VRDESettings
289	{
290	VRDESettings()
291	: fEnabled(true),
292	authType(AuthType_Null),
293	ulAuthTimeout(5000),
294	fAllowMultiConnection(false),
295	fReuseSingleConnection(false)
296	{}
297
298	bool operator==(const VRDESettings& v) const;
299
300	bool fEnabled;
301	AuthType_T authType;
302	uint32_t ulAuthTimeout;
303	com::Utf8Str strAuthLibrary;
304	bool fAllowMultiConnection,
305	fReuseSingleConnection;
306	com::Utf8Str strVrdeExtPack;
307	StringsMap mapProperties;
308	};
309
310	/**
311	* NOTE: If you add any fields in here, you must update a) the constructor and b)
312	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
313	* your settings might never get saved.
314	*/
315	struct BIOSSettings
316	{
317	BIOSSettings()
318	: fACPIEnabled(true),
319	fIOAPICEnabled(false),
320	fLogoFadeIn(true),
321	fLogoFadeOut(true),
322	ulLogoDisplayTime(0),
323	biosBootMenuMode(BIOSBootMenuMode_MessageAndMenu),
324	fPXEDebugEnabled(false),
325	llTimeOffset(0)
326	{}
327
328	bool operator==(const BIOSSettings &d) const;
329
330	bool fACPIEnabled,
331	fIOAPICEnabled,
332	fLogoFadeIn,
333	fLogoFadeOut;
334	uint32_t ulLogoDisplayTime;
335	com::Utf8Str strLogoImagePath;
336	BIOSBootMenuMode_T biosBootMenuMode;
337	bool fPXEDebugEnabled;
338	int64_t llTimeOffset;
339	};
340
341	/**
342	* NOTE: If you add any fields in here, you must update a) the constructor and b)
343	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
344	* your settings might never get saved.
345	*/
346	struct USBController
347	{
348	USBController()
349	: fEnabled(false),
350	fEnabledEHCI(false)
351	{}
352
353	bool operator==(const USBController &u) const;
354
355	bool fEnabled;
356	bool fEnabledEHCI;
357	USBDeviceFiltersList llDeviceFilters;
358	};
359
360	struct NATRule
361	{
362	NATRule()
363	: proto(NATProtocol_TCP),
364	u16HostPort(0),
365	u16GuestPort(0)
366	{}
367
368	bool operator==(const NATRule &r) const
369	{
370	return strName == r.strName
371	&& proto == r.proto
372	&& u16HostPort == r.u16HostPort
373	&& strHostIP == r.strHostIP
374	&& u16GuestPort == r.u16GuestPort
375	&& strGuestIP == r.strGuestIP;
376	}
377
378	com::Utf8Str strName;
379	NATProtocol_T proto;
380	uint16_t u16HostPort;
381	com::Utf8Str strHostIP;
382	uint16_t u16GuestPort;
383	com::Utf8Str strGuestIP;
384	};
385	typedef std::list<NATRule> NATRuleList;
386
387	struct NAT
388	{
389	NAT()
390	: u32Mtu(0),
391	u32SockRcv(0),
392	u32SockSnd(0),
393	u32TcpRcv(0),
394	u32TcpSnd(0),
395	fDnsPassDomain(true), /* historically this value is true */
396	fDnsProxy(false),
397	fDnsUseHostResolver(false),
398	fAliasLog(false),
399	fAliasProxyOnly(false),
400	fAliasUseSamePorts(false)
401	{}
402
403	bool operator==(const NAT &n) const
404	{
405	return strNetwork == n.strNetwork
406	&& strBindIP == n.strBindIP
407	&& u32Mtu == n.u32Mtu
408	&& u32SockRcv == n.u32SockRcv
409	&& u32SockSnd == n.u32SockSnd
410	&& u32TcpSnd == n.u32TcpSnd
411	&& u32TcpRcv == n.u32TcpRcv
412	&& strTftpPrefix == n.strTftpPrefix
413	&& strTftpBootFile == n.strTftpBootFile
414	&& strTftpNextServer == n.strTftpNextServer
415	&& fDnsPassDomain == n.fDnsPassDomain
416	&& fDnsProxy == n.fDnsProxy
417	&& fDnsUseHostResolver == n.fDnsUseHostResolver
418	&& fAliasLog == n.fAliasLog
419	&& fAliasProxyOnly == n.fAliasProxyOnly
420	&& fAliasUseSamePorts == n.fAliasUseSamePorts
421	&& llRules == n.llRules;
422	}
423
424	com::Utf8Str strNetwork;
425	com::Utf8Str strBindIP;
426	uint32_t u32Mtu;
427	uint32_t u32SockRcv;
428	uint32_t u32SockSnd;
429	uint32_t u32TcpRcv;
430	uint32_t u32TcpSnd;
431	com::Utf8Str strTftpPrefix;
432	com::Utf8Str strTftpBootFile;
433	com::Utf8Str strTftpNextServer;
434	bool fDnsPassDomain;
435	bool fDnsProxy;
436	bool fDnsUseHostResolver;
437	bool fAliasLog;
438	bool fAliasProxyOnly;
439	bool fAliasUseSamePorts;
440	NATRuleList llRules;
441	};
442	/**
443	* NOTE: If you add any fields in here, you must update a) the constructor and b)
444	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
445	* your settings might never get saved.
446	*/
447	struct NetworkAdapter
448	{
449	NetworkAdapter()
450	: ulSlot(0),
451	type(NetworkAdapterType_Am79C970A),
452	fEnabled(false),
453	fCableConnected(false),
454	ulLineSpeed(0),
455	enmPromiscModePolicy(NetworkAdapterPromiscModePolicy_Deny),
456	fTraceEnabled(false),
457	mode(NetworkAttachmentType_Null),
458	ulBootPriority(0)
459	{}
460
461	bool operator==(const NetworkAdapter &n) const;
462
463	uint32_t ulSlot;
464
465	NetworkAdapterType_T type;
466	bool fEnabled;
467	com::Utf8Str strMACAddress;
468	bool fCableConnected;
469	uint32_t ulLineSpeed;
470	NetworkAdapterPromiscModePolicy_T enmPromiscModePolicy;
471	bool fTraceEnabled;
472	com::Utf8Str strTraceFile;
473
474	NetworkAttachmentType_T mode;
475	NAT nat;
476	com::Utf8Str strBridgedName;
477	com::Utf8Str strHostOnlyName;
478	com::Utf8Str strInternalNetworkName;
479	com::Utf8Str strGenericDriver;
480	StringsMap genericProperties;
481	uint32_t ulBootPriority;
482	com::Utf8Str strBandwidthGroup; // requires settings version 1.13 (VirtualBox 4.2)
483	};
484	typedef std::list<NetworkAdapter> NetworkAdaptersList;
485
486	/**
487	* NOTE: If you add any fields in here, you must update a) the constructor and b)
488	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
489	* your settings might never get saved.
490	*/
491	struct SerialPort
492	{
493	SerialPort()
494	: ulSlot(0),
495	fEnabled(false),
496	ulIOBase(0x3f8),
497	ulIRQ(4),
498	portMode(PortMode_Disconnected),
499	fServer(false)
500	{}
501
502	bool operator==(const SerialPort &n) const;
503
504	uint32_t ulSlot;
505
506	bool fEnabled;
507	uint32_t ulIOBase;
508	uint32_t ulIRQ;
509	PortMode_T portMode;
510	com::Utf8Str strPath;
511	bool fServer;
512	};
513	typedef std::list<SerialPort> SerialPortsList;
514
515	/**
516	* NOTE: If you add any fields in here, you must update a) the constructor and b)
517	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
518	* your settings might never get saved.
519	*/
520	struct ParallelPort
521	{
522	ParallelPort()
523	: ulSlot(0),
524	fEnabled(false),
525	ulIOBase(0x378),
526	ulIRQ(7)
527	{}
528
529	bool operator==(const ParallelPort &d) const;
530
531	uint32_t ulSlot;
532
533	bool fEnabled;
534	uint32_t ulIOBase;
535	uint32_t ulIRQ;
536	com::Utf8Str strPath;
537	};
538	typedef std::list<ParallelPort> ParallelPortsList;
539
540	/**
541	* NOTE: If you add any fields in here, you must update a) the constructor and b)
542	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
543	* your settings might never get saved.
544	*/
545	struct AudioAdapter
546	{
547	AudioAdapter()
548	: fEnabled(true),
549	controllerType(AudioControllerType_AC97),
550	driverType(AudioDriverType_Null)
551	{}
552
553	bool operator==(const AudioAdapter &a) const
554	{
555	return (this == &a)
556	\|\| ( (fEnabled == a.fEnabled)
557	&& (controllerType == a.controllerType)
558	&& (driverType == a.driverType)
559	);
560	}
561
562	bool fEnabled;
563	AudioControllerType_T controllerType;
564	AudioDriverType_T driverType;
565	};
566
567	/**
568	* NOTE: If you add any fields in here, you must update a) the constructor and b)
569	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
570	* your settings might never get saved.
571	*/
572	struct SharedFolder
573	{
574	SharedFolder()
575	: fWritable(false)
576	, fAutoMount(false)
577	{}
578
579	bool operator==(const SharedFolder &a) const;
580
581	com::Utf8Str strName,
582	strHostPath;
583	bool fWritable;
584	bool fAutoMount;
585	};
586	typedef std::list<SharedFolder> SharedFoldersList;
587
588	/**
589	* NOTE: If you add any fields in here, you must update a) the constructor and b)
590	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
591	* your settings might never get saved.
592	*/
593	struct GuestProperty
594	{
595	GuestProperty()
596	: timestamp(0)
597	{};
598
599	bool operator==(const GuestProperty &g) const;
600
601	com::Utf8Str strName,
602	strValue;
603	uint64_t timestamp;
604	com::Utf8Str strFlags;
605	};
606	typedef std::list<GuestProperty> GuestPropertiesList;
607
608	typedef std::map<uint32_t, DeviceType_T> BootOrderMap;
609
610	/**
611	* NOTE: If you add any fields in here, you must update a) the constructor and b)
612	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
613	* your settings might never get saved.
614	*/
615	struct CpuIdLeaf
616	{
617	CpuIdLeaf()
618	: ulId(UINT32_MAX),
619	ulEax(0),
620	ulEbx(0),
621	ulEcx(0),
622	ulEdx(0)
623	{}
624
625	bool operator==(const CpuIdLeaf &c) const
626	{
627	return ( (this == &c)
628	\|\| ( (ulId == c.ulId)
629	&& (ulEax == c.ulEax)
630	&& (ulEbx == c.ulEbx)
631	&& (ulEcx == c.ulEcx)
632	&& (ulEdx == c.ulEdx)
633	)
634	);
635	}
636
637	uint32_t ulId;
638	uint32_t ulEax;
639	uint32_t ulEbx;
640	uint32_t ulEcx;
641	uint32_t ulEdx;
642	};
643	typedef std::list<CpuIdLeaf> CpuIdLeafsList;
644
645	/**
646	* NOTE: If you add any fields in here, you must update a) the constructor and b)
647	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
648	* your settings might never get saved.
649	*/
650	struct Cpu
651	{
652	Cpu()
653	: ulId(UINT32_MAX)
654	{}
655
656	bool operator==(const Cpu &c) const
657	{
658	return (ulId == c.ulId);
659	}
660
661	uint32_t ulId;
662	};
663	typedef std::list<Cpu> CpuList;
664
665	/**
666	* NOTE: If you add any fields in here, you must update a) the constructor and b)
667	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
668	* your settings might never get saved.
669	*/
670	struct BandwidthGroup
671	{
672	BandwidthGroup()
673	: cMaxBytesPerSec(0),
674	enmType(BandwidthGroupType_Null)
675	{}
676
677	bool operator==(const BandwidthGroup &i) const
678	{
679	return ( (strName == i.strName)
680	&& (cMaxBytesPerSec == i.cMaxBytesPerSec)
681	&& (enmType == i.enmType));
682	}
683
684	com::Utf8Str strName;
685	uint64_t cMaxBytesPerSec;
686	BandwidthGroupType_T enmType;
687	};
688	typedef std::list<BandwidthGroup> BandwidthGroupList;
689
690	/**
691	* NOTE: If you add any fields in here, you must update a) the constructor and b)
692	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
693	* your settings might never get saved.
694	*/
695	struct IoSettings
696	{
697	IoSettings();
698
699	bool operator==(const IoSettings &i) const
700	{
701	return ( (fIoCacheEnabled == i.fIoCacheEnabled)
702	&& (ulIoCacheSize == i.ulIoCacheSize)
703	&& (llBandwidthGroups == i.llBandwidthGroups));
704	}
705
706	bool fIoCacheEnabled;
707	uint32_t ulIoCacheSize;
708	BandwidthGroupList llBandwidthGroups;
709	};
710
711	/**
712	* NOTE: If you add any fields in here, you must update a) the constructor and b)
713	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
714	* your settings might never get saved.
715	*/
716	struct HostPciDeviceAttachment
717	{
718	HostPciDeviceAttachment()
719	: uHostAddress(0),
720	uGuestAddress(0)
721	{}
722
723	bool operator==(const HostPciDeviceAttachment &a) const
724	{
725	return ( (uHostAddress == a.uHostAddress)
726	&& (uGuestAddress == a.uGuestAddress)
727	&& (strDeviceName == a.strDeviceName)
728	);
729	}
730
731	com::Utf8Str strDeviceName;
732	uint32_t uHostAddress;
733	uint32_t uGuestAddress;
734	};
735	typedef std::list<HostPciDeviceAttachment> HostPciDeviceAttachmentList;
736
737	/**
738	* Representation of Machine hardware; this is used in the MachineConfigFile.hardwareMachine
739	* field.
740	*
741	* NOTE: If you add any fields in here, you must update a) the constructor and b)
742	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
743	* your settings might never get saved.
744	*/
745	struct Hardware
746	{
747	Hardware();
748
749	bool operator==(const Hardware&) const;
750
751	com::Utf8Str strVersion; // hardware version, optional
752	com::Guid uuid; // hardware uuid, optional (null).
753
754	bool fHardwareVirt,
755	fHardwareVirtExclusive,
756	fNestedPaging,
757	fLargePages,
758	fVPID,
759	fHardwareVirtForce,
760	fSyntheticCpu,
761	fPAE;
762	uint32_t cCPUs;
763	bool fCpuHotPlug; // requires settings version 1.10 (VirtualBox 3.2)
764	CpuList llCpus; // requires settings version 1.10 (VirtualBox 3.2)
765	bool fHpetEnabled; // requires settings version 1.10 (VirtualBox 3.2)
766	uint32_t ulCpuExecutionCap; // requires settings version 1.11 (VirtualBox 3.3)
767
768	CpuIdLeafsList llCpuIdLeafs;
769
770	uint32_t ulMemorySizeMB;
771
772	BootOrderMap mapBootOrder; // item 0 has highest priority
773
774	uint32_t ulVRAMSizeMB;
775	uint32_t cMonitors;
776	bool fAccelerate3D,
777	fAccelerate2DVideo; // requires settings version 1.8 (VirtualBox 3.1)
778	FirmwareType_T firmwareType; // requires settings version 1.9 (VirtualBox 3.1)
779
780	PointingHidType_T pointingHidType; // requires settings version 1.10 (VirtualBox 3.2)
781	KeyboardHidType_T keyboardHidType; // requires settings version 1.10 (VirtualBox 3.2)
782
783	ChipsetType_T chipsetType; // requires settings version 1.11 (VirtualBox 4.0)
784
785	bool fEmulatedUSBCardReader; // 1.12 (VirtualBox 4.1)
786
787	VRDESettings vrdeSettings;
788
789	BIOSSettings biosSettings;
790	USBController usbController;
791	NetworkAdaptersList llNetworkAdapters;
792	SerialPortsList llSerialPorts;
793	ParallelPortsList llParallelPorts;
794	AudioAdapter audioAdapter;
795
796	// technically these two have no business in the hardware section, but for some
797	// clever reason <Hardware> is where they are in the XML....
798	SharedFoldersList llSharedFolders;
799	ClipboardMode_T clipboardMode;
800
801	uint32_t ulMemoryBalloonSize;
802	bool fPageFusionEnabled;
803
804	GuestPropertiesList llGuestProperties;
805	com::Utf8Str strNotificationPatterns;
806
807	IoSettings ioSettings; // requires settings version 1.10 (VirtualBox 3.2)
808	HostPciDeviceAttachmentList pciAttachments; // requires settings version 1.12 (VirtualBox 4.1)
809	};
810
811	/**
812	* A device attached to a storage controller. This can either be a
813	* hard disk or a DVD drive or a floppy drive and also specifies
814	* which medium is "in" the drive; as a result, this is a combination
815	* of the Main IMedium and IMediumAttachment interfaces.
816	*
817	* NOTE: If you add any fields in here, you must update a) the constructor and b)
818	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
819	* your settings might never get saved.
820	*/
821	struct AttachedDevice
822	{
823	AttachedDevice()
824	: deviceType(DeviceType_Null),
825	fPassThrough(false),
826	fTempEject(false),
827	fNonRotational(false),
828	lPort(0),
829	lDevice(0)
830	{}
831
832	bool operator==(const AttachedDevice &a) const;
833
834	DeviceType_T deviceType; // only HardDisk, DVD or Floppy are allowed
835
836	// DVDs can be in pass-through mode:
837	bool fPassThrough;
838
839	// Whether guest-triggered eject of DVDs will keep the medium in the
840	// VM config or not:
841	bool fTempEject;
842
843	// Whether the medium is non-rotational:
844	bool fNonRotational;
845
846	// Whether the medium supports discarding unused blocks:
847	bool fDiscard;
848
849	int32_t lPort;
850	int32_t lDevice;
851
852	// if an image file is attached to the device (ISO, RAW, or hard disk image such as VDI),
853	// this is its UUID; it depends on deviceType which media registry this then needs to
854	// be looked up in. If no image file (only permitted for DVDs and floppies), then the UUID is NULL
855	com::Guid uuid;
856
857	// for DVDs and floppies, the attachment can also be a host device:
858	com::Utf8Str strHostDriveSrc; // if != NULL, value of <HostDrive>/@src
859
860	// Bandwidth group the device is attached to.
861	com::Utf8Str strBwGroup;
862	};
863	typedef std::list<AttachedDevice> AttachedDevicesList;
864
865	/**
866	* NOTE: If you add any fields in here, you must update a) the constructor and b)
867	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
868	* your settings might never get saved.
869	*/
870	struct StorageController
871	{
872	StorageController()
873	: storageBus(StorageBus_IDE),
874	controllerType(StorageControllerType_PIIX3),
875	ulPortCount(2),
876	ulInstance(0),
877	fUseHostIOCache(true),
878	fBootable(true),
879	lIDE0MasterEmulationPort(0),
880	lIDE0SlaveEmulationPort(0),
881	lIDE1MasterEmulationPort(0),
882	lIDE1SlaveEmulationPort(0)
883	{}
884
885	bool operator==(const StorageController &s) const;
886
887	com::Utf8Str strName;
888	StorageBus_T storageBus; // _SATA, _SCSI, _IDE, _SAS
889	StorageControllerType_T controllerType;
890	uint32_t ulPortCount;
891	uint32_t ulInstance;
892	bool fUseHostIOCache;
893	bool fBootable;
894
895	// only for when controllerType == StorageControllerType_IntelAhci:
896	int32_t lIDE0MasterEmulationPort,
897	lIDE0SlaveEmulationPort,
898	lIDE1MasterEmulationPort,
899	lIDE1SlaveEmulationPort;
900
901	AttachedDevicesList llAttachedDevices;
902	};
903	typedef std::list<StorageController> StorageControllersList;
904
905	/**
906	* We wrap the storage controllers list into an extra struct so we can
907	* use an undefined struct without needing std::list<> in all the headers.
908	*
909	* NOTE: If you add any fields in here, you must update a) the constructor and b)
910	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
911	* your settings might never get saved.
912	*/
913	struct Storage
914	{
915	bool operator==(const Storage &s) const;
916
917	StorageControllersList llStorageControllers;
918	};
919
920	/**
921	* Settings that has to do with debugging.
922	*/
923	struct Debugging
924	{
925	Debugging()
926	: fTracingEnabled(false),
927	fAllowTracingToAccessVM(false),
928	strTracingConfig()
929	{ }
930
931	bool operator==(const Debugging &rOther) const
932	{
933	return fTracingEnabled == rOther.fTracingEnabled
934	&& fAllowTracingToAccessVM == rOther.fAllowTracingToAccessVM
935	&& strTracingConfig == rOther.strTracingConfig;
936	}
937
938	bool areDefaultSettings() const
939	{
940	return !fTracingEnabled
941	&& !fAllowTracingToAccessVM
942	&& strTracingConfig.isEmpty();
943	}
944
945	bool fTracingEnabled;
946	bool fAllowTracingToAccessVM;
947	com::Utf8Str strTracingConfig;
948	};
949
950	/**
951	* Settings that has to do with autostart.
952	*/
953	struct Autostart
954	{
955	Autostart()
956	: fAutostartEnabled(false),
957	uAutostartDelay(0),
958	enmAutostopType(AutostopType_Disabled)
959	{ }
960
961	bool operator==(const Autostart &rOther) const
962	{
963	return fAutostartEnabled == rOther.fAutostartEnabled
964	&& uAutostartDelay == rOther.uAutostartDelay
965	&& enmAutostopType == rOther.enmAutostopType;
966	}
967
968	bool areDefaultSettings() const
969	{
970	return !fAutostartEnabled
971	&& !uAutostartDelay
972	&& enmAutostopType == AutostopType_Disabled;
973	}
974
975	bool fAutostartEnabled;
976	uint32_t uAutostartDelay;
977	AutostopType_T enmAutostopType;
978	};
979
980	struct Snapshot;
981	typedef std::list<Snapshot> SnapshotsList;
982
983	/**
984	* NOTE: If you add any fields in here, you must update a) the constructor and b)
985	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
986	* your settings might never get saved.
987	*/
988	struct Snapshot
989	{
990	bool operator==(const Snapshot &s) const;
991
992	com::Guid uuid;
993	com::Utf8Str strName,
994	strDescription; // optional
995	RTTIMESPEC timestamp;
996
997	com::Utf8Str strStateFile; // for online snapshots only
998
999	Hardware hardware;
1000	Storage storage;
1001
1002	Debugging debugging;
1003	Autostart autostart;
1004
1005	SnapshotsList llChildSnapshots;
1006	};
1007
1008	struct MachineUserData
1009	{
1010	MachineUserData()
1011	: fNameSync(true),
1012	fTeleporterEnabled(false),
1013	uTeleporterPort(0),
1014	enmFaultToleranceState(FaultToleranceState_Inactive),
1015	uFaultTolerancePort(0),
1016	uFaultToleranceInterval(0),
1017	fRTCUseUTC(false)
1018	{
1019	llGroups.push_back("/");
1020	}
1021
1022	bool operator==(const MachineUserData &c) const
1023	{
1024	return (strName == c.strName)
1025	&& (fNameSync == c.fNameSync)
1026	&& (strDescription == c.strDescription)
1027	&& (strOsType == c.strOsType)
1028	&& (strSnapshotFolder == c.strSnapshotFolder)
1029	&& (fTeleporterEnabled == c.fTeleporterEnabled)
1030	&& (uTeleporterPort == c.uTeleporterPort)
1031	&& (strTeleporterAddress == c.strTeleporterAddress)
1032	&& (strTeleporterPassword == c.strTeleporterPassword)
1033	&& (enmFaultToleranceState == c.enmFaultToleranceState)
1034	&& (uFaultTolerancePort == c.uFaultTolerancePort)
1035	&& (uFaultToleranceInterval == c.uFaultToleranceInterval)
1036	&& (strFaultToleranceAddress == c.strFaultToleranceAddress)
1037	&& (strFaultTolerancePassword == c.strFaultTolerancePassword)
1038	&& (fRTCUseUTC == c.fRTCUseUTC);
1039	}
1040
1041	com::Utf8Str strName;
1042	bool fNameSync;
1043	com::Utf8Str strDescription;
1044	StringsList llGroups;
1045	com::Utf8Str strOsType;
1046	com::Utf8Str strSnapshotFolder;
1047	bool fTeleporterEnabled;
1048	uint32_t uTeleporterPort;
1049	com::Utf8Str strTeleporterAddress;
1050	com::Utf8Str strTeleporterPassword;
1051	FaultToleranceState_T enmFaultToleranceState;
1052	uint32_t uFaultTolerancePort;
1053	com::Utf8Str strFaultToleranceAddress;
1054	com::Utf8Str strFaultTolerancePassword;
1055	uint32_t uFaultToleranceInterval;
1056	bool fRTCUseUTC;
1057	};
1058
1059	/**
1060	* MachineConfigFile represents an XML machine configuration. All the machine settings
1061	* that go out to the XML (or are read from it) are in here.
1062	*
1063	* NOTE: If you add any fields in here, you must update a) the constructor and b)
1064	* the operator== which is used by Machine::saveSettings(), or otherwise your settings
1065	* might never get saved.
1066	*/
1067	class MachineConfigFile : public ConfigFileBase
1068	{
1069	public:
1070	com::Guid uuid;
1071
1072	MachineUserData machineUserData;
1073
1074	com::Utf8Str strStateFile;
1075	bool fCurrentStateModified; // optional, default is true
1076	RTTIMESPEC timeLastStateChange; // optional, defaults to now
1077	bool fAborted; // optional, default is false
1078
1079	com::Guid uuidCurrentSnapshot;
1080
1081	Hardware hardwareMachine;
1082	Storage storageMachine;
1083	MediaRegistry mediaRegistry;
1084	Debugging debugging;
1085	Autostart autostart;
1086
1087	StringsMap mapExtraDataItems;
1088
1089	SnapshotsList llFirstSnapshot; // first snapshot or empty list if there's none
1090
1091	MachineConfigFile(const com::Utf8Str *pstrFilename);
1092
1093	bool operator==(const MachineConfigFile &m) const;
1094
1095	bool canHaveOwnMediaRegistry() const;
1096
1097	void importMachineXML(const xml::ElementNode &elmMachine);
1098
1099	void write(const com::Utf8Str &strFilename);
1100
1101	enum
1102	{
1103	BuildMachineXML_IncludeSnapshots = 0x01,
1104	BuildMachineXML_WriteVboxVersionAttribute = 0x02,
1105	BuildMachineXML_SkipRemovableMedia = 0x04,
1106	BuildMachineXML_MediaRegistry = 0x08,
1107	BuildMachineXML_SuppressSavedState = 0x10
1108	};
1109	void buildMachineXML(xml::ElementNode &elmMachine,
1110	uint32_t fl,
1111	std::list<xml::ElementNode> pllElementsWithUuidAttributes);
1112
1113	static bool isAudioDriverAllowedOnThisHost(AudioDriverType_T drv);
1114	static AudioDriverType_T getHostDefaultAudioDriver();
1115
1116	private:
1117	void readNetworkAdapters(const xml::ElementNode &elmHardware, NetworkAdaptersList &ll);
1118	void readAttachedNetworkMode(const xml::ElementNode &pelmMode, bool fEnabled, NetworkAdapter &nic);
1119	void readCpuIdTree(const xml::ElementNode &elmCpuid, CpuIdLeafsList &ll);
1120	void readCpuTree(const xml::ElementNode &elmCpu, CpuList &ll);
1121	void readSerialPorts(const xml::ElementNode &elmUART, SerialPortsList &ll);
1122	void readParallelPorts(const xml::ElementNode &elmLPT, ParallelPortsList &ll);
1123	void readAudioAdapter(const xml::ElementNode &elmAudioAdapter, AudioAdapter &aa);
1124	void readGuestProperties(const xml::ElementNode &elmGuestProperties, Hardware &hw);
1125	void readStorageControllerAttributes(const xml::ElementNode &elmStorageController, StorageController &sctl);
1126	void readHardware(const xml::ElementNode &elmHardware, Hardware &hw, Storage &strg);
1127	void readHardDiskAttachments_pre1_7(const xml::ElementNode &elmHardDiskAttachments, Storage &strg);
1128	void readStorageControllers(const xml::ElementNode &elmStorageControllers, Storage &strg);
1129	void readDVDAndFloppies_pre1_9(const xml::ElementNode &elmHardware, Storage &strg);
1130	void readTeleporter(const xml::ElementNode pElmTeleporter, MachineUserData pUserData);
1131	void readDebugging(const xml::ElementNode pElmDbg, Debugging pDbg);
1132	void readAutostart(const xml::ElementNode pElmAutostart, Autostart pAutostart);
1133	void readSnapshot(const xml::ElementNode &elmSnapshot, Snapshot &snap);
1134	void convertOldOSType_pre1_5(com::Utf8Str &str);
1135	void readMachine(const xml::ElementNode &elmMachine);
1136
1137	void buildHardwareXML(xml::ElementNode &elmParent, const Hardware &hw, const Storage &strg);
1138	void buildNetworkXML(NetworkAttachmentType_T mode, xml::ElementNode &elmParent, bool fEnabled, const NetworkAdapter &nic);
1139	void buildStorageControllersXML(xml::ElementNode &elmParent,
1140	const Storage &st,
1141	bool fSkipRemovableMedia,
1142	std::list<xml::ElementNode> pllElementsWithUuidAttributes);
1143	void buildDebuggingXML(xml::ElementNode pElmParent, const Debugging pDbg);
1144	void buildAutostartXML(xml::ElementNode pElmParent, const Autostart pAutostart);
1145	void buildSnapshotXML(xml::ElementNode &elmParent, const Snapshot &snap);
1146
1147	void bumpSettingsVersionIfNeeded();
1148	};
1149
1150	} // namespace settings
1151
1152
1153	#endif /* ___VBox_settings_h */

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

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

Download in other formats: