settings.h@ 81768

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

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

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

Download in other formats: