VirtualBox

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

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

Recording/Main:

  • Renamed RecordingVideoScalingMethod -> RecordingVideoScalingMode (to match the other enums).
  • Renamed RecordingVideoRateControlMode -> RecordingRateControlMode, as this also can apply to audio codecs.
  • Added ABR (average bitrate) mode to RecordingRateControlMode.

IRecordingScreenSettings:

  • Added audioRateControlMode.
  • Added videoScalingMode.

ISystemProperties:

  • Renamed supportedRecordingVSMethods to supportedRecordingVSModes (to match RecordingVideoScalingMode).
  • Added supportedRecordingARCModes.

Renamed com::settings::RecordingScreenSettings.Audio.enmAudioCodec -> .enmCodec (Doppelmoppel).

More documentation.

​bugref:10275
  • Property svn:eol-style set to native
  • Property svn:keywords set to Date Revision Author Id
File size: 51.5 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
626/**
627 * Recording settings for a single screen (e.g. virtual monitor).
628 *
629 * NOTE: If you add any fields in here, you must update a) the constructor and b)
630 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
631 * your settings might never get saved.
632 */
633struct RecordingScreenSettings
634{
635 RecordingScreenSettings(uint32_t idScreen = UINT32_MAX);
636
637 virtual ~RecordingScreenSettings();
638
639 void applyDefaults(void);
640
641 bool areDefaultSettings(void) const;
642
643 bool isFeatureEnabled(RecordingFeature_T enmFeature) const;
644
645 static const char *getDefaultOptions(void);
646
647 static int featuresFromString(const com::Utf8Str &strFeatures, RecordingFeatureMap &featureMap);
648
649 static void featuresToString(const RecordingFeatureMap &featureMap, com::Utf8Str &strFeatures);
650
651 static int audioCodecFromString(const com::Utf8Str &strCodec, RecordingAudioCodec_T &enmCodec);
652
653 static void audioCodecToString(const RecordingAudioCodec_T &enmCodec, com::Utf8Str &strCodec);
654
655 static int videoCodecFromString(const com::Utf8Str &strCodec, RecordingVideoCodec_T &enmCodec);
656
657 static void videoCodecToString(const RecordingVideoCodec_T &enmCodec, com::Utf8Str &strCodec);
658
659 bool operator==(const RecordingScreenSettings &d) const;
660
661 /** Screen ID.
662 * UINT32_MAX if not set. */
663 uint32_t idScreen;
664 /** Whether to record this screen or not. */
665 bool fEnabled; // requires settings version 1.14 (VirtualBox 4.3)
666 /** Destination to record to. */
667 RecordingDestination_T enmDest;
668 /** Which features are enable or not. */
669 RecordingFeatureMap featureMap; // requires settings version 1.19 (VirtualBox 7.0)
670 /** Maximum time (in s) to record. If set to 0, no time limit is set. */
671 uint32_t ulMaxTimeS; // requires settings version 1.14 (VirtualBox 4.3)
672 /** Options string for hidden / advanced / experimental features.
673 * Use RecordingScreenSettings::getDefaultOptions(). */
674 com::Utf8Str strOptions; // new since VirtualBox 5.2.
675
676 /**
677 * Structure holding settings for audio recording.
678 */
679 struct Audio
680 {
681 /** The audio codec type to use. */
682 RecordingAudioCodec_T enmCodec; // requires settings version 1.19 (VirtualBox 7.0)
683 /** Codec deadline to use. */
684 RecordingCodecDeadline_T enmDeadline; // requires settings version 1.19 (VirtualBox 7.0)
685 /** Rate control mode to use. */
686 RecordingRateControlMode_T
687 enmRateCtlMode;// requires settings version 1.19 (VirtualBox 7.0)
688 /** Hz rate. */
689 uint16_t uHz; // requires settings version 1.19 (VirtualBox 7.0)
690 /** Bits per sample. */
691 uint8_t cBits; // requires settings version 1.19 (VirtualBox 7.0)
692 /** Number of audio channels. */
693 uint8_t cChannels; // requires settings version 1.19 (VirtualBox 7.0)
694 } Audio;
695
696 /**
697 * Structure holding settings for video recording.
698 */
699 struct Video
700 {
701 /** The codec to use. */
702 RecordingVideoCodec_T enmCodec; // requires settings version 1.19 (VirtualBox 7.0)
703 /** Codec deadline to use. */
704 RecordingCodecDeadline_T enmDeadline; // requires settings version 1.19 (VirtualBox 7.0)
705 /** Rate control mode to use. */
706 RecordingRateControlMode_T
707 enmRateCtlMode; // requires settings version 1.19 (VirtualBox 7.0)
708 /** Rate control mode to use. */
709 RecordingVideoScalingMode_T
710 enmScalingMode; // requires settings version 1.19 (VirtualBox 7.0)
711 /** Target frame width in pixels (X). */
712 uint32_t ulWidth; // requires settings version 1.14 (VirtualBox 4.3)
713 /** Target frame height in pixels (Y). */
714 uint32_t ulHeight; // requires settings version 1.14 (VirtualBox 4.3)
715 /** Encoding rate. */
716 uint32_t ulRate; // requires settings version 1.14 (VirtualBox 4.3)
717 /** Frames per second (FPS). */
718 uint32_t ulFPS; // requires settings version 1.14 (VirtualBox 4.3)
719 } Video;
720
721 /**
722 * Structure holding settings if the destination is a file.
723 */
724 struct File
725 {
726 /** Maximum size (in MB) the file is allowed to have.
727 * When reaching the limit, recording will stop. 0 means no limit. */
728 uint32_t ulMaxSizeMB; // requires settings version 1.14 (VirtualBox 4.3)
729 /** Absolute file name path to use for recording.
730 * When empty, this is considered as being the default setting. */
731 com::Utf8Str strName; // requires settings version 1.14 (VirtualBox 4.3)
732 } File;
733};
734
735/** Map for keeping settings per virtual screen.
736 * The key specifies the screen ID. */
737typedef std::map<uint32_t, RecordingScreenSettings> RecordingScreenSettingsMap;
738
739/**
740 * Common recording settings, shared among all per-screen recording settings.
741 *
742 * NOTE: If you add any fields in here, you must update a) the constructor and b)
743 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
744 * your settings might never get saved.
745 */
746struct RecordingCommonSettings
747{
748 RecordingCommonSettings();
749
750 void applyDefaults(void);
751
752 bool areDefaultSettings(void) const;
753
754 bool operator==(const RecordingCommonSettings &d) const;
755
756 /** Whether recording as a whole is enabled or disabled. */
757 bool fEnabled; // requires settings version 1.14 (VirtualBox 4.3)
758};
759
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 RecordingSettings
766{
767 RecordingSettings();
768
769 void applyDefaults(void);
770
771 bool areDefaultSettings(void) const;
772
773 bool operator==(const RecordingSettings &that) const;
774
775 /** Common settings for all per-screen recording settings. */
776 RecordingCommonSettings common;
777 /** Map of handled recording screen settings.
778 * The key specifies the screen ID. */
779 RecordingScreenSettingsMap mapScreens;
780};
781
782/**
783 * NOTE: If you add any fields in here, you must update a) the constructor and b)
784 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
785 * your settings might never get saved.
786 */
787struct GraphicsAdapter
788{
789 GraphicsAdapter();
790
791 bool areDefaultSettings() const;
792
793 bool operator==(const GraphicsAdapter &g) const;
794
795 GraphicsControllerType_T graphicsControllerType;
796 uint32_t ulVRAMSizeMB;
797 uint32_t cMonitors;
798 bool fAccelerate3D,
799 fAccelerate2DVideo; // requires settings version 1.8 (VirtualBox 3.1)
800};
801
802/**
803 * NOTE: If you add any fields in here, you must update a) the constructor and b)
804 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
805 * your settings might never get saved.
806 */
807struct USBController
808{
809 USBController();
810
811 bool operator==(const USBController &u) const;
812
813 com::Utf8Str strName;
814 USBControllerType_T enmType;
815};
816
817typedef std::list<USBController> USBControllerList;
818
819struct USB
820{
821 USB();
822
823 bool operator==(const USB &u) const;
824
825 /** List of USB controllers present. */
826 USBControllerList llUSBControllers;
827 /** List of USB device filters. */
828 USBDeviceFiltersList llDeviceFilters;
829};
830
831struct NAT
832{
833 NAT();
834
835 bool areDNSDefaultSettings() const;
836 bool areAliasDefaultSettings() const;
837 bool areTFTPDefaultSettings() const;
838 bool areLocalhostReachableDefaultSettings(SettingsVersion_T sv) const;
839 bool areDefaultSettings(SettingsVersion_T sv) const;
840
841 bool operator==(const NAT &n) const;
842
843 com::Utf8Str strNetwork;
844 com::Utf8Str strBindIP;
845 uint32_t u32Mtu;
846 uint32_t u32SockRcv;
847 uint32_t u32SockSnd;
848 uint32_t u32TcpRcv;
849 uint32_t u32TcpSnd;
850 com::Utf8Str strTFTPPrefix;
851 com::Utf8Str strTFTPBootFile;
852 com::Utf8Str strTFTPNextServer;
853 bool fDNSPassDomain;
854 bool fDNSProxy;
855 bool fDNSUseHostResolver;
856 bool fAliasLog;
857 bool fAliasProxyOnly;
858 bool fAliasUseSamePorts;
859 bool fLocalhostReachable;
860 NATRulesMap mapRules;
861};
862
863/**
864 * NOTE: If you add any fields in here, you must update a) the constructor and b)
865 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
866 * your settings might never get saved.
867 */
868struct NetworkAdapter
869{
870 NetworkAdapter();
871
872 bool areGenericDriverDefaultSettings() const;
873 bool areDefaultSettings(SettingsVersion_T sv) const;
874 bool areDisabledDefaultSettings(SettingsVersion_T sv) const;
875
876 bool operator==(const NetworkAdapter &n) const;
877
878 uint32_t ulSlot;
879
880 NetworkAdapterType_T type;
881 bool fEnabled;
882 com::Utf8Str strMACAddress;
883 bool fCableConnected;
884 uint32_t ulLineSpeed;
885 NetworkAdapterPromiscModePolicy_T enmPromiscModePolicy;
886 bool fTraceEnabled;
887 com::Utf8Str strTraceFile;
888
889 NetworkAttachmentType_T mode;
890 NAT nat;
891 com::Utf8Str strBridgedName;
892 com::Utf8Str strHostOnlyName;
893#ifdef VBOX_WITH_VMNET
894 com::Utf8Str strHostOnlyNetworkName;
895#endif /* VBOX_WITH_VMNET */
896 com::Utf8Str strInternalNetworkName;
897 com::Utf8Str strGenericDriver;
898 StringsMap genericProperties;
899 com::Utf8Str strNATNetworkName;
900#ifdef VBOX_WITH_CLOUD_NET
901 com::Utf8Str strCloudNetworkName;
902#endif /* VBOX_WITH_CLOUD_NET */
903 uint32_t ulBootPriority;
904 com::Utf8Str strBandwidthGroup; // requires settings version 1.13 (VirtualBox 4.2)
905};
906
907typedef std::list<NetworkAdapter> NetworkAdaptersList;
908
909/**
910 * NOTE: If you add any fields in here, you must update a) the constructor and b)
911 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
912 * your settings might never get saved.
913 */
914struct SerialPort
915{
916 SerialPort();
917
918 bool operator==(const SerialPort &n) const;
919
920 uint32_t ulSlot;
921
922 bool fEnabled;
923 uint32_t ulIOBase;
924 uint32_t ulIRQ;
925 PortMode_T portMode;
926 com::Utf8Str strPath;
927 bool fServer;
928 UartType_T uartType;
929};
930
931typedef std::list<SerialPort> SerialPortsList;
932
933/**
934 * NOTE: If you add any fields in here, you must update a) the constructor and b)
935 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
936 * your settings might never get saved.
937 */
938struct ParallelPort
939{
940 ParallelPort();
941
942 bool operator==(const ParallelPort &d) const;
943
944 uint32_t ulSlot;
945
946 bool fEnabled;
947 uint32_t ulIOBase;
948 uint32_t ulIRQ;
949 com::Utf8Str strPath;
950};
951
952typedef std::list<ParallelPort> ParallelPortsList;
953
954/**
955 * NOTE: If you add any fields in here, you must update a) the constructor and b)
956 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
957 * your settings might never get saved.
958 */
959struct AudioAdapter
960{
961 AudioAdapter();
962
963 bool areDefaultSettings(SettingsVersion_T sv) const;
964
965 bool operator==(const AudioAdapter &a) const;
966
967 bool fEnabled;
968 bool fEnabledIn;
969 bool fEnabledOut;
970 AudioControllerType_T controllerType;
971 AudioCodecType_T codecType;
972 AudioDriverType_T driverType;
973 settings::StringsMap properties;
974};
975
976/**
977 * NOTE: If you add any fields in here, you must update a) the constructor and b)
978 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
979 * your settings might never get saved.
980 */
981struct SharedFolder
982{
983 SharedFolder();
984
985 bool operator==(const SharedFolder &a) const;
986
987 com::Utf8Str strName,
988 strHostPath;
989 bool fWritable;
990 bool fAutoMount;
991 com::Utf8Str strAutoMountPoint;
992};
993
994typedef std::list<SharedFolder> SharedFoldersList;
995
996/**
997 * NOTE: If you add any fields in here, you must update a) the constructor and b)
998 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
999 * your settings might never get saved.
1000 */
1001struct GuestProperty
1002{
1003 GuestProperty();
1004
1005 bool operator==(const GuestProperty &g) const;
1006
1007 com::Utf8Str strName,
1008 strValue;
1009 uint64_t timestamp;
1010 com::Utf8Str strFlags;
1011};
1012
1013typedef std::list<GuestProperty> GuestPropertiesList;
1014
1015typedef std::map<uint32_t, DeviceType_T> BootOrderMap;
1016
1017/**
1018 * NOTE: If you add any fields in here, you must update a) the constructor and b)
1019 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
1020 * your settings might never get saved.
1021 */
1022struct CpuIdLeaf
1023{
1024 CpuIdLeaf();
1025
1026 bool operator==(const CpuIdLeaf &c) const;
1027
1028 uint32_t idx;
1029 uint32_t idxSub;
1030 uint32_t uEax;
1031 uint32_t uEbx;
1032 uint32_t uEcx;
1033 uint32_t uEdx;
1034};
1035
1036typedef std::list<CpuIdLeaf> CpuIdLeafsList;
1037
1038/**
1039 * NOTE: If you add any fields in here, you must update a) the constructor and b)
1040 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
1041 * your settings might never get saved.
1042 */
1043struct Cpu
1044{
1045 Cpu();
1046
1047 bool operator==(const Cpu &c) const;
1048
1049 uint32_t ulId;
1050};
1051
1052typedef std::list<Cpu> CpuList;
1053
1054/**
1055 * NOTE: If you add any fields in here, you must update a) the constructor and b)
1056 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
1057 * your settings might never get saved.
1058 */
1059struct BandwidthGroup
1060{
1061 BandwidthGroup();
1062
1063 bool operator==(const BandwidthGroup &i) const;
1064
1065 com::Utf8Str strName;
1066 uint64_t cMaxBytesPerSec;
1067 BandwidthGroupType_T enmType;
1068};
1069
1070typedef std::list<BandwidthGroup> BandwidthGroupList;
1071
1072/**
1073 * NOTE: If you add any fields in here, you must update a) the constructor and b)
1074 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
1075 * your settings might never get saved.
1076 */
1077struct IOSettings
1078{
1079 IOSettings();
1080
1081 bool areIOCacheDefaultSettings() const;
1082 bool areDefaultSettings() const;
1083
1084 bool operator==(const IOSettings &i) const;
1085
1086 bool fIOCacheEnabled;
1087 uint32_t ulIOCacheSize;
1088 BandwidthGroupList llBandwidthGroups;
1089};
1090
1091/**
1092 * NOTE: If you add any fields in here, you must update a) the constructor and b)
1093 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
1094 * your settings might never get saved.
1095 */
1096struct HostPCIDeviceAttachment
1097{
1098 HostPCIDeviceAttachment();
1099
1100 bool operator==(const HostPCIDeviceAttachment &a) const;
1101
1102 com::Utf8Str strDeviceName;
1103 uint32_t uHostAddress;
1104 uint32_t uGuestAddress;
1105};
1106
1107typedef std::list<HostPCIDeviceAttachment> HostPCIDeviceAttachmentList;
1108
1109/**
1110 * A device attached to a storage controller. This can either be a
1111 * hard disk or a DVD drive or a floppy drive and also specifies
1112 * which medium is "in" the drive; as a result, this is a combination
1113 * of the Main IMedium and IMediumAttachment interfaces.
1114 *
1115 * NOTE: If you add any fields in here, you must update a) the constructor and b)
1116 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
1117 * your settings might never get saved.
1118 */
1119struct AttachedDevice
1120{
1121 AttachedDevice();
1122
1123 bool operator==(const AttachedDevice &a) const;
1124
1125 DeviceType_T deviceType; // only HardDisk, DVD or Floppy are allowed
1126
1127 // DVDs can be in pass-through mode:
1128 bool fPassThrough;
1129
1130 // Whether guest-triggered eject of DVDs will keep the medium in the
1131 // VM config or not:
1132 bool fTempEject;
1133
1134 // Whether the medium is non-rotational:
1135 bool fNonRotational;
1136
1137 // Whether the medium supports discarding unused blocks:
1138 bool fDiscard;
1139
1140 // Whether the medium is hot-pluggable:
1141 bool fHotPluggable;
1142
1143 int32_t lPort;
1144 int32_t lDevice;
1145
1146 // if an image file is attached to the device (ISO, RAW, or hard disk image such as VDI),
1147 // this is its UUID; it depends on deviceType which media registry this then needs to
1148 // be looked up in. If no image file (only permitted for DVDs and floppies), then the UUID is NULL
1149 com::Guid uuid;
1150
1151 // for DVDs and floppies, the attachment can also be a host device:
1152 com::Utf8Str strHostDriveSrc; // if != NULL, value of <HostDrive>/@src
1153
1154 // Bandwidth group the device is attached to.
1155 com::Utf8Str strBwGroup;
1156};
1157
1158typedef std::list<AttachedDevice> AttachedDevicesList;
1159
1160/**
1161 * NOTE: If you add any fields in here, you must update a) the constructor and b)
1162 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
1163 * your settings might never get saved.
1164 */
1165struct StorageController
1166{
1167 StorageController();
1168
1169 bool operator==(const StorageController &s) const;
1170
1171 com::Utf8Str strName;
1172 StorageBus_T storageBus; // _SATA, _SCSI, _IDE, _SAS
1173 StorageControllerType_T controllerType;
1174 uint32_t ulPortCount;
1175 uint32_t ulInstance;
1176 bool fUseHostIOCache;
1177 bool fBootable;
1178
1179 // only for when controllerType == StorageControllerType_IntelAhci:
1180 int32_t lIDE0MasterEmulationPort,
1181 lIDE0SlaveEmulationPort,
1182 lIDE1MasterEmulationPort,
1183 lIDE1SlaveEmulationPort;
1184
1185 AttachedDevicesList llAttachedDevices;
1186};
1187
1188typedef std::list<StorageController> StorageControllersList;
1189
1190/**
1191 * We wrap the storage controllers list into an extra struct so we can
1192 * use an undefined struct without needing std::list<> in all the headers.
1193 *
1194 * NOTE: If you add any fields in here, you must update a) the constructor and b)
1195 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
1196 * your settings might never get saved.
1197 */
1198struct Storage
1199{
1200 bool operator==(const Storage &s) const;
1201
1202 StorageControllersList llStorageControllers;
1203};
1204
1205/**
1206 * Representation of Machine hardware; this is used in the MachineConfigFile.hardwareMachine
1207 * field.
1208 *
1209 * NOTE: If you add any fields in here, you must update a) the constructor and b)
1210 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
1211 * your settings might never get saved.
1212 */
1213struct Hardware
1214{
1215 Hardware();
1216
1217 bool areParavirtDefaultSettings(SettingsVersion_T sv) const;
1218 bool areBootOrderDefaultSettings() const;
1219 bool areDisplayDefaultSettings() const;
1220 bool areAllNetworkAdaptersDefaultSettings(SettingsVersion_T sv) const;
1221
1222 bool operator==(const Hardware&) const;
1223
1224 com::Utf8Str strVersion; // hardware version, optional
1225 com::Guid uuid; // hardware uuid, optional (null).
1226
1227 bool fHardwareVirt,
1228 fNestedPaging,
1229 fLargePages,
1230 fVPID,
1231 fUnrestrictedExecution,
1232 fHardwareVirtForce,
1233 fUseNativeApi,
1234 fSyntheticCpu,
1235 fTripleFaultReset,
1236 fPAE,
1237 fAPIC, // requires settings version 1.16 (VirtualBox 5.1)
1238 fX2APIC; // requires settings version 1.16 (VirtualBox 5.1)
1239 bool fIBPBOnVMExit; //< added out of cycle, after 1.16 was out.
1240 bool fIBPBOnVMEntry; //< added out of cycle, after 1.16 was out.
1241 bool fSpecCtrl; //< added out of cycle, after 1.16 was out.
1242 bool fSpecCtrlByHost; //< added out of cycle, after 1.16 was out.
1243 bool fL1DFlushOnSched ; //< added out of cycle, after 1.16 was out.
1244 bool fL1DFlushOnVMEntry ; //< added out of cycle, after 1.16 was out.
1245 bool fMDSClearOnSched; //< added out of cycle, after 1.16 was out.
1246 bool fMDSClearOnVMEntry; //< added out of cycle, after 1.16 was out.
1247 bool fNestedHWVirt; //< requires settings version 1.17 (VirtualBox 6.0)
1248 bool fVirtVmsaveVmload; //< requires settings version 1.18 (VirtualBox 6.1)
1249 typedef enum LongModeType { LongMode_Enabled, LongMode_Disabled, LongMode_Legacy } LongModeType;
1250 LongModeType enmLongMode;
1251 uint32_t cCPUs;
1252 bool fCpuHotPlug; // requires settings version 1.10 (VirtualBox 3.2)
1253 CpuList llCpus; // requires settings version 1.10 (VirtualBox 3.2)
1254 bool fHPETEnabled; // requires settings version 1.10 (VirtualBox 3.2)
1255 uint32_t ulCpuExecutionCap; // requires settings version 1.11 (VirtualBox 3.3)
1256 uint32_t uCpuIdPortabilityLevel; // requires settings version 1.15 (VirtualBox 5.0)
1257 com::Utf8Str strCpuProfile; // requires settings version 1.16 (VirtualBox 5.1)
1258
1259 CpuIdLeafsList llCpuIdLeafs;
1260
1261 uint32_t ulMemorySizeMB;
1262
1263 BootOrderMap mapBootOrder; // item 0 has highest priority
1264
1265 FirmwareType_T firmwareType; // requires settings version 1.9 (VirtualBox 3.1)
1266
1267 PointingHIDType_T pointingHIDType; // requires settings version 1.10 (VirtualBox 3.2)
1268 KeyboardHIDType_T keyboardHIDType; // requires settings version 1.10 (VirtualBox 3.2)
1269
1270 ChipsetType_T chipsetType; // requires settings version 1.11 (VirtualBox 4.0)
1271 IommuType_T iommuType; // requires settings version 1.19 (VirtualBox 6.2)
1272 ParavirtProvider_T paravirtProvider; // requires settings version 1.15 (VirtualBox 4.4)
1273 com::Utf8Str strParavirtDebug; // requires settings version 1.16 (VirtualBox 5.1)
1274
1275 bool fEmulatedUSBCardReader; // 1.12 (VirtualBox 4.1)
1276
1277 VRDESettings vrdeSettings;
1278
1279 BIOSSettings biosSettings;
1280 NvramSettings nvramSettings;
1281 GraphicsAdapter graphicsAdapter;
1282 USB usbSettings;
1283 TpmSettings tpmSettings; // requires settings version 1.19 (VirtualBox 6.2)
1284 NetworkAdaptersList llNetworkAdapters;
1285 SerialPortsList llSerialPorts;
1286 ParallelPortsList llParallelPorts;
1287 AudioAdapter audioAdapter;
1288 Storage storage;
1289
1290 // technically these two have no business in the hardware section, but for some
1291 // clever reason <Hardware> is where they are in the XML....
1292 SharedFoldersList llSharedFolders;
1293
1294 ClipboardMode_T clipboardMode;
1295 bool fClipboardFileTransfersEnabled;
1296
1297 DnDMode_T dndMode;
1298
1299 uint32_t ulMemoryBalloonSize;
1300 bool fPageFusionEnabled;
1301
1302 GuestPropertiesList llGuestProperties;
1303
1304 IOSettings ioSettings; // requires settings version 1.10 (VirtualBox 3.2)
1305 HostPCIDeviceAttachmentList pciAttachments; // requires settings version 1.12 (VirtualBox 4.1)
1306
1307 com::Utf8Str strDefaultFrontend; // requires settings version 1.14 (VirtualBox 4.3)
1308};
1309
1310/**
1311 * Settings that has to do with debugging.
1312 */
1313struct Debugging
1314{
1315 Debugging();
1316
1317 bool areDefaultSettings() const;
1318
1319 bool operator==(const Debugging &rOther) const;
1320
1321 bool fTracingEnabled;
1322 bool fAllowTracingToAccessVM;
1323 com::Utf8Str strTracingConfig;
1324};
1325
1326/**
1327 * Settings that has to do with autostart.
1328 */
1329struct Autostart
1330{
1331 Autostart();
1332
1333 bool areDefaultSettings() const;
1334
1335 bool operator==(const Autostart &rOther) const;
1336
1337 bool fAutostartEnabled;
1338 uint32_t uAutostartDelay;
1339 AutostopType_T enmAutostopType;
1340};
1341
1342struct Snapshot;
1343typedef std::list<Snapshot> SnapshotsList;
1344
1345/**
1346 * NOTE: If you add any fields in here, you must update a) the constructor and b)
1347 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
1348 * your settings might never get saved.
1349 */
1350struct Snapshot
1351{
1352 Snapshot();
1353
1354 bool operator==(const Snapshot &s) const;
1355
1356 com::Guid uuid;
1357 com::Utf8Str strName,
1358 strDescription; // optional
1359 RTTIMESPEC timestamp;
1360
1361 com::Utf8Str strStateFile; // for online snapshots only
1362
1363 Hardware hardware;
1364
1365 Debugging debugging;
1366 Autostart autostart;
1367 RecordingSettings recordingSettings;
1368
1369 SnapshotsList llChildSnapshots;
1370
1371 static const struct Snapshot Empty;
1372};
1373
1374/**
1375 * NOTE: If you add any fields in here, you must update a) the constructor and b)
1376 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
1377 * your settings might never get saved.
1378 */
1379struct MachineUserData
1380{
1381 MachineUserData();
1382
1383 bool operator==(const MachineUserData &c) const;
1384
1385 com::Utf8Str strName;
1386 bool fDirectoryIncludesUUID;
1387 bool fNameSync;
1388 com::Utf8Str strDescription;
1389 StringsList llGroups;
1390 com::Utf8Str strOsType;
1391 com::Utf8Str strSnapshotFolder;
1392 bool fTeleporterEnabled;
1393 uint32_t uTeleporterPort;
1394 com::Utf8Str strTeleporterAddress;
1395 com::Utf8Str strTeleporterPassword;
1396 bool fRTCUseUTC;
1397 IconBlob ovIcon;
1398 VMProcPriority_T enmVMPriority;
1399};
1400
1401
1402/**
1403 * MachineConfigFile represents an XML machine configuration. All the machine settings
1404 * that go out to the XML (or are read from it) are in here.
1405 *
1406 * NOTE: If you add any fields in here, you must update a) the constructor and b)
1407 * the operator== which is used by Machine::saveSettings(), or otherwise your settings
1408 * might never get saved.
1409 */
1410class MachineConfigFile : public ConfigFileBase
1411{
1412public:
1413 com::Guid uuid;
1414
1415 enum
1416 {
1417 ParseState_NotParsed,
1418 ParseState_PasswordError,
1419 ParseState_Parsed
1420 } enmParseState;
1421
1422 MachineUserData machineUserData;
1423
1424 com::Utf8Str strStateKeyId;
1425 com::Utf8Str strStateKeyStore;
1426 com::Utf8Str strStateFile;
1427 bool fCurrentStateModified; // optional, default is true
1428 RTTIMESPEC timeLastStateChange; // optional, defaults to now
1429 bool fAborted; // optional, default is false
1430
1431 com::Guid uuidCurrentSnapshot;
1432
1433 Hardware hardwareMachine;
1434 MediaRegistry mediaRegistry;
1435 Debugging debugging;
1436 Autostart autostart;
1437 RecordingSettings recordingSettings;
1438
1439 StringsMap mapExtraDataItems;
1440
1441 SnapshotsList llFirstSnapshot; // first snapshot or empty list if there's none
1442
1443 com::Utf8Str strKeyId;
1444 com::Utf8Str strKeyStore; // if not empty, the encryption is used
1445 com::Utf8Str strLogKeyId;
1446 com::Utf8Str strLogKeyStore;
1447
1448 MachineConfigFile(const com::Utf8Str *pstrFilename,
1449 PCVBOXCRYPTOIF pCryptoIf = NULL,
1450 const char *pszPassword = NULL);
1451
1452 bool operator==(const MachineConfigFile &m) const;
1453
1454 bool canHaveOwnMediaRegistry() const;
1455
1456 void importMachineXML(const xml::ElementNode &elmMachine);
1457
1458 void write(const com::Utf8Str &strFilename, PCVBOXCRYPTOIF pCryptoIf = NULL, const char *pszPassword = NULL);
1459
1460 enum
1461 {
1462 BuildMachineXML_IncludeSnapshots = 0x01,
1463 BuildMachineXML_WriteVBoxVersionAttribute = 0x02,
1464 BuildMachineXML_SkipRemovableMedia = 0x04,
1465 BuildMachineXML_MediaRegistry = 0x08,
1466 BuildMachineXML_SuppressSavedState = 0x10
1467 };
1468
1469 void copyEncryptionSettingsFrom(const MachineConfigFile &other);
1470 void buildMachineXML(xml::ElementNode &elmMachine,
1471 uint32_t fl,
1472 std::list<xml::ElementNode*> *pllElementsWithUuidAttributes);
1473
1474 static bool isAudioDriverAllowedOnThisHost(AudioDriverType_T enmDrvType);
1475 static AudioDriverType_T getHostDefaultAudioDriver();
1476
1477private:
1478 void readNetworkAdapters(const xml::ElementNode &elmHardware, NetworkAdaptersList &ll);
1479 void readAttachedNetworkMode(const xml::ElementNode &pelmMode, bool fEnabled, NetworkAdapter &nic);
1480 void readCpuIdTree(const xml::ElementNode &elmCpuid, CpuIdLeafsList &ll);
1481 void readCpuTree(const xml::ElementNode &elmCpu, CpuList &ll);
1482 void readSerialPorts(const xml::ElementNode &elmUART, SerialPortsList &ll);
1483 void readParallelPorts(const xml::ElementNode &elmLPT, ParallelPortsList &ll);
1484 void readAudioAdapter(const xml::ElementNode &elmAudioAdapter, AudioAdapter &aa);
1485 void readGuestProperties(const xml::ElementNode &elmGuestProperties, Hardware &hw);
1486 void readStorageControllerAttributes(const xml::ElementNode &elmStorageController, StorageController &sctl);
1487 void readHardware(const xml::ElementNode &elmHardware, Hardware &hw);
1488 void readHardDiskAttachments_pre1_7(const xml::ElementNode &elmHardDiskAttachments, Storage &strg);
1489 void readStorageControllers(const xml::ElementNode &elmStorageControllers, Storage &strg);
1490 void readDVDAndFloppies_pre1_9(const xml::ElementNode &elmHardware, Storage &strg);
1491 void readTeleporter(const xml::ElementNode &elmTeleporter, MachineUserData &userData);
1492 void readDebugging(const xml::ElementNode &elmDbg, Debugging &dbg);
1493 void readAutostart(const xml::ElementNode &elmAutostart, Autostart &autostrt);
1494 void readRecordingSettings(const xml::ElementNode &elmRecording, uint32_t cMonitors, RecordingSettings &recording);
1495 void readGroups(const xml::ElementNode &elmGroups, StringsList &llGroups);
1496 bool readSnapshot(const com::Guid &curSnapshotUuid, const xml::ElementNode &elmSnapshot, Snapshot &snap);
1497 void convertOldOSType_pre1_5(com::Utf8Str &str);
1498 void readMachine(const xml::ElementNode &elmMachine);
1499 void readMachineEncrypted(const xml::ElementNode &elmMachine, PCVBOXCRYPTOIF pCryptoIf, const char *pszPassword);
1500
1501 void buildHardwareXML(xml::ElementNode &elmParent, const Hardware &hw, uint32_t fl, std::list<xml::ElementNode*> *pllElementsWithUuidAttributes);
1502 void buildNetworkXML(NetworkAttachmentType_T mode, bool fEnabled, xml::ElementNode &elmParent, const NetworkAdapter &nic);
1503 void buildStorageControllersXML(xml::ElementNode &elmParent,
1504 const Storage &st,
1505 bool fSkipRemovableMedia,
1506 std::list<xml::ElementNode*> *pllElementsWithUuidAttributes);
1507 void buildDebuggingXML(xml::ElementNode &elmParent, const Debugging &dbg);
1508 void buildAutostartXML(xml::ElementNode &elmParent, const Autostart &autostrt);
1509 void buildRecordingXML(xml::ElementNode &elmParent, const RecordingSettings &recording);
1510 void buildGroupsXML(xml::ElementNode &elmParent, const StringsList &llGroups);
1511 void buildSnapshotXML(xml::ElementNode &elmParent, const Snapshot &snap);
1512
1513 void buildMachineEncryptedXML(xml::ElementNode &elmMachine,
1514 uint32_t fl,
1515 std::list<xml::ElementNode*> *pllElementsWithUuidAttributes,
1516 PCVBOXCRYPTOIF pCryptoIf,
1517 const char *pszPassword);
1518
1519 void bumpSettingsVersionIfNeeded();
1520};
1521
1522} // namespace settings
1523
1524
1525#endif /* !VBOX_INCLUDED_settings_h */
Note: See TracBrowser for help on using the repository browser.

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