settings.h@ 34837

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

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

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

Download in other formats: