settings.h@ 60534

Last change on this file since 60534 was 60410, checked in by vboxsync, 9 years ago
IMachine: Added CPUProfile attribute (read/write string). Added a modifyvm option for setting it. Show non-default values in showvminfo, but always show it starting with 6.0.
Property svn:eol-style set to `native` Property svn:keywords set to `Date Revision Author Id`
File size: 45.3 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-2015 Oracle Corporation
21	*
22	* This file is part of VirtualBox Open Source Edition (OSE), as
23	* available from http://www.virtualbox.org. This file is free software;
24	* you can redistribute it and/or modify it under the terms of the GNU
25	* General Public License (GPL) as published by the Free Software
26	* Foundation, in version 2 as it comes in the "COPYING" file of the
27	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
28	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
29	*
30	* The contents of this file may alternatively be used under the terms
31	* of the Common Development and Distribution License Version 1.0
32	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
33	* VirtualBox OSE distribution, in which case the provisions of the
34	* CDDL are applicable instead of those of the GPL.
35	*
36	* You may elect to license modified versions of this file under the
37	* terms and conditions of either the GPL or the CDDL or both.
38	*/
39
40	#ifndef ___VBox_settings_h
41	#define ___VBox_settings_h
42
43	#include <iprt/time.h>
44
45	#include "VBox/com/VirtualBox.h"
46
47	#include <VBox/com/Guid.h>
48	#include <VBox/com/string.h>
49
50	#include <list>
51	#include <map>
52
53	/**
54	* Maximum depth of a medium tree, to prevent stack overflows.
55	* XPCOM has a relatively low stack size for its workers, and we have
56	* to avoid crashes due to exceeding the limit both on reading and
57	* writing config files.
58	*/
59	#define SETTINGS_MEDIUM_DEPTH_MAX 300
60
61	/**
62	* Maximum depth of the snapshot tree, to prevent stack overflows.
63	* XPCOM has a relatively low stack size for its workers, and we have
64	* to avoid crashes due to exceeding the limit both on reading and
65	* writing config files. The bottleneck is reading config files with
66	* deep snapshot nesting, as libxml2 needs quite some stack space,
67	* so with the current stack size the margin isn't big.
68	*/
69	#define SETTINGS_SNAPSHOT_DEPTH_MAX 250
70
71	namespace xml
72	{
73	class ElementNode;
74	}
75
76	namespace settings
77	{
78
79	class ConfigFileError;
80
81	////////////////////////////////////////////////////////////////////////////////
82	//
83	// Structures shared between Machine XML and VirtualBox.xml
84	//
85	////////////////////////////////////////////////////////////////////////////////
86
87	/**
88	* USB device filter definition. This struct is used both in MainConfigFile
89	* (for global USB filters) and MachineConfigFile (for machine filters).
90	*
91	* NOTE: If you add any fields in here, you must update a) the constructor and b)
92	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
93	* your settings might never get saved.
94	*/
95	struct USBDeviceFilter
96	{
97	USBDeviceFilter()
98	: fActive(false),
99	action(USBDeviceFilterAction_Null),
100	ulMaskedInterfaces(0)
101	{}
102
103	bool operator==(const USBDeviceFilter&u) const;
104
105	com::Utf8Str strName;
106	bool fActive;
107	com::Utf8Str strVendorId,
108	strProductId,
109	strRevision,
110	strManufacturer,
111	strProduct,
112	strSerialNumber,
113	strPort;
114	USBDeviceFilterAction_T action; // only used with host USB filters
115	com::Utf8Str strRemote; // irrelevant for host USB objects
116	uint32_t ulMaskedInterfaces; // irrelevant for host USB objects
117	};
118
119	typedef std::map<com::Utf8Str, com::Utf8Str> StringsMap;
120	typedef std::list<com::Utf8Str> StringsList;
121
122	// ExtraDataItem (used by both VirtualBox.xml and machines XML)
123	struct USBDeviceFilter;
124	typedef std::list<USBDeviceFilter> USBDeviceFiltersList;
125
126	struct Medium;
127	typedef std::list<Medium> MediaList;
128
129	/**
130	* NOTE: If you add any fields in here, you must update a) the constructor and b)
131	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
132	* your settings might never get saved.
133	*/
134	struct Medium
135	{
136	Medium()
137	: fAutoReset(false),
138	hdType(MediumType_Normal)
139	{}
140
141	com::Guid uuid;
142	com::Utf8Str strLocation;
143	com::Utf8Str strDescription;
144
145	// the following are for hard disks only:
146	com::Utf8Str strFormat;
147	bool fAutoReset; // optional, only for diffs, default is false
148	StringsMap properties;
149	MediumType_T hdType;
150
151	MediaList llChildren; // only used with hard disks
152
153	bool operator==(const Medium &m) const;
154	};
155
156	extern const struct Medium g_MediumEmpty;
157
158	/**
159	* A media registry. Starting with VirtualBox 3.3, this can appear in both the
160	* VirtualBox.xml file as well as machine XML files with settings version 1.11
161	* or higher, so these lists are now in ConfigFileBase.
162	*
163	* NOTE: If you add any fields in here, you must update a) the constructor and b)
164	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
165	* your settings might never get saved.
166	*/
167	struct MediaRegistry
168	{
169	MediaList llHardDisks,
170	llDvdImages,
171	llFloppyImages;
172
173	bool operator==(const MediaRegistry &m) const;
174	};
175
176	/**
177	*
178	*/
179	struct NATRule
180	{
181	NATRule()
182	: proto(NATProtocol_TCP),
183	u16HostPort(0),
184	u16GuestPort(0)
185	{}
186
187	bool operator==(const NATRule &r) const
188	{
189	return strName == r.strName
190	&& proto == r.proto
191	&& u16HostPort == r.u16HostPort
192	&& strHostIP == r.strHostIP
193	&& u16GuestPort == r.u16GuestPort
194	&& strGuestIP == r.strGuestIP;
195	}
196
197	com::Utf8Str strName;
198	NATProtocol_T proto;
199	uint16_t u16HostPort;
200	com::Utf8Str strHostIP;
201	uint16_t u16GuestPort;
202	com::Utf8Str strGuestIP;
203	};
204	typedef std::list<NATRule> NATRuleList;
205
206
207	struct NATHostLoopbackOffset
208	{
209	/** Note: 128/8 is only acceptable */
210	com::Utf8Str strLoopbackHostAddress;
211	uint32_t u32Offset;
212	bool operator == (const com::Utf8Str& strAddr)
213	{
214	return (strLoopbackHostAddress == strAddr);
215	}
216
217	bool operator == (uint32_t off)
218	{
219	return (this->u32Offset == off);
220	}
221	};
222	typedef std::list<NATHostLoopbackOffset> NATLoopbackOffsetList;
223
224	/**
225	* Common base class for both MainConfigFile and MachineConfigFile
226	* which contains some common logic for both.
227	*/
228	class ConfigFileBase
229	{
230	public:
231	bool fileExists();
232
233	void copyBaseFrom(const ConfigFileBase &b);
234
235	protected:
236	ConfigFileBase(const com::Utf8Str *pstrFilename);
237	/* Note: this copy constructor doesn't create a full copy of other, cause
238	* the file based stuff (xml doc) could not be copied. */
239	ConfigFileBase(const ConfigFileBase &other);
240
241	~ConfigFileBase();
242
243	typedef enum {Error, HardDisk, DVDImage, FloppyImage} MediaType;
244
245	static const char *stringifyMediaType(MediaType t);
246	void parseUUID(com::Guid &guid,
247	const com::Utf8Str &strUUID) const;
248	void parseTimestamp(RTTIMESPEC &timestamp,
249	const com::Utf8Str &str) const;
250	com::Utf8Str stringifyTimestamp(const RTTIMESPEC &tm) const;
251
252	void readExtraData(const xml::ElementNode &elmExtraData,
253	StringsMap &map);
254	void readUSBDeviceFilters(const xml::ElementNode &elmDeviceFilters,
255	USBDeviceFiltersList &ll);
256	void readMediumOne(MediaType t, const xml::ElementNode &elmMedium, Medium &med);
257	void readMedium(MediaType t, uint32_t depth, const xml::ElementNode &elmMedium, Medium &med);
258	void readMediaRegistry(const xml::ElementNode &elmMediaRegistry, MediaRegistry &mr);
259	void readNATForwardRuleList(const xml::ElementNode &elmParent, NATRuleList &llRules);
260	void readNATLoopbacks(const xml::ElementNode &elmParent, NATLoopbackOffsetList &llLoopBacks);
261
262	void setVersionAttribute(xml::ElementNode &elm);
263	void createStubDocument();
264
265	void buildExtraData(xml::ElementNode &elmParent, const StringsMap &me);
266	void buildUSBDeviceFilters(xml::ElementNode &elmParent,
267	const USBDeviceFiltersList &ll,
268	bool fHostMode);
269	void buildMedium(MediaType t,
270	uint32_t depth,
271	xml::ElementNode &elmMedium,
272	const Medium &mdm);
273	void buildMediaRegistry(xml::ElementNode &elmParent,
274	const MediaRegistry &mr);
275	void buildNATForwardRuleList(xml::ElementNode &elmParent, const NATRuleList &natRuleList);
276	void buildNATLoopbacks(xml::ElementNode &elmParent, const NATLoopbackOffsetList &natLoopbackList);
277	void clearDocument();
278
279	struct Data;
280	Data *m;
281
282	friend class ConfigFileError;
283	};
284
285	////////////////////////////////////////////////////////////////////////////////
286	//
287	// VirtualBox.xml structures
288	//
289	////////////////////////////////////////////////////////////////////////////////
290
291	struct USBDeviceSource
292	{
293	com::Utf8Str strName;
294	com::Utf8Str strBackend;
295	com::Utf8Str strAddress;
296	StringsMap properties;
297	};
298
299	typedef std::list<USBDeviceSource> USBDeviceSourcesList;
300
301	struct Host
302	{
303	USBDeviceFiltersList llUSBDeviceFilters;
304	USBDeviceSourcesList llUSBDeviceSources;
305	};
306
307	struct SystemProperties
308	{
309	SystemProperties()
310	: ulLogHistoryCount(3)
311	#if defined(RT_OS_DARWIN) \|\| defined(RT_OS_WINDOWS)
312	, fExclusiveHwVirt(false)
313	#else
314	, fExclusiveHwVirt(true)
315	#endif
316	{}
317
318	com::Utf8Str strDefaultMachineFolder;
319	com::Utf8Str strDefaultHardDiskFolder;
320	com::Utf8Str strDefaultHardDiskFormat;
321	com::Utf8Str strVRDEAuthLibrary;
322	com::Utf8Str strWebServiceAuthLibrary;
323	com::Utf8Str strDefaultVRDEExtPack;
324	com::Utf8Str strAutostartDatabasePath;
325	com::Utf8Str strDefaultAdditionsISO;
326	com::Utf8Str strDefaultFrontend;
327	com::Utf8Str strLoggingLevel;
328	uint32_t ulLogHistoryCount;
329	bool fExclusiveHwVirt;
330	};
331
332	struct MachineRegistryEntry
333	{
334	com::Guid uuid;
335	com::Utf8Str strSettingsFile;
336	};
337	typedef std::list<MachineRegistryEntry> MachinesRegistry;
338
339	struct DhcpOptValue
340	{
341	enum Encoding {
342	LEGACY = DhcpOptEncoding_Legacy,
343	HEX = DhcpOptEncoding_Hex
344	};
345
346	com::Utf8Str text;
347	Encoding encoding;
348
349	DhcpOptValue()
350	: text(), encoding(LEGACY) {}
351
352	DhcpOptValue(const com::Utf8Str &aText, Encoding aEncoding = LEGACY)
353	: text(aText), encoding(aEncoding) {}
354	};
355
356	typedef std::map<DhcpOpt_T, DhcpOptValue> DhcpOptionMap;
357	typedef DhcpOptionMap::value_type DhcpOptValuePair;
358	typedef DhcpOptionMap::iterator DhcpOptIterator;
359	typedef DhcpOptionMap::const_iterator DhcpOptConstIterator;
360
361	typedef struct VmNameSlotKey
362	{
363	VmNameSlotKey(const com::Utf8Str& aVmName, LONG aSlot): VmName(aVmName),
364	Slot(aSlot){}
365	const com::Utf8Str VmName;
366	LONG Slot;
367	bool operator< (const VmNameSlotKey& that) const
368	{
369	if (VmName == that.VmName)
370	return Slot < that.Slot;
371	else return VmName < that.VmName;
372	}
373	} VmNameSlotKey;
374	typedef std::map<VmNameSlotKey, DhcpOptionMap> VmSlot2OptionsMap;
375	typedef VmSlot2OptionsMap::value_type VmSlot2OptionsPair;
376	typedef VmSlot2OptionsMap::iterator VmSlot2OptionsIterator;
377	typedef VmSlot2OptionsMap::const_iterator VmSlot2OptionsConstIterator;
378
379	struct DHCPServer
380	{
381	DHCPServer()
382	: fEnabled(false)
383	{}
384
385	com::Utf8Str strNetworkName,
386	strIPAddress,
387	strIPLower,
388	strIPUpper;
389	bool fEnabled;
390	DhcpOptionMap GlobalDhcpOptions;
391	VmSlot2OptionsMap VmSlot2OptionsM;
392	};
393	typedef std::list<DHCPServer> DHCPServersList;
394
395
396	/**
397	* Nat Networking settings (NAT service).
398	*/
399	struct NATNetwork
400	{
401	com::Utf8Str strNetworkName;
402	bool fEnabled;
403	com::Utf8Str strNetwork;
404	bool fIPv6;
405	com::Utf8Str strIPv6Prefix;
406	uint32_t u32HostLoopback6Offset;
407	NATLoopbackOffsetList llHostLoopbackOffsetList;
408	bool fAdvertiseDefaultIPv6Route;
409	bool fNeedDhcpServer;
410	NATRuleList llPortForwardRules4;
411	NATRuleList llPortForwardRules6;
412	NATNetwork():fEnabled(true),
413	fAdvertiseDefaultIPv6Route(false),
414	fNeedDhcpServer(true)
415	{}
416	bool operator==(const NATNetwork &n) const
417	{
418	return strNetworkName == n.strNetworkName
419	&& strNetwork == n.strNetwork;
420	}
421
422	};
423	typedef std::list<NATNetwork> NATNetworksList;
424
425
426	class MainConfigFile : public ConfigFileBase
427	{
428	public:
429	MainConfigFile(const com::Utf8Str *pstrFilename);
430
431	void readMachineRegistry(const xml::ElementNode &elmMachineRegistry);
432	void readDHCPServers(const xml::ElementNode &elmDHCPServers);
433	void readDhcpOptions(DhcpOptionMap& map, const xml::ElementNode& options);
434	void readNATNetworks(const xml::ElementNode &elmNATNetworks);
435
436	void write(const com::Utf8Str strFilename);
437
438	Host host;
439	SystemProperties systemProperties;
440	MediaRegistry mediaRegistry;
441	MachinesRegistry llMachines;
442	DHCPServersList llDhcpServers;
443	NATNetworksList llNATNetworks;
444	StringsMap mapExtraDataItems;
445
446	private:
447	void bumpSettingsVersionIfNeeded();
448	void buildUSBDeviceSources(xml::ElementNode &elmParent, const USBDeviceSourcesList &ll);
449	void readUSBDeviceSources(const xml::ElementNode &elmDeviceSources, USBDeviceSourcesList &ll);
450	};
451
452	////////////////////////////////////////////////////////////////////////////////
453	//
454	// Machine XML structures
455	//
456	////////////////////////////////////////////////////////////////////////////////
457
458	/**
459	* NOTE: If you add any fields in here, you must update a) the constructor and b)
460	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
461	* your settings might never get saved.
462	*/
463	struct VRDESettings
464	{
465	VRDESettings()
466	: fEnabled(true),
467	authType(AuthType_Null),
468	ulAuthTimeout(5000),
469	fAllowMultiConnection(false),
470	fReuseSingleConnection(false)
471	{}
472
473	bool operator==(const VRDESettings& v) const;
474
475	bool fEnabled;
476	AuthType_T authType;
477	uint32_t ulAuthTimeout;
478	com::Utf8Str strAuthLibrary;
479	bool fAllowMultiConnection,
480	fReuseSingleConnection;
481	com::Utf8Str strVrdeExtPack;
482	StringsMap mapProperties;
483	};
484
485	/**
486	* NOTE: If you add any fields in here, you must update a) the constructor and b)
487	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
488	* your settings might never get saved.
489	*/
490	struct BIOSSettings
491	{
492	BIOSSettings()
493	: fACPIEnabled(true),
494	fIOAPICEnabled(false),
495	fLogoFadeIn(true),
496	fLogoFadeOut(true),
497	ulLogoDisplayTime(0),
498	biosBootMenuMode(BIOSBootMenuMode_MessageAndMenu),
499	fPXEDebugEnabled(false),
500	llTimeOffset(0)
501	{}
502
503	bool operator==(const BIOSSettings &d) const;
504
505	bool fACPIEnabled,
506	fIOAPICEnabled,
507	fLogoFadeIn,
508	fLogoFadeOut;
509	uint32_t ulLogoDisplayTime;
510	com::Utf8Str strLogoImagePath;
511	BIOSBootMenuMode_T biosBootMenuMode;
512	bool fPXEDebugEnabled;
513	int64_t llTimeOffset;
514	};
515
516	/**
517	* NOTE: If you add any fields in here, you must update a) the constructor and b)
518	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
519	* your settings might never get saved.
520	*/
521	struct USBController
522	{
523	USBController()
524	: enmType(USBControllerType_Null)
525	{}
526
527	bool operator==(const USBController &u) const;
528
529	com::Utf8Str strName;
530	USBControllerType_T enmType;
531	};
532	typedef std::list<USBController> USBControllerList;
533
534	struct USB
535	{
536	USB() {}
537
538	bool operator==(const USB &u) const;
539
540	/** List of USB controllers present. */
541	USBControllerList llUSBControllers;
542	/** List of USB device filters. */
543	USBDeviceFiltersList llDeviceFilters;
544	};
545
546	struct NAT
547	{
548	NAT()
549	: u32Mtu(0),
550	u32SockRcv(0),
551	u32SockSnd(0),
552	u32TcpRcv(0),
553	u32TcpSnd(0),
554	fDNSPassDomain(true), /* historically this value is true */
555	fDNSProxy(false),
556	fDNSUseHostResolver(false),
557	fAliasLog(false),
558	fAliasProxyOnly(false),
559	fAliasUseSamePorts(false)
560	{}
561
562	bool operator==(const NAT &n) const
563	{
564	return strNetwork == n.strNetwork
565	&& strBindIP == n.strBindIP
566	&& u32Mtu == n.u32Mtu
567	&& u32SockRcv == n.u32SockRcv
568	&& u32SockSnd == n.u32SockSnd
569	&& u32TcpSnd == n.u32TcpSnd
570	&& u32TcpRcv == n.u32TcpRcv
571	&& strTFTPPrefix == n.strTFTPPrefix
572	&& strTFTPBootFile == n.strTFTPBootFile
573	&& strTFTPNextServer == n.strTFTPNextServer
574	&& fDNSPassDomain == n.fDNSPassDomain
575	&& fDNSProxy == n.fDNSProxy
576	&& fDNSUseHostResolver == n.fDNSUseHostResolver
577	&& fAliasLog == n.fAliasLog
578	&& fAliasProxyOnly == n.fAliasProxyOnly
579	&& fAliasUseSamePorts == n.fAliasUseSamePorts
580	&& llRules == n.llRules;
581	}
582
583	com::Utf8Str strNetwork;
584	com::Utf8Str strBindIP;
585	uint32_t u32Mtu;
586	uint32_t u32SockRcv;
587	uint32_t u32SockSnd;
588	uint32_t u32TcpRcv;
589	uint32_t u32TcpSnd;
590	com::Utf8Str strTFTPPrefix;
591	com::Utf8Str strTFTPBootFile;
592	com::Utf8Str strTFTPNextServer;
593	bool fDNSPassDomain;
594	bool fDNSProxy;
595	bool fDNSUseHostResolver;
596	bool fAliasLog;
597	bool fAliasProxyOnly;
598	bool fAliasUseSamePorts;
599	NATRuleList llRules;
600	};
601
602	/**
603	* NOTE: If you add any fields in here, you must update a) the constructor and b)
604	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
605	* your settings might never get saved.
606	*/
607	struct NetworkAdapter
608	{
609	NetworkAdapter()
610	: ulSlot(0),
611	type(NetworkAdapterType_Am79C970A),
612	fEnabled(false),
613	fCableConnected(false),
614	ulLineSpeed(0),
615	enmPromiscModePolicy(NetworkAdapterPromiscModePolicy_Deny),
616	fTraceEnabled(false),
617	mode(NetworkAttachmentType_Null),
618	ulBootPriority(0)
619	{}
620
621	bool operator==(const NetworkAdapter &n) const;
622
623	uint32_t ulSlot;
624
625	NetworkAdapterType_T type;
626	bool fEnabled;
627	com::Utf8Str strMACAddress;
628	bool fCableConnected;
629	uint32_t ulLineSpeed;
630	NetworkAdapterPromiscModePolicy_T enmPromiscModePolicy;
631	bool fTraceEnabled;
632	com::Utf8Str strTraceFile;
633
634	NetworkAttachmentType_T mode;
635	NAT nat;
636	com::Utf8Str strBridgedName;
637	com::Utf8Str strHostOnlyName;
638	com::Utf8Str strInternalNetworkName;
639	com::Utf8Str strGenericDriver;
640	StringsMap genericProperties;
641	com::Utf8Str strNATNetworkName;
642	uint32_t ulBootPriority;
643	com::Utf8Str strBandwidthGroup; // requires settings version 1.13 (VirtualBox 4.2)
644	};
645	typedef std::list<NetworkAdapter> NetworkAdaptersList;
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 SerialPort
653	{
654	SerialPort()
655	: ulSlot(0),
656	fEnabled(false),
657	ulIOBase(0x3f8),
658	ulIRQ(4),
659	portMode(PortMode_Disconnected),
660	fServer(false)
661	{}
662
663	bool operator==(const SerialPort &n) const;
664
665	uint32_t ulSlot;
666
667	bool fEnabled;
668	uint32_t ulIOBase;
669	uint32_t ulIRQ;
670	PortMode_T portMode;
671	com::Utf8Str strPath;
672	bool fServer;
673	};
674	typedef std::list<SerialPort> SerialPortsList;
675
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 ParallelPort
682	{
683	ParallelPort()
684	: ulSlot(0),
685	fEnabled(false),
686	ulIOBase(0x378),
687	ulIRQ(7)
688	{}
689
690	bool operator==(const ParallelPort &d) const;
691
692	uint32_t ulSlot;
693
694	bool fEnabled;
695	uint32_t ulIOBase;
696	uint32_t ulIRQ;
697	com::Utf8Str strPath;
698	};
699	typedef std::list<ParallelPort> ParallelPortsList;
700
701	/**
702	* NOTE: If you add any fields in here, you must update a) the constructor and b)
703	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
704	* your settings might never get saved.
705	*/
706	struct AudioAdapter
707	{
708	AudioAdapter()
709	: fEnabled(true),
710	controllerType(AudioControllerType_AC97),
711	codecType(AudioCodecType_STAC9700),
712	driverType(AudioDriverType_Null)
713	{}
714
715	bool operator==(const AudioAdapter &a) const
716	{
717	return (this == &a)
718	\|\| ( (fEnabled == a.fEnabled)
719	&& (controllerType == a.controllerType)
720	&& (codecType == a.codecType)
721	&& (driverType == a.driverType)
722	&& (properties == a.properties)
723	);
724	}
725
726	bool fEnabled;
727	AudioControllerType_T controllerType;
728	AudioCodecType_T codecType;
729	AudioDriverType_T driverType;
730	settings::StringsMap properties;
731	};
732
733	/**
734	* NOTE: If you add any fields in here, you must update a) the constructor and b)
735	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
736	* your settings might never get saved.
737	*/
738	struct SharedFolder
739	{
740	SharedFolder()
741	: fWritable(false)
742	, fAutoMount(false)
743	{}
744
745	bool operator==(const SharedFolder &a) const;
746
747	com::Utf8Str strName,
748	strHostPath;
749	bool fWritable;
750	bool fAutoMount;
751	};
752	typedef std::list<SharedFolder> SharedFoldersList;
753
754	/**
755	* NOTE: If you add any fields in here, you must update a) the constructor and b)
756	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
757	* your settings might never get saved.
758	*/
759	struct GuestProperty
760	{
761	GuestProperty()
762	: timestamp(0)
763	{};
764
765	bool operator==(const GuestProperty &g) const;
766
767	com::Utf8Str strName,
768	strValue;
769	uint64_t timestamp;
770	com::Utf8Str strFlags;
771	};
772	typedef std::list<GuestProperty> GuestPropertiesList;
773
774	typedef std::map<uint32_t, DeviceType_T> BootOrderMap;
775
776	/**
777	* NOTE: If you add any fields in here, you must update a) the constructor and b)
778	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
779	* your settings might never get saved.
780	*/
781	struct CpuIdLeaf
782	{
783	CpuIdLeaf()
784	: ulId(UINT32_MAX),
785	ulEax(0),
786	ulEbx(0),
787	ulEcx(0),
788	ulEdx(0)
789	{}
790
791	bool operator==(const CpuIdLeaf &c) const
792	{
793	return ( (this == &c)
794	\|\| ( (ulId == c.ulId)
795	&& (ulEax == c.ulEax)
796	&& (ulEbx == c.ulEbx)
797	&& (ulEcx == c.ulEcx)
798	&& (ulEdx == c.ulEdx)
799	)
800	);
801	}
802
803	uint32_t ulId;
804	uint32_t ulEax;
805	uint32_t ulEbx;
806	uint32_t ulEcx;
807	uint32_t ulEdx;
808	};
809	typedef std::list<CpuIdLeaf> CpuIdLeafsList;
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 Cpu
817	{
818	Cpu()
819	: ulId(UINT32_MAX)
820	{}
821
822	bool operator==(const Cpu &c) const
823	{
824	return (ulId == c.ulId);
825	}
826
827	uint32_t ulId;
828	};
829	typedef std::list<Cpu> CpuList;
830
831	/**
832	* NOTE: If you add any fields in here, you must update a) the constructor and b)
833	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
834	* your settings might never get saved.
835	*/
836	struct BandwidthGroup
837	{
838	BandwidthGroup()
839	: cMaxBytesPerSec(0),
840	enmType(BandwidthGroupType_Null)
841	{}
842
843	bool operator==(const BandwidthGroup &i) const
844	{
845	return ( (strName == i.strName)
846	&& (cMaxBytesPerSec == i.cMaxBytesPerSec)
847	&& (enmType == i.enmType));
848	}
849
850	com::Utf8Str strName;
851	uint64_t cMaxBytesPerSec;
852	BandwidthGroupType_T enmType;
853	};
854	typedef std::list<BandwidthGroup> BandwidthGroupList;
855
856	/**
857	* NOTE: If you add any fields in here, you must update a) the constructor and b)
858	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
859	* your settings might never get saved.
860	*/
861	struct IOSettings
862	{
863	IOSettings();
864
865	bool operator==(const IOSettings &i) const
866	{
867	return ( (fIOCacheEnabled == i.fIOCacheEnabled)
868	&& (ulIOCacheSize == i.ulIOCacheSize)
869	&& (llBandwidthGroups == i.llBandwidthGroups));
870	}
871
872	bool fIOCacheEnabled;
873	uint32_t ulIOCacheSize;
874	BandwidthGroupList llBandwidthGroups;
875	};
876
877	/**
878	* NOTE: If you add any fields in here, you must update a) the constructor and b)
879	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
880	* your settings might never get saved.
881	*/
882	struct HostPCIDeviceAttachment
883	{
884	HostPCIDeviceAttachment()
885	: uHostAddress(0),
886	uGuestAddress(0)
887	{}
888
889	bool operator==(const HostPCIDeviceAttachment &a) const
890	{
891	return ( (uHostAddress == a.uHostAddress)
892	&& (uGuestAddress == a.uGuestAddress)
893	&& (strDeviceName == a.strDeviceName)
894	);
895	}
896
897	com::Utf8Str strDeviceName;
898	uint32_t uHostAddress;
899	uint32_t uGuestAddress;
900	};
901	typedef std::list<HostPCIDeviceAttachment> HostPCIDeviceAttachmentList;
902
903	/**
904	* Representation of Machine hardware; this is used in the MachineConfigFile.hardwareMachine
905	* field.
906	*
907	* NOTE: If you add any fields in here, you must update a) the constructor and b)
908	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
909	* your settings might never get saved.
910	*/
911	struct Hardware
912	{
913	Hardware();
914
915	bool operator==(const Hardware&) const;
916
917	bool areParavirtDefaultSettings() const
918	{
919	return paravirtProvider == ParavirtProvider_Legacy;
920	}
921
922	com::Utf8Str strVersion; // hardware version, optional
923	com::Guid uuid; // hardware uuid, optional (null).
924
925	bool fHardwareVirt,
926	fNestedPaging,
927	fLargePages,
928	fVPID,
929	fUnrestrictedExecution,
930	fHardwareVirtForce,
931	fSyntheticCpu,
932	fTripleFaultReset,
933	fPAE;
934	typedef enum LongModeType { LongMode_Enabled, LongMode_Disabled, LongMode_Legacy } LongModeType;
935	LongModeType enmLongMode;
936	uint32_t cCPUs;
937	bool fCpuHotPlug; // requires settings version 1.10 (VirtualBox 3.2)
938	CpuList llCpus; // requires settings version 1.10 (VirtualBox 3.2)
939	bool fHPETEnabled; // requires settings version 1.10 (VirtualBox 3.2)
940	uint32_t ulCpuExecutionCap; // requires settings version 1.11 (VirtualBox 3.3)
941	uint32_t uCpuIdPortabilityLevel; // requires settings version 1.15 (VirtualBox 5.0)
942	com::Utf8Str strCpuProfile; // requires settings version 1.16 (VirtualBox 5.1)
943
944	CpuIdLeafsList llCpuIdLeafs;
945
946	uint32_t ulMemorySizeMB;
947
948	BootOrderMap mapBootOrder; // item 0 has highest priority
949
950	GraphicsControllerType_T graphicsControllerType;
951	uint32_t ulVRAMSizeMB;
952	uint32_t cMonitors;
953	bool fAccelerate3D,
954	fAccelerate2DVideo; // requires settings version 1.8 (VirtualBox 3.1)
955
956	uint32_t ulVideoCaptureHorzRes; // requires settings version 1.14 (VirtualBox 4.3)
957	uint32_t ulVideoCaptureVertRes; // requires settings version 1.14 (VirtualBox 4.3)
958	uint32_t ulVideoCaptureRate; // requires settings version 1.14 (VirtualBox 4.3)
959	uint32_t ulVideoCaptureFPS; // requires settings version 1.14 (VirtualBox 4.3)
960	uint32_t ulVideoCaptureMaxTime; // requires settings version 1.14 (VirtualBox 4.3)
961	uint32_t ulVideoCaptureMaxSize; // requires settings version 1.14 (VirtualBox 4.3)
962	bool fVideoCaptureEnabled; // requires settings version 1.14 (VirtualBox 4.3)
963	uint64_t u64VideoCaptureScreens; // requires settings version 1.14 (VirtualBox 4.3)
964	com::Utf8Str strVideoCaptureFile; // requires settings version 1.14 (VirtualBox 4.3)
965
966	FirmwareType_T firmwareType; // requires settings version 1.9 (VirtualBox 3.1)
967
968	PointingHIDType_T pointingHIDType; // requires settings version 1.10 (VirtualBox 3.2)
969	KeyboardHIDType_T keyboardHIDType; // requires settings version 1.10 (VirtualBox 3.2)
970
971	ChipsetType_T chipsetType; // requires settings version 1.11 (VirtualBox 4.0)
972	ParavirtProvider_T paravirtProvider; // requires settings version 1.15 (VirtualBox 4.4)
973	com::Utf8Str strParavirtDebug; // requires settings version 1.16 (VirtualBox 5.1)
974
975	bool fEmulatedUSBCardReader; // 1.12 (VirtualBox 4.1)
976
977	VRDESettings vrdeSettings;
978
979	BIOSSettings biosSettings;
980	USB usbSettings;
981	NetworkAdaptersList llNetworkAdapters;
982	SerialPortsList llSerialPorts;
983	ParallelPortsList llParallelPorts;
984	AudioAdapter audioAdapter;
985
986	// technically these two have no business in the hardware section, but for some
987	// clever reason <Hardware> is where they are in the XML....
988	SharedFoldersList llSharedFolders;
989	ClipboardMode_T clipboardMode;
990	DnDMode_T dndMode;
991
992	uint32_t ulMemoryBalloonSize;
993	bool fPageFusionEnabled;
994
995	GuestPropertiesList llGuestProperties;
996
997	IOSettings ioSettings; // requires settings version 1.10 (VirtualBox 3.2)
998	HostPCIDeviceAttachmentList pciAttachments; // requires settings version 1.12 (VirtualBox 4.1)
999
1000	com::Utf8Str strDefaultFrontend; // requires settings version 1.14 (VirtualBox 4.3)
1001	};
1002
1003	/**
1004	* A device attached to a storage controller. This can either be a
1005	* hard disk or a DVD drive or a floppy drive and also specifies
1006	* which medium is "in" the drive; as a result, this is a combination
1007	* of the Main IMedium and IMediumAttachment interfaces.
1008	*
1009	* NOTE: If you add any fields in here, you must update a) the constructor and b)
1010	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
1011	* your settings might never get saved.
1012	*/
1013	struct AttachedDevice
1014	{
1015	AttachedDevice()
1016	: deviceType(DeviceType_Null),
1017	fPassThrough(false),
1018	fTempEject(false),
1019	fNonRotational(false),
1020	fDiscard(false),
1021	fHotPluggable(false),
1022	lPort(0),
1023	lDevice(0)
1024	{}
1025
1026	bool operator==(const AttachedDevice &a) const;
1027
1028	DeviceType_T deviceType; // only HardDisk, DVD or Floppy are allowed
1029
1030	// DVDs can be in pass-through mode:
1031	bool fPassThrough;
1032
1033	// Whether guest-triggered eject of DVDs will keep the medium in the
1034	// VM config or not:
1035	bool fTempEject;
1036
1037	// Whether the medium is non-rotational:
1038	bool fNonRotational;
1039
1040	// Whether the medium supports discarding unused blocks:
1041	bool fDiscard;
1042
1043	// Whether the medium is hot-pluggable:
1044	bool fHotPluggable;
1045
1046	int32_t lPort;
1047	int32_t lDevice;
1048
1049	// if an image file is attached to the device (ISO, RAW, or hard disk image such as VDI),
1050	// this is its UUID; it depends on deviceType which media registry this then needs to
1051	// be looked up in. If no image file (only permitted for DVDs and floppies), then the UUID is NULL
1052	com::Guid uuid;
1053
1054	// for DVDs and floppies, the attachment can also be a host device:
1055	com::Utf8Str strHostDriveSrc; // if != NULL, value of <HostDrive>/@src
1056
1057	// Bandwidth group the device is attached to.
1058	com::Utf8Str strBwGroup;
1059	};
1060	typedef std::list<AttachedDevice> AttachedDevicesList;
1061
1062	/**
1063	* NOTE: If you add any fields in here, you must update a) the constructor and b)
1064	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
1065	* your settings might never get saved.
1066	*/
1067	struct StorageController
1068	{
1069	StorageController()
1070	: storageBus(StorageBus_IDE),
1071	controllerType(StorageControllerType_PIIX3),
1072	ulPortCount(2),
1073	ulInstance(0),
1074	fUseHostIOCache(true),
1075	fBootable(true)
1076	{}
1077
1078	bool operator==(const StorageController &s) const;
1079
1080	com::Utf8Str strName;
1081	StorageBus_T storageBus; // _SATA, _SCSI, _IDE, _SAS
1082	StorageControllerType_T controllerType;
1083	uint32_t ulPortCount;
1084	uint32_t ulInstance;
1085	bool fUseHostIOCache;
1086	bool fBootable;
1087
1088	// only for when controllerType == StorageControllerType_IntelAhci:
1089	int32_t lIDE0MasterEmulationPort,
1090	lIDE0SlaveEmulationPort,
1091	lIDE1MasterEmulationPort,
1092	lIDE1SlaveEmulationPort;
1093
1094	AttachedDevicesList llAttachedDevices;
1095	};
1096	typedef std::list<StorageController> StorageControllersList;
1097
1098	/**
1099	* We wrap the storage controllers list into an extra struct so we can
1100	* use an undefined struct without needing std::list<> in all the headers.
1101	*
1102	* NOTE: If you add any fields in here, you must update a) the constructor and b)
1103	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
1104	* your settings might never get saved.
1105	*/
1106	struct Storage
1107	{
1108	bool operator==(const Storage &s) const;
1109
1110	StorageControllersList llStorageControllers;
1111	};
1112
1113	/**
1114	* Settings that has to do with debugging.
1115	*/
1116	struct Debugging
1117	{
1118	Debugging()
1119	: fTracingEnabled(false),
1120	fAllowTracingToAccessVM(false),
1121	strTracingConfig()
1122	{ }
1123
1124	bool operator==(const Debugging &rOther) const
1125	{
1126	return fTracingEnabled == rOther.fTracingEnabled
1127	&& fAllowTracingToAccessVM == rOther.fAllowTracingToAccessVM
1128	&& strTracingConfig == rOther.strTracingConfig;
1129	}
1130
1131	bool areDefaultSettings() const
1132	{
1133	return !fTracingEnabled
1134	&& !fAllowTracingToAccessVM
1135	&& strTracingConfig.isEmpty();
1136	}
1137
1138	bool fTracingEnabled;
1139	bool fAllowTracingToAccessVM;
1140	com::Utf8Str strTracingConfig;
1141	};
1142
1143	/**
1144	* Settings that has to do with autostart.
1145	*/
1146	struct Autostart
1147	{
1148	Autostart()
1149	: fAutostartEnabled(false),
1150	uAutostartDelay(0),
1151	enmAutostopType(AutostopType_Disabled)
1152	{ }
1153
1154	bool operator==(const Autostart &rOther) const
1155	{
1156	return fAutostartEnabled == rOther.fAutostartEnabled
1157	&& uAutostartDelay == rOther.uAutostartDelay
1158	&& enmAutostopType == rOther.enmAutostopType;
1159	}
1160
1161	bool areDefaultSettings() const
1162	{
1163	return !fAutostartEnabled
1164	&& !uAutostartDelay
1165	&& enmAutostopType == AutostopType_Disabled;
1166	}
1167
1168	bool fAutostartEnabled;
1169	uint32_t uAutostartDelay;
1170	AutostopType_T enmAutostopType;
1171	};
1172
1173	struct Snapshot;
1174	typedef std::list<Snapshot> SnapshotsList;
1175
1176	/**
1177	* NOTE: If you add any fields in here, you must update a) the constructor and b)
1178	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
1179	* your settings might never get saved.
1180	*/
1181	struct Snapshot
1182	{
1183	Snapshot()
1184	{
1185	RTTimeSpecSetNano(&timestamp, 0);
1186	}
1187
1188	bool operator==(const Snapshot &s) const;
1189
1190	com::Guid uuid;
1191	com::Utf8Str strName,
1192	strDescription; // optional
1193	RTTIMESPEC timestamp;
1194
1195	com::Utf8Str strStateFile; // for online snapshots only
1196
1197	Hardware hardware;
1198	Storage storage;
1199
1200	Debugging debugging;
1201	Autostart autostart;
1202
1203	SnapshotsList llChildSnapshots;
1204	};
1205
1206	struct MachineUserData
1207	{
1208	MachineUserData()
1209	: fDirectoryIncludesUUID(false),
1210	fNameSync(true),
1211	fTeleporterEnabled(false),
1212	uTeleporterPort(0),
1213	enmFaultToleranceState(FaultToleranceState_Inactive),
1214	uFaultTolerancePort(0),
1215	uFaultToleranceInterval(0),
1216	fRTCUseUTC(false),
1217	strVMPriority("")
1218	{
1219	llGroups.push_back("/");
1220	}
1221
1222	bool operator==(const MachineUserData &c) const
1223	{
1224	return (strName == c.strName)
1225	&& (fDirectoryIncludesUUID == c.fDirectoryIncludesUUID)
1226	&& (fNameSync == c.fNameSync)
1227	&& (strDescription == c.strDescription)
1228	&& (llGroups == c.llGroups)
1229	&& (strOsType == c.strOsType)
1230	&& (strSnapshotFolder == c.strSnapshotFolder)
1231	&& (fTeleporterEnabled == c.fTeleporterEnabled)
1232	&& (uTeleporterPort == c.uTeleporterPort)
1233	&& (strTeleporterAddress == c.strTeleporterAddress)
1234	&& (strTeleporterPassword == c.strTeleporterPassword)
1235	&& (enmFaultToleranceState == c.enmFaultToleranceState)
1236	&& (uFaultTolerancePort == c.uFaultTolerancePort)
1237	&& (uFaultToleranceInterval == c.uFaultToleranceInterval)
1238	&& (strFaultToleranceAddress == c.strFaultToleranceAddress)
1239	&& (strFaultTolerancePassword == c.strFaultTolerancePassword)
1240	&& (fRTCUseUTC == c.fRTCUseUTC)
1241	&& (ovIcon == c.ovIcon)
1242	&& (strVMPriority == c.strVMPriority);
1243	}
1244
1245	com::Utf8Str strName;
1246	bool fDirectoryIncludesUUID;
1247	bool fNameSync;
1248	com::Utf8Str strDescription;
1249	StringsList llGroups;
1250	com::Utf8Str strOsType;
1251	com::Utf8Str strSnapshotFolder;
1252	bool fTeleporterEnabled;
1253	uint32_t uTeleporterPort;
1254	com::Utf8Str strTeleporterAddress;
1255	com::Utf8Str strTeleporterPassword;
1256	FaultToleranceState_T enmFaultToleranceState;
1257	uint32_t uFaultTolerancePort;
1258	com::Utf8Str strFaultToleranceAddress;
1259	com::Utf8Str strFaultTolerancePassword;
1260	uint32_t uFaultToleranceInterval;
1261	bool fRTCUseUTC;
1262	com::Utf8Str ovIcon;
1263	com::Utf8Str strVMPriority;
1264	};
1265
1266	extern const struct Snapshot g_SnapshotEmpty;
1267
1268	/**
1269	* MachineConfigFile represents an XML machine configuration. All the machine settings
1270	* that go out to the XML (or are read from it) are in here.
1271	*
1272	* NOTE: If you add any fields in here, you must update a) the constructor and b)
1273	* the operator== which is used by Machine::saveSettings(), or otherwise your settings
1274	* might never get saved.
1275	*/
1276	class MachineConfigFile : public ConfigFileBase
1277	{
1278	public:
1279	com::Guid uuid;
1280
1281	MachineUserData machineUserData;
1282
1283	com::Utf8Str strStateFile;
1284	bool fCurrentStateModified; // optional, default is true
1285	RTTIMESPEC timeLastStateChange; // optional, defaults to now
1286	bool fAborted; // optional, default is false
1287
1288	com::Guid uuidCurrentSnapshot;
1289
1290	Hardware hardwareMachine;
1291	Storage storageMachine;
1292	MediaRegistry mediaRegistry;
1293	Debugging debugging;
1294	Autostart autostart;
1295
1296	StringsMap mapExtraDataItems;
1297
1298	SnapshotsList llFirstSnapshot; // first snapshot or empty list if there's none
1299
1300	MachineConfigFile(const com::Utf8Str *pstrFilename);
1301
1302	bool operator==(const MachineConfigFile &m) const;
1303
1304	bool canHaveOwnMediaRegistry() const;
1305
1306	void importMachineXML(const xml::ElementNode &elmMachine);
1307
1308	void write(const com::Utf8Str &strFilename);
1309
1310	enum
1311	{
1312	BuildMachineXML_IncludeSnapshots = 0x01,
1313	BuildMachineXML_WriteVBoxVersionAttribute = 0x02,
1314	BuildMachineXML_SkipRemovableMedia = 0x04,
1315	BuildMachineXML_MediaRegistry = 0x08,
1316	BuildMachineXML_SuppressSavedState = 0x10
1317	};
1318	void buildMachineXML(xml::ElementNode &elmMachine,
1319	uint32_t fl,
1320	std::list<xml::ElementNode> pllElementsWithUuidAttributes);
1321
1322	static bool isAudioDriverAllowedOnThisHost(AudioDriverType_T drv);
1323	static AudioDriverType_T getHostDefaultAudioDriver();
1324
1325	private:
1326	void readNetworkAdapters(const xml::ElementNode &elmHardware, NetworkAdaptersList &ll);
1327	void readAttachedNetworkMode(const xml::ElementNode &pelmMode, bool fEnabled, NetworkAdapter &nic);
1328	void readCpuIdTree(const xml::ElementNode &elmCpuid, CpuIdLeafsList &ll);
1329	void readCpuTree(const xml::ElementNode &elmCpu, CpuList &ll);
1330	void readSerialPorts(const xml::ElementNode &elmUART, SerialPortsList &ll);
1331	void readParallelPorts(const xml::ElementNode &elmLPT, ParallelPortsList &ll);
1332	void readAudioAdapter(const xml::ElementNode &elmAudioAdapter, AudioAdapter &aa);
1333	void readGuestProperties(const xml::ElementNode &elmGuestProperties, Hardware &hw);
1334	void readStorageControllerAttributes(const xml::ElementNode &elmStorageController, StorageController &sctl);
1335	void readHardware(const xml::ElementNode &elmHardware, Hardware &hw, Storage &strg);
1336	void readHardDiskAttachments_pre1_7(const xml::ElementNode &elmHardDiskAttachments, Storage &strg);
1337	void readStorageControllers(const xml::ElementNode &elmStorageControllers, Storage &strg);
1338	void readDVDAndFloppies_pre1_9(const xml::ElementNode &elmHardware, Storage &strg);
1339	void readTeleporter(const xml::ElementNode pElmTeleporter, MachineUserData pUserData);
1340	void readDebugging(const xml::ElementNode pElmDbg, Debugging pDbg);
1341	void readAutostart(const xml::ElementNode pElmAutostart, Autostart pAutostart);
1342	void readGroups(const xml::ElementNode elmGroups, StringsList pllGroups);
1343	bool readSnapshot(const com::Guid &curSnapshotUuid, uint32_t depth, const xml::ElementNode &elmSnapshot, Snapshot &snap);
1344	void convertOldOSType_pre1_5(com::Utf8Str &str);
1345	void readMachine(const xml::ElementNode &elmMachine);
1346
1347	void buildHardwareXML(xml::ElementNode &elmParent, const Hardware &hw, const Storage &strg);
1348	void buildNetworkXML(NetworkAttachmentType_T mode, xml::ElementNode &elmParent, bool fEnabled, const NetworkAdapter &nic);
1349	void buildStorageControllersXML(xml::ElementNode &elmParent,
1350	const Storage &st,
1351	bool fSkipRemovableMedia,
1352	std::list<xml::ElementNode> pllElementsWithUuidAttributes);
1353	void buildDebuggingXML(xml::ElementNode pElmParent, const Debugging pDbg);
1354	void buildAutostartXML(xml::ElementNode pElmParent, const Autostart pAutostart);
1355	void buildGroupsXML(xml::ElementNode pElmParent, const StringsList pllGroups);
1356	void buildSnapshotXML(uint32_t depth, xml::ElementNode &elmParent, const Snapshot &snap);
1357
1358	void bumpSettingsVersionIfNeeded();
1359	};
1360
1361	} // namespace settings
1362
1363
1364	#endif /* ___VBox_settings_h */

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

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

Download in other formats: