VirtualBox

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

Last change on this file since 95362 was 94981, checked in by vboxsync, 3 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette