VirtualBox

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

Last change on this file since 105687 was 105605, checked in by vboxsync, 4 months ago

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