settings.h@ 45138

Last change on this file since 45138 was 45138, checked in by vboxsync, 12 years ago
Main/NATNetworks: API+XML serialization for NATNetworks.
Property svn:eol-style set to `native` Property svn:keywords set to `Date Revision Author Id`
File size: 40.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-2013 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	typedef std::list<com::Utf8Str> StringsList;
103
104	// ExtraDataItem (used by both VirtualBox.xml and machines XML)
105	struct USBDeviceFilter;
106	typedef std::list<USBDeviceFilter> USBDeviceFiltersList;
107
108	struct Medium;
109	typedef std::list<Medium> MediaList;
110
111	/**
112	* NOTE: If you add any fields in here, you must update a) the constructor and b)
113	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
114	* your settings might never get saved.
115	*/
116	struct Medium
117	{
118	Medium()
119	: fAutoReset(false),
120	hdType(MediumType_Normal)
121	{}
122
123	com::Guid uuid;
124	com::Utf8Str strLocation;
125	com::Utf8Str strDescription;
126
127	// the following are for hard disks only:
128	com::Utf8Str strFormat;
129	bool fAutoReset; // optional, only for diffs, default is false
130	StringsMap properties;
131	MediumType_T hdType;
132
133	MediaList llChildren; // only used with hard disks
134
135	bool operator==(const Medium &m) const;
136	};
137
138	/**
139	* A media registry. Starting with VirtualBox 3.3, this can appear in both the
140	* VirtualBox.xml file as well as machine XML files with settings version 1.11
141	* or higher, so these lists are now in ConfigFileBase.
142	*
143	* NOTE: If you add any fields in here, you must update a) the constructor and b)
144	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
145	* your settings might never get saved.
146	*/
147	struct MediaRegistry
148	{
149	MediaList llHardDisks,
150	llDvdImages,
151	llFloppyImages;
152
153	bool operator==(const MediaRegistry &m) const;
154	};
155
156	/**
157	*
158	*/
159	struct NATRule
160	{
161	NATRule()
162	: proto(NATProtocol_TCP),
163	u16HostPort(0),
164	u16GuestPort(0)
165	{}
166
167	bool operator==(const NATRule &r) const
168	{
169	return strName == r.strName
170	&& proto == r.proto
171	&& u16HostPort == r.u16HostPort
172	&& strHostIP == r.strHostIP
173	&& u16GuestPort == r.u16GuestPort
174	&& strGuestIP == r.strGuestIP;
175	}
176
177	com::Utf8Str strName;
178	NATProtocol_T proto;
179	uint16_t u16HostPort;
180	com::Utf8Str strHostIP;
181	uint16_t u16GuestPort;
182	com::Utf8Str strGuestIP;
183	};
184	typedef std::list<NATRule> NATRuleList;
185
186	/**
187	*
188	*/
189	struct NATRule
190	{
191	NATRule()
192	: proto(NATProtocol_TCP),
193	u16HostPort(0),
194	u16GuestPort(0)
195	{}
196
197	bool operator==(const NATRule &r) const
198	{
199	return strName == r.strName
200	&& proto == r.proto
201	&& u16HostPort == r.u16HostPort
202	&& strHostIP == r.strHostIP
203	&& u16GuestPort == r.u16GuestPort
204	&& strGuestIP == r.strGuestIP;
205	}
206
207	com::Utf8Str strName;
208	NATProtocol_T proto;
209	uint16_t u16HostPort;
210	com::Utf8Str strHostIP;
211	uint16_t u16GuestPort;
212	com::Utf8Str strGuestIP;
213	};
214	typedef std::list<NATRule> NATRuleList;
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	void parseUUID(com::Guid &guid,
236	const com::Utf8Str &strUUID) const;
237	void parseTimestamp(RTTIMESPEC &timestamp,
238	const com::Utf8Str &str) const;
239
240	com::Utf8Str makeString(const RTTIMESPEC &tm);
241
242	void readExtraData(const xml::ElementNode &elmExtraData,
243	StringsMap &map);
244	void readUSBDeviceFilters(const xml::ElementNode &elmDeviceFilters,
245	USBDeviceFiltersList &ll);
246	typedef enum {Error, HardDisk, DVDImage, FloppyImage} MediaType;
247	void readMedium(MediaType t, const xml::ElementNode &elmMedium, MediaList &llMedia);
248	void readMediaRegistry(const xml::ElementNode &elmMediaRegistry, MediaRegistry &mr);
249	void readNATForwardRuleList(const xml::ElementNode &elmParent, NATRuleList &llRules);
250
251	void setVersionAttribute(xml::ElementNode &elm);
252	void createStubDocument();
253
254	void buildExtraData(xml::ElementNode &elmParent, const StringsMap &me);
255	void buildUSBDeviceFilters(xml::ElementNode &elmParent,
256	const USBDeviceFiltersList &ll,
257	bool fHostMode);
258	void buildMedium(xml::ElementNode &elmMedium,
259	DeviceType_T devType,
260	const Medium &m,
261	uint32_t level);
262	void buildMediaRegistry(xml::ElementNode &elmParent,
263	const MediaRegistry &mr);
264	void buildNATForwardRuleList(xml::ElementNode &elmParent, const NATRuleList &natRuleList);
265	void clearDocument();
266
267	struct Data;
268	Data *m;
269
270	friend class ConfigFileError;
271	};
272
273	////////////////////////////////////////////////////////////////////////////////
274	//
275	// VirtualBox.xml structures
276	//
277	////////////////////////////////////////////////////////////////////////////////
278
279	struct Host
280	{
281	USBDeviceFiltersList llUSBDeviceFilters;
282	};
283
284	struct SystemProperties
285	{
286	SystemProperties()
287	: ulLogHistoryCount(3)
288	{}
289
290	com::Utf8Str strDefaultMachineFolder;
291	com::Utf8Str strDefaultHardDiskFolder;
292	com::Utf8Str strDefaultHardDiskFormat;
293	com::Utf8Str strVRDEAuthLibrary;
294	com::Utf8Str strWebServiceAuthLibrary;
295	com::Utf8Str strDefaultVRDEExtPack;
296	com::Utf8Str strAutostartDatabasePath;
297	com::Utf8Str strDefaultAdditionsISO;
298	com::Utf8Str strDefaultFrontend;
299	uint32_t ulLogHistoryCount;
300	};
301
302	struct MachineRegistryEntry
303	{
304	com::Guid uuid;
305	com::Utf8Str strSettingsFile;
306	};
307	typedef std::list<MachineRegistryEntry> MachinesRegistry;
308
309	struct DHCPServer
310	{
311	DHCPServer()
312	: fEnabled(false)
313	{}
314
315	com::Utf8Str strNetworkName,
316	strIPAddress,
317	strIPNetworkMask,
318	strIPLower,
319	strIPUpper;
320	bool fEnabled;
321	};
322	typedef std::list<DHCPServer> DHCPServersList;
323
324
325	/**
326	* Nat Networking settings (NAT service).
327	*/
328	struct NATNetwork
329	{
330	com::Utf8Str strNetworkName;
331	bool fEnabled;
332	com::Utf8Str strNetwork;
333	bool fIPv6;
334	com::Utf8Str strIPv6Prefix;
335	bool fAdvertiseDefaultIPv6Route;
336	bool fNeedDhcpServer;
337	NATRuleList llPortForwardRules4;
338	NATRuleList llPortForwardRules6;
339	NATNetwork():fEnabled(false),
340	fAdvertiseDefaultIPv6Route(false),
341	fNeedDhcpServer(false)
342	{}
343	bool operator==(const NATNetwork &n) const
344	{
345	return strNetworkName == n.strNetworkName
346	&& strNetwork == n.strNetwork;
347	}
348
349	};
350	typedef std::list<NATNetwork> NATNetworksList;
351
352
353	/**
354	* Nat Networking settings (NAT service).
355	*/
356	struct NATNetwork
357	{
358	com::Utf8Str strNetworkName;
359	bool fEnabled;
360	com::Utf8Str strNetwork;
361	bool fIPv6;
362	com::Utf8Str strIPv6Prefix;
363	bool fAdvertiseDefaultIPv6Route;
364	bool fNeedDhcpServer;
365	NATRuleList llPortForwardRules4;
366	NATRuleList llPortForwardRules6;
367	NATNetwork():fEnabled(false),
368	fAdvertiseDefaultIPv6Route(false),
369	fNeedDhcpServer(false)
370	{}
371	bool operator==(const NATNetwork &n) const
372	{
373	return strNetworkName == n.strNetworkName
374	&& strNetwork == n.strNetwork;
375	}
376
377	};
378	typedef std::list<NATNetwork> NATNetworksList;
379
380	class MainConfigFile : public ConfigFileBase
381	{
382	public:
383	MainConfigFile(const com::Utf8Str *pstrFilename);
384
385	void readMachineRegistry(const xml::ElementNode &elmMachineRegistry);
386	void readDHCPServers(const xml::ElementNode &elmDHCPServers);
387	void readNATNetworks(const xml::ElementNode &elmNATNetworks);
388
389	void write(const com::Utf8Str strFilename);
390
391	Host host;
392	SystemProperties systemProperties;
393	MediaRegistry mediaRegistry;
394	MachinesRegistry llMachines;
395	DHCPServersList llDhcpServers;
396	NATNetworksList llNATNetworks;
397	StringsMap mapExtraDataItems;
398	};
399
400	////////////////////////////////////////////////////////////////////////////////
401	//
402	// Machine XML structures
403	//
404	////////////////////////////////////////////////////////////////////////////////
405
406	/**
407	* NOTE: If you add any fields in here, you must update a) the constructor and b)
408	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
409	* your settings might never get saved.
410	*/
411	struct VRDESettings
412	{
413	VRDESettings()
414	: fEnabled(true),
415	authType(AuthType_Null),
416	ulAuthTimeout(5000),
417	fAllowMultiConnection(false),
418	fReuseSingleConnection(false)
419	{}
420
421	bool operator==(const VRDESettings& v) const;
422
423	bool fEnabled;
424	AuthType_T authType;
425	uint32_t ulAuthTimeout;
426	com::Utf8Str strAuthLibrary;
427	bool fAllowMultiConnection,
428	fReuseSingleConnection;
429	com::Utf8Str strVrdeExtPack;
430	StringsMap mapProperties;
431	};
432
433	/**
434	* NOTE: If you add any fields in here, you must update a) the constructor and b)
435	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
436	* your settings might never get saved.
437	*/
438	struct BIOSSettings
439	{
440	BIOSSettings()
441	: fACPIEnabled(true),
442	fIOAPICEnabled(false),
443	fLogoFadeIn(true),
444	fLogoFadeOut(true),
445	ulLogoDisplayTime(0),
446	biosBootMenuMode(BIOSBootMenuMode_MessageAndMenu),
447	fPXEDebugEnabled(false),
448	llTimeOffset(0)
449	{}
450
451	bool operator==(const BIOSSettings &d) const;
452
453	bool fACPIEnabled,
454	fIOAPICEnabled,
455	fLogoFadeIn,
456	fLogoFadeOut;
457	uint32_t ulLogoDisplayTime;
458	com::Utf8Str strLogoImagePath;
459	BIOSBootMenuMode_T biosBootMenuMode;
460	bool fPXEDebugEnabled;
461	int64_t llTimeOffset;
462	};
463
464	/**
465	* NOTE: If you add any fields in here, you must update a) the constructor and b)
466	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
467	* your settings might never get saved.
468	*/
469	struct USBController
470	{
471	USBController()
472	: fEnabled(false),
473	fEnabledEHCI(false)
474	{}
475
476	bool operator==(const USBController &u) const;
477
478	bool fEnabled;
479	bool fEnabledEHCI;
480	USBDeviceFiltersList llDeviceFilters;
481	};
482
483	struct NAT
484	{
485	NAT()
486	: u32Mtu(0),
487	u32SockRcv(0),
488	u32SockSnd(0),
489	u32TcpRcv(0),
490	u32TcpSnd(0),
491	fDNSPassDomain(true), /* historically this value is true */
492	fDNSProxy(false),
493	fDNSUseHostResolver(false),
494	fAliasLog(false),
495	fAliasProxyOnly(false),
496	fAliasUseSamePorts(false)
497	{}
498
499	bool operator==(const NAT &n) const
500	{
501	return strNetwork == n.strNetwork
502	&& strBindIP == n.strBindIP
503	&& u32Mtu == n.u32Mtu
504	&& u32SockRcv == n.u32SockRcv
505	&& u32SockSnd == n.u32SockSnd
506	&& u32TcpSnd == n.u32TcpSnd
507	&& u32TcpRcv == n.u32TcpRcv
508	&& strTFTPPrefix == n.strTFTPPrefix
509	&& strTFTPBootFile == n.strTFTPBootFile
510	&& strTFTPNextServer == n.strTFTPNextServer
511	&& fDNSPassDomain == n.fDNSPassDomain
512	&& fDNSProxy == n.fDNSProxy
513	&& fDNSUseHostResolver == n.fDNSUseHostResolver
514	&& fAliasLog == n.fAliasLog
515	&& fAliasProxyOnly == n.fAliasProxyOnly
516	&& fAliasUseSamePorts == n.fAliasUseSamePorts
517	&& llRules == n.llRules;
518	}
519
520	com::Utf8Str strNetwork;
521	com::Utf8Str strBindIP;
522	uint32_t u32Mtu;
523	uint32_t u32SockRcv;
524	uint32_t u32SockSnd;
525	uint32_t u32TcpRcv;
526	uint32_t u32TcpSnd;
527	com::Utf8Str strTFTPPrefix;
528	com::Utf8Str strTFTPBootFile;
529	com::Utf8Str strTFTPNextServer;
530	bool fDNSPassDomain;
531	bool fDNSProxy;
532	bool fDNSUseHostResolver;
533	bool fAliasLog;
534	bool fAliasProxyOnly;
535	bool fAliasUseSamePorts;
536	NATRuleList llRules;
537	};
538
539	/**
540	* NOTE: If you add any fields in here, you must update a) the constructor and b)
541	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
542	* your settings might never get saved.
543	*/
544	struct NetworkAdapter
545	{
546	NetworkAdapter()
547	: ulSlot(0),
548	type(NetworkAdapterType_Am79C970A),
549	fEnabled(false),
550	fCableConnected(false),
551	ulLineSpeed(0),
552	enmPromiscModePolicy(NetworkAdapterPromiscModePolicy_Deny),
553	fTraceEnabled(false),
554	mode(NetworkAttachmentType_Null),
555	ulBootPriority(0)
556	{}
557
558	bool operator==(const NetworkAdapter &n) const;
559
560	uint32_t ulSlot;
561
562	NetworkAdapterType_T type;
563	bool fEnabled;
564	com::Utf8Str strMACAddress;
565	bool fCableConnected;
566	uint32_t ulLineSpeed;
567	NetworkAdapterPromiscModePolicy_T enmPromiscModePolicy;
568	bool fTraceEnabled;
569	com::Utf8Str strTraceFile;
570
571	NetworkAttachmentType_T mode;
572	NAT nat;
573	com::Utf8Str strBridgedName;
574	com::Utf8Str strHostOnlyName;
575	com::Utf8Str strInternalNetworkName;
576	com::Utf8Str strGenericDriver;
577	StringsMap genericProperties;
578	uint32_t ulBootPriority;
579	com::Utf8Str strBandwidthGroup; // requires settings version 1.13 (VirtualBox 4.2)
580	};
581	typedef std::list<NetworkAdapter> NetworkAdaptersList;
582
583	/**
584	* NOTE: If you add any fields in here, you must update a) the constructor and b)
585	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
586	* your settings might never get saved.
587	*/
588	struct SerialPort
589	{
590	SerialPort()
591	: ulSlot(0),
592	fEnabled(false),
593	ulIOBase(0x3f8),
594	ulIRQ(4),
595	portMode(PortMode_Disconnected),
596	fServer(false)
597	{}
598
599	bool operator==(const SerialPort &n) const;
600
601	uint32_t ulSlot;
602
603	bool fEnabled;
604	uint32_t ulIOBase;
605	uint32_t ulIRQ;
606	PortMode_T portMode;
607	com::Utf8Str strPath;
608	bool fServer;
609	};
610	typedef std::list<SerialPort> SerialPortsList;
611
612	/**
613	* NOTE: If you add any fields in here, you must update a) the constructor and b)
614	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
615	* your settings might never get saved.
616	*/
617	struct ParallelPort
618	{
619	ParallelPort()
620	: ulSlot(0),
621	fEnabled(false),
622	ulIOBase(0x378),
623	ulIRQ(7)
624	{}
625
626	bool operator==(const ParallelPort &d) const;
627
628	uint32_t ulSlot;
629
630	bool fEnabled;
631	uint32_t ulIOBase;
632	uint32_t ulIRQ;
633	com::Utf8Str strPath;
634	};
635	typedef std::list<ParallelPort> ParallelPortsList;
636
637	/**
638	* NOTE: If you add any fields in here, you must update a) the constructor and b)
639	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
640	* your settings might never get saved.
641	*/
642	struct AudioAdapter
643	{
644	AudioAdapter()
645	: fEnabled(true),
646	controllerType(AudioControllerType_AC97),
647	driverType(AudioDriverType_Null)
648	{}
649
650	bool operator==(const AudioAdapter &a) const
651	{
652	return (this == &a)
653	\|\| ( (fEnabled == a.fEnabled)
654	&& (controllerType == a.controllerType)
655	&& (driverType == a.driverType)
656	);
657	}
658
659	bool fEnabled;
660	AudioControllerType_T controllerType;
661	AudioDriverType_T driverType;
662	};
663
664	/**
665	* NOTE: If you add any fields in here, you must update a) the constructor and b)
666	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
667	* your settings might never get saved.
668	*/
669	struct SharedFolder
670	{
671	SharedFolder()
672	: fWritable(false)
673	, fAutoMount(false)
674	{}
675
676	bool operator==(const SharedFolder &a) const;
677
678	com::Utf8Str strName,
679	strHostPath;
680	bool fWritable;
681	bool fAutoMount;
682	};
683	typedef std::list<SharedFolder> SharedFoldersList;
684
685	/**
686	* NOTE: If you add any fields in here, you must update a) the constructor and b)
687	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
688	* your settings might never get saved.
689	*/
690	struct GuestProperty
691	{
692	GuestProperty()
693	: timestamp(0)
694	{};
695
696	bool operator==(const GuestProperty &g) const;
697
698	com::Utf8Str strName,
699	strValue;
700	uint64_t timestamp;
701	com::Utf8Str strFlags;
702	};
703	typedef std::list<GuestProperty> GuestPropertiesList;
704
705	typedef std::map<uint32_t, DeviceType_T> BootOrderMap;
706
707	/**
708	* NOTE: If you add any fields in here, you must update a) the constructor and b)
709	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
710	* your settings might never get saved.
711	*/
712	struct CpuIdLeaf
713	{
714	CpuIdLeaf()
715	: ulId(UINT32_MAX),
716	ulEax(0),
717	ulEbx(0),
718	ulEcx(0),
719	ulEdx(0)
720	{}
721
722	bool operator==(const CpuIdLeaf &c) const
723	{
724	return ( (this == &c)
725	\|\| ( (ulId == c.ulId)
726	&& (ulEax == c.ulEax)
727	&& (ulEbx == c.ulEbx)
728	&& (ulEcx == c.ulEcx)
729	&& (ulEdx == c.ulEdx)
730	)
731	);
732	}
733
734	uint32_t ulId;
735	uint32_t ulEax;
736	uint32_t ulEbx;
737	uint32_t ulEcx;
738	uint32_t ulEdx;
739	};
740	typedef std::list<CpuIdLeaf> CpuIdLeafsList;
741
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 Cpu
748	{
749	Cpu()
750	: ulId(UINT32_MAX)
751	{}
752
753	bool operator==(const Cpu &c) const
754	{
755	return (ulId == c.ulId);
756	}
757
758	uint32_t ulId;
759	};
760	typedef std::list<Cpu> CpuList;
761
762	/**
763	* NOTE: If you add any fields in here, you must update a) the constructor and b)
764	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
765	* your settings might never get saved.
766	*/
767	struct BandwidthGroup
768	{
769	BandwidthGroup()
770	: cMaxBytesPerSec(0),
771	enmType(BandwidthGroupType_Null)
772	{}
773
774	bool operator==(const BandwidthGroup &i) const
775	{
776	return ( (strName == i.strName)
777	&& (cMaxBytesPerSec == i.cMaxBytesPerSec)
778	&& (enmType == i.enmType));
779	}
780
781	com::Utf8Str strName;
782	uint64_t cMaxBytesPerSec;
783	BandwidthGroupType_T enmType;
784	};
785	typedef std::list<BandwidthGroup> BandwidthGroupList;
786
787	/**
788	* NOTE: If you add any fields in here, you must update a) the constructor and b)
789	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
790	* your settings might never get saved.
791	*/
792	struct IOSettings
793	{
794	IOSettings();
795
796	bool operator==(const IOSettings &i) const
797	{
798	return ( (fIOCacheEnabled == i.fIOCacheEnabled)
799	&& (ulIOCacheSize == i.ulIOCacheSize)
800	&& (llBandwidthGroups == i.llBandwidthGroups));
801	}
802
803	bool fIOCacheEnabled;
804	uint32_t ulIOCacheSize;
805	BandwidthGroupList llBandwidthGroups;
806	};
807
808	/**
809	* NOTE: If you add any fields in here, you must update a) the constructor and b)
810	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
811	* your settings might never get saved.
812	*/
813	struct HostPCIDeviceAttachment
814	{
815	HostPCIDeviceAttachment()
816	: uHostAddress(0),
817	uGuestAddress(0)
818	{}
819
820	bool operator==(const HostPCIDeviceAttachment &a) const
821	{
822	return ( (uHostAddress == a.uHostAddress)
823	&& (uGuestAddress == a.uGuestAddress)
824	&& (strDeviceName == a.strDeviceName)
825	);
826	}
827
828	com::Utf8Str strDeviceName;
829	uint32_t uHostAddress;
830	uint32_t uGuestAddress;
831	};
832	typedef std::list<HostPCIDeviceAttachment> HostPCIDeviceAttachmentList;
833
834	/**
835	* Representation of Machine hardware; this is used in the MachineConfigFile.hardwareMachine
836	* field.
837	*
838	* NOTE: If you add any fields in here, you must update a) the constructor and b)
839	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
840	* your settings might never get saved.
841	*/
842	struct Hardware
843	{
844	Hardware();
845
846	bool operator==(const Hardware&) const;
847
848	com::Utf8Str strVersion; // hardware version, optional
849	com::Guid uuid; // hardware uuid, optional (null).
850
851	bool fHardwareVirt,
852	fHardwareVirtExclusive,
853	fNestedPaging,
854	fLargePages,
855	fVPID,
856	fHardwareVirtForce,
857	fSyntheticCpu,
858	fPAE;
859	uint32_t cCPUs;
860	bool fCpuHotPlug; // requires settings version 1.10 (VirtualBox 3.2)
861	CpuList llCpus; // requires settings version 1.10 (VirtualBox 3.2)
862	bool fHPETEnabled; // requires settings version 1.10 (VirtualBox 3.2)
863	uint32_t ulCpuExecutionCap; // requires settings version 1.11 (VirtualBox 3.3)
864
865	CpuIdLeafsList llCpuIdLeafs;
866
867	uint32_t ulMemorySizeMB;
868
869	BootOrderMap mapBootOrder; // item 0 has highest priority
870
871	uint32_t ulVRAMSizeMB;
872	uint32_t cMonitors;
873	bool fAccelerate3D,
874	fAccelerate2DVideo; // requires settings version 1.8 (VirtualBox 3.1)
875	uint32_t ulVideoCaptureHorzRes;
876	uint32_t ulVideoCaptureVertRes;
877	bool fVideoCaptureEnabled;
878	com::Utf8Str strVideoCaptureFile;
879	FirmwareType_T firmwareType; // requires settings version 1.9 (VirtualBox 3.1)
880
881	PointingHIDType_T pointingHIDType; // requires settings version 1.10 (VirtualBox 3.2)
882	KeyboardHIDType_T keyboardHIDType; // requires settings version 1.10 (VirtualBox 3.2)
883
884	ChipsetType_T chipsetType; // requires settings version 1.11 (VirtualBox 4.0)
885
886	bool fEmulatedUSBWebcam; // 1.13 (VirtualBox 4.2)
887	bool fEmulatedUSBCardReader; // 1.12 (VirtualBox 4.1)
888
889	VRDESettings vrdeSettings;
890
891	BIOSSettings biosSettings;
892	USBController usbController;
893	NetworkAdaptersList llNetworkAdapters;
894	SerialPortsList llSerialPorts;
895	ParallelPortsList llParallelPorts;
896	AudioAdapter audioAdapter;
897
898	// technically these two have no business in the hardware section, but for some
899	// clever reason <Hardware> is where they are in the XML....
900	SharedFoldersList llSharedFolders;
901	ClipboardMode_T clipboardMode;
902	DragAndDropMode_T dragAndDropMode;
903
904	uint32_t ulMemoryBalloonSize;
905	bool fPageFusionEnabled;
906
907	GuestPropertiesList llGuestProperties;
908	com::Utf8Str strNotificationPatterns;
909
910	IOSettings ioSettings; // requires settings version 1.10 (VirtualBox 3.2)
911	HostPCIDeviceAttachmentList pciAttachments; // requires settings version 1.12 (VirtualBox 4.1)
912
913	com::Utf8Str strDefaultFrontend; // requires settings version 1.14 (VirtualBox 4.3)
914	};
915
916	/**
917	* A device attached to a storage controller. This can either be a
918	* hard disk or a DVD drive or a floppy drive and also specifies
919	* which medium is "in" the drive; as a result, this is a combination
920	* of the Main IMedium and IMediumAttachment interfaces.
921	*
922	* NOTE: If you add any fields in here, you must update a) the constructor and b)
923	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
924	* your settings might never get saved.
925	*/
926	struct AttachedDevice
927	{
928	AttachedDevice()
929	: deviceType(DeviceType_Null),
930	fPassThrough(false),
931	fTempEject(false),
932	fNonRotational(false),
933	lPort(0),
934	lDevice(0)
935	{}
936
937	bool operator==(const AttachedDevice &a) const;
938
939	DeviceType_T deviceType; // only HardDisk, DVD or Floppy are allowed
940
941	// DVDs can be in pass-through mode:
942	bool fPassThrough;
943
944	// Whether guest-triggered eject of DVDs will keep the medium in the
945	// VM config or not:
946	bool fTempEject;
947
948	// Whether the medium is non-rotational:
949	bool fNonRotational;
950
951	// Whether the medium supports discarding unused blocks:
952	bool fDiscard;
953
954	int32_t lPort;
955	int32_t lDevice;
956
957	// if an image file is attached to the device (ISO, RAW, or hard disk image such as VDI),
958	// this is its UUID; it depends on deviceType which media registry this then needs to
959	// be looked up in. If no image file (only permitted for DVDs and floppies), then the UUID is NULL
960	com::Guid uuid;
961
962	// for DVDs and floppies, the attachment can also be a host device:
963	com::Utf8Str strHostDriveSrc; // if != NULL, value of <HostDrive>/@src
964
965	// Bandwidth group the device is attached to.
966	com::Utf8Str strBwGroup;
967	};
968	typedef std::list<AttachedDevice> AttachedDevicesList;
969
970	/**
971	* NOTE: If you add any fields in here, you must update a) the constructor and b)
972	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
973	* your settings might never get saved.
974	*/
975	struct StorageController
976	{
977	StorageController()
978	: storageBus(StorageBus_IDE),
979	controllerType(StorageControllerType_PIIX3),
980	ulPortCount(2),
981	ulInstance(0),
982	fUseHostIOCache(true),
983	fBootable(true),
984	lIDE0MasterEmulationPort(0),
985	lIDE0SlaveEmulationPort(0),
986	lIDE1MasterEmulationPort(0),
987	lIDE1SlaveEmulationPort(0)
988	{}
989
990	bool operator==(const StorageController &s) const;
991
992	com::Utf8Str strName;
993	StorageBus_T storageBus; // _SATA, _SCSI, _IDE, _SAS
994	StorageControllerType_T controllerType;
995	uint32_t ulPortCount;
996	uint32_t ulInstance;
997	bool fUseHostIOCache;
998	bool fBootable;
999
1000	// only for when controllerType == StorageControllerType_IntelAhci:
1001	int32_t lIDE0MasterEmulationPort,
1002	lIDE0SlaveEmulationPort,
1003	lIDE1MasterEmulationPort,
1004	lIDE1SlaveEmulationPort;
1005
1006	AttachedDevicesList llAttachedDevices;
1007	};
1008	typedef std::list<StorageController> StorageControllersList;
1009
1010	/**
1011	* We wrap the storage controllers list into an extra struct so we can
1012	* use an undefined struct without needing std::list<> in all the headers.
1013	*
1014	* NOTE: If you add any fields in here, you must update a) the constructor and b)
1015	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
1016	* your settings might never get saved.
1017	*/
1018	struct Storage
1019	{
1020	bool operator==(const Storage &s) const;
1021
1022	StorageControllersList llStorageControllers;
1023	};
1024
1025	/**
1026	* Settings that has to do with debugging.
1027	*/
1028	struct Debugging
1029	{
1030	Debugging()
1031	: fTracingEnabled(false),
1032	fAllowTracingToAccessVM(false),
1033	strTracingConfig()
1034	{ }
1035
1036	bool operator==(const Debugging &rOther) const
1037	{
1038	return fTracingEnabled == rOther.fTracingEnabled
1039	&& fAllowTracingToAccessVM == rOther.fAllowTracingToAccessVM
1040	&& strTracingConfig == rOther.strTracingConfig;
1041	}
1042
1043	bool areDefaultSettings() const
1044	{
1045	return !fTracingEnabled
1046	&& !fAllowTracingToAccessVM
1047	&& strTracingConfig.isEmpty();
1048	}
1049
1050	bool fTracingEnabled;
1051	bool fAllowTracingToAccessVM;
1052	com::Utf8Str strTracingConfig;
1053	};
1054
1055	/**
1056	* Settings that has to do with autostart.
1057	*/
1058	struct Autostart
1059	{
1060	Autostart()
1061	: fAutostartEnabled(false),
1062	uAutostartDelay(0),
1063	enmAutostopType(AutostopType_Disabled)
1064	{ }
1065
1066	bool operator==(const Autostart &rOther) const
1067	{
1068	return fAutostartEnabled == rOther.fAutostartEnabled
1069	&& uAutostartDelay == rOther.uAutostartDelay
1070	&& enmAutostopType == rOther.enmAutostopType;
1071	}
1072
1073	bool areDefaultSettings() const
1074	{
1075	return !fAutostartEnabled
1076	&& !uAutostartDelay
1077	&& enmAutostopType == AutostopType_Disabled;
1078	}
1079
1080	bool fAutostartEnabled;
1081	uint32_t uAutostartDelay;
1082	AutostopType_T enmAutostopType;
1083	};
1084
1085	struct Snapshot;
1086	typedef std::list<Snapshot> SnapshotsList;
1087
1088	/**
1089	* NOTE: If you add any fields in here, you must update a) the constructor and b)
1090	* the operator== which is used by MachineConfigFile::operator==(), or otherwise
1091	* your settings might never get saved.
1092	*/
1093	struct Snapshot
1094	{
1095	bool operator==(const Snapshot &s) const;
1096
1097	com::Guid uuid;
1098	com::Utf8Str strName,
1099	strDescription; // optional
1100	RTTIMESPEC timestamp;
1101
1102	com::Utf8Str strStateFile; // for online snapshots only
1103
1104	Hardware hardware;
1105	Storage storage;
1106
1107	Debugging debugging;
1108	Autostart autostart;
1109
1110	SnapshotsList llChildSnapshots;
1111	};
1112
1113	struct MachineUserData
1114	{
1115	MachineUserData()
1116	: fDirectoryIncludesUUID(false),
1117	fNameSync(true),
1118	fTeleporterEnabled(false),
1119	uTeleporterPort(0),
1120	enmFaultToleranceState(FaultToleranceState_Inactive),
1121	uFaultTolerancePort(0),
1122	uFaultToleranceInterval(0),
1123	fRTCUseUTC(false)
1124	{
1125	llGroups.push_back("/");
1126	}
1127
1128	bool operator==(const MachineUserData &c) const
1129	{
1130	return (strName == c.strName)
1131	&& (fDirectoryIncludesUUID == c.fDirectoryIncludesUUID)
1132	&& (fNameSync == c.fNameSync)
1133	&& (strDescription == c.strDescription)
1134	&& (llGroups == c.llGroups)
1135	&& (strOsType == c.strOsType)
1136	&& (strSnapshotFolder == c.strSnapshotFolder)
1137	&& (fTeleporterEnabled == c.fTeleporterEnabled)
1138	&& (uTeleporterPort == c.uTeleporterPort)
1139	&& (strTeleporterAddress == c.strTeleporterAddress)
1140	&& (strTeleporterPassword == c.strTeleporterPassword)
1141	&& (enmFaultToleranceState == c.enmFaultToleranceState)
1142	&& (uFaultTolerancePort == c.uFaultTolerancePort)
1143	&& (uFaultToleranceInterval == c.uFaultToleranceInterval)
1144	&& (strFaultToleranceAddress == c.strFaultToleranceAddress)
1145	&& (strFaultTolerancePassword == c.strFaultTolerancePassword)
1146	&& (fRTCUseUTC == c.fRTCUseUTC);
1147	}
1148
1149	com::Utf8Str strName;
1150	bool fDirectoryIncludesUUID;
1151	bool fNameSync;
1152	com::Utf8Str strDescription;
1153	StringsList llGroups;
1154	com::Utf8Str strOsType;
1155	com::Utf8Str strSnapshotFolder;
1156	bool fTeleporterEnabled;
1157	uint32_t uTeleporterPort;
1158	com::Utf8Str strTeleporterAddress;
1159	com::Utf8Str strTeleporterPassword;
1160	FaultToleranceState_T enmFaultToleranceState;
1161	uint32_t uFaultTolerancePort;
1162	com::Utf8Str strFaultToleranceAddress;
1163	com::Utf8Str strFaultTolerancePassword;
1164	uint32_t uFaultToleranceInterval;
1165	bool fRTCUseUTC;
1166	};
1167
1168	/**
1169	* MachineConfigFile represents an XML machine configuration. All the machine settings
1170	* that go out to the XML (or are read from it) are in here.
1171	*
1172	* NOTE: If you add any fields in here, you must update a) the constructor and b)
1173	* the operator== which is used by Machine::saveSettings(), or otherwise your settings
1174	* might never get saved.
1175	*/
1176	class MachineConfigFile : public ConfigFileBase
1177	{
1178	public:
1179	com::Guid uuid;
1180
1181	MachineUserData machineUserData;
1182
1183	com::Utf8Str strStateFile;
1184	bool fCurrentStateModified; // optional, default is true
1185	RTTIMESPEC timeLastStateChange; // optional, defaults to now
1186	bool fAborted; // optional, default is false
1187
1188	com::Guid uuidCurrentSnapshot;
1189
1190	Hardware hardwareMachine;
1191	Storage storageMachine;
1192	MediaRegistry mediaRegistry;
1193	Debugging debugging;
1194	Autostart autostart;
1195
1196	StringsMap mapExtraDataItems;
1197
1198	SnapshotsList llFirstSnapshot; // first snapshot or empty list if there's none
1199
1200	MachineConfigFile(const com::Utf8Str *pstrFilename);
1201
1202	bool operator==(const MachineConfigFile &m) const;
1203
1204	bool canHaveOwnMediaRegistry() const;
1205
1206	void importMachineXML(const xml::ElementNode &elmMachine);
1207
1208	void write(const com::Utf8Str &strFilename);
1209
1210	enum
1211	{
1212	BuildMachineXML_IncludeSnapshots = 0x01,
1213	BuildMachineXML_WriteVboxVersionAttribute = 0x02,
1214	BuildMachineXML_SkipRemovableMedia = 0x04,
1215	BuildMachineXML_MediaRegistry = 0x08,
1216	BuildMachineXML_SuppressSavedState = 0x10
1217	};
1218	void buildMachineXML(xml::ElementNode &elmMachine,
1219	uint32_t fl,
1220	std::list<xml::ElementNode> pllElementsWithUuidAttributes);
1221
1222	static bool isAudioDriverAllowedOnThisHost(AudioDriverType_T drv);
1223	static AudioDriverType_T getHostDefaultAudioDriver();
1224
1225	private:
1226	void readNetworkAdapters(const xml::ElementNode &elmHardware, NetworkAdaptersList &ll);
1227	void readAttachedNetworkMode(const xml::ElementNode &pelmMode, bool fEnabled, NetworkAdapter &nic);
1228	void readCpuIdTree(const xml::ElementNode &elmCpuid, CpuIdLeafsList &ll);
1229	void readCpuTree(const xml::ElementNode &elmCpu, CpuList &ll);
1230	void readSerialPorts(const xml::ElementNode &elmUART, SerialPortsList &ll);
1231	void readParallelPorts(const xml::ElementNode &elmLPT, ParallelPortsList &ll);
1232	void readAudioAdapter(const xml::ElementNode &elmAudioAdapter, AudioAdapter &aa);
1233	void readGuestProperties(const xml::ElementNode &elmGuestProperties, Hardware &hw);
1234	void readStorageControllerAttributes(const xml::ElementNode &elmStorageController, StorageController &sctl);
1235	void readHardware(const xml::ElementNode &elmHardware, Hardware &hw, Storage &strg);
1236	void readHardDiskAttachments_pre1_7(const xml::ElementNode &elmHardDiskAttachments, Storage &strg);
1237	void readStorageControllers(const xml::ElementNode &elmStorageControllers, Storage &strg);
1238	void readDVDAndFloppies_pre1_9(const xml::ElementNode &elmHardware, Storage &strg);
1239	void readTeleporter(const xml::ElementNode pElmTeleporter, MachineUserData pUserData);
1240	void readDebugging(const xml::ElementNode pElmDbg, Debugging pDbg);
1241	void readAutostart(const xml::ElementNode pElmAutostart, Autostart pAutostart);
1242	void readGroups(const xml::ElementNode elmGroups, StringsList pllGroups);
1243	void readSnapshot(const xml::ElementNode &elmSnapshot, Snapshot &snap);
1244	void convertOldOSType_pre1_5(com::Utf8Str &str);
1245	void readMachine(const xml::ElementNode &elmMachine);
1246
1247	void buildHardwareXML(xml::ElementNode &elmParent, const Hardware &hw, const Storage &strg);
1248	void buildNetworkXML(NetworkAttachmentType_T mode, xml::ElementNode &elmParent, bool fEnabled, const NetworkAdapter &nic);
1249	void buildStorageControllersXML(xml::ElementNode &elmParent,
1250	const Storage &st,
1251	bool fSkipRemovableMedia,
1252	std::list<xml::ElementNode> pllElementsWithUuidAttributes);
1253	void buildDebuggingXML(xml::ElementNode pElmParent, const Debugging pDbg);
1254	void buildAutostartXML(xml::ElementNode pElmParent, const Autostart pAutostart);
1255	void buildGroupsXML(xml::ElementNode pElmParent, const StringsList pllGroups);
1256	void buildSnapshotXML(xml::ElementNode &elmParent, const Snapshot &snap);
1257
1258	void bumpSettingsVersionIfNeeded();
1259	};
1260
1261	} // namespace settings
1262
1263
1264	#endif /* ___VBox_settings_h */

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

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

Download in other formats: