settings.h@ 33661

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

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

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

Download in other formats: