settings.h@ 32190

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

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

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

Download in other formats: