VirtualBox

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

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

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