VirtualBox

source: vbox/trunk/src/VBox/Main/include/VirtualBoxImpl.h@ 86506

Last change on this file since 86506 was 86501, checked in by vboxsync, 4 years ago

VBoxSVC: Fix Medium leak when encoutering duplicate instances while loading a media registry (from settings) via VirtualBox::initMedia(). The media registration is now moved to before any children are loaded, so that we use the right parent for them. This essentially changes the operation to a merge. An unaddressed issue is that on child load failure, we will leave the parent(s) still registered but non-functioning (uninit was done). (The old code would just leave any successfully loaded children registered with non-working parents only accessible via their parent attribute.) bugref:9841
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 20.1 KB
Line 
1/* $Id: VirtualBoxImpl.h 86501 2020-10-09 12:28:32Z vboxsync $ */
2/** @file
3 * VirtualBox COM class implementation
4 */
5
6/*
7 * Copyright (C) 2006-2020 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#ifndef MAIN_INCLUDED_VirtualBoxImpl_h
19#define MAIN_INCLUDED_VirtualBoxImpl_h
20#ifndef RT_WITHOUT_PRAGMA_ONCE
21# pragma once
22#endif
23
24#include "VirtualBoxBase.h"
25#include "objectslist.h"
26#include "VirtualBoxWrap.h"
27
28#ifdef RT_OS_WINDOWS
29# include "win/resource.h"
30#endif
31
32//#ifdef DEBUG_bird
33//# define VBOXSVC_WITH_CLIENT_WATCHER
34//#endif
35
36namespace com
37{
38 class Event;
39 class EventQueue;
40}
41
42class SessionMachine;
43class GuestOSType;
44class Progress;
45class Host;
46class SystemProperties;
47class DHCPServer;
48class PerformanceCollector;
49class CloudProviderManager;
50#ifdef VBOX_WITH_EXTPACK
51class ExtPackManager;
52#endif
53class AutostartDb;
54class NATNetwork;
55#ifdef VBOX_WITH_CLOUD_NET
56class CloudNetwork;
57#endif /* VBOX_WITH_CLOUD_NET */
58
59
60typedef std::list<ComObjPtr<SessionMachine> > SessionMachinesList;
61
62#ifdef RT_OS_WINDOWS
63class SVCHlpClient;
64#endif
65
66namespace settings
67{
68 class MainConfigFile;
69 struct MediaRegistry;
70}
71
72
73#if defined(VBOX_WITH_SDS) && !defined(VBOX_WITH_XPCOM)
74class VirtualBoxClassFactory; /* See ../src-server/win/svcmain.cpp */
75#endif
76
77#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
78struct SharedClipboardAreaData;
79#endif
80
81class ATL_NO_VTABLE VirtualBox :
82 public VirtualBoxWrap
83#ifdef RT_OS_WINDOWS
84 , public ATL::CComCoClass<VirtualBox, &CLSID_VirtualBox>
85#endif
86{
87
88public:
89
90 typedef std::list<ComPtr<IInternalSessionControl> > InternalControlList;
91 typedef ObjectsList<Machine> MachinesOList;
92
93#if 0 /* obsoleted by AsyncEvent */
94 class CallbackEvent;
95 friend class CallbackEvent;
96#endif
97 class AsyncEvent;
98 friend class AsyncEvent;
99
100#ifndef VBOX_WITH_XPCOM
101# ifdef VBOX_WITH_SDS
102 DECLARE_CLASSFACTORY_EX(VirtualBoxClassFactory)
103# else
104 DECLARE_CLASSFACTORY_SINGLETON(VirtualBox)
105# endif
106#endif
107
108 // Do not use any ATL registry support.
109 //DECLARE_REGISTRY_RESOURCEID(IDR_VIRTUALBOX)
110
111 // Kind of redundant (VirtualBoxWrap declares itself not aggregatable and
112 // CComCoClass<VirtualBox, &CLSID_VirtualBox> as aggregatable, the former
113 // is the first inheritance), but the C++ multiple inheritance rules and
114 // the class factory in svcmain.cpp needs this to disambiguate.
115 DECLARE_NOT_AGGREGATABLE(VirtualBox)
116
117 // to postpone generation of the default ctor/dtor
118 DECLARE_EMPTY_CTOR_DTOR(VirtualBox)
119
120 HRESULT FinalConstruct();
121 void FinalRelease();
122
123 // public initializer/uninitializer for internal purposes only
124 HRESULT init();
125 HRESULT initMachines();
126 HRESULT initMedia(const Guid &uuidMachineRegistry,
127 const settings::MediaRegistry &mediaRegistry,
128 const Utf8Str &strMachineFolder);
129 void uninit();
130
131 // public methods only for internal purposes
132
133 /**
134 * Override of the default locking class to be used for validating lock
135 * order with the standard member lock handle.
136 */
137 virtual VBoxLockingClass getLockingClass() const
138 {
139 return LOCKCLASS_VIRTUALBOXOBJECT;
140 }
141
142#ifdef DEBUG
143 void i_dumpAllBackRefs();
144#endif
145
146 HRESULT i_postEvent(Event *event);
147
148 HRESULT i_addProgress(IProgress *aProgress);
149 HRESULT i_removeProgress(IN_GUID aId);
150
151#ifdef RT_OS_WINDOWS
152 typedef DECLCALLBACKPTR(HRESULT, SVCHelperClientFunc,(SVCHlpClient *aClient, Progress *aProgress, void *aUser, int *aVrc));
153 HRESULT i_startSVCHelperClient(bool aPrivileged,
154 SVCHelperClientFunc aFunc,
155 void *aUser, Progress *aProgress);
156#endif
157
158 void i_addProcessToReap(RTPROCESS pid);
159 void i_updateClientWatcher();
160
161 int i_loadVDPlugin(const char *pszPluginLibrary);
162 int i_unloadVDPlugin(const char *pszPluginLibrary);
163
164 void i_onMediumRegistered(const Guid &aMediumId, const DeviceType_T aDevType, const BOOL aRegistered);
165 void i_onMediumConfigChanged(IMedium *aMedium);
166 void i_onMediumChanged(IMediumAttachment* aMediumAttachment);
167 void i_onStorageControllerChanged(const Guid &aMachineId, const com::Utf8Str &aControllerName);
168 void i_onStorageDeviceChanged(IMediumAttachment* aStorageDevice, const BOOL fRemoved, const BOOL fSilent);
169 void i_onMachineStateChanged(const Guid &aId, MachineState_T aState);
170 void i_onMachineDataChanged(const Guid &aId, BOOL aTemporary = FALSE);
171 BOOL i_onExtraDataCanChange(const Guid &aId, const Utf8Str &aKey, const Utf8Str &aValue, Bstr &aError);
172 void i_onExtraDataChanged(const Guid &aId, const Utf8Str &aKey, const Utf8Str &aValue);
173 void i_onMachineRegistered(const Guid &aId, BOOL aRegistered);
174 void i_onSessionStateChanged(const Guid &aId, SessionState_T aState);
175
176 void i_onSnapshotTaken(const Guid &aMachineId, const Guid &aSnapshotId);
177 void i_onSnapshotDeleted(const Guid &aMachineId, const Guid &aSnapshotId);
178 void i_onSnapshotRestored(const Guid &aMachineId, const Guid &aSnapshotId);
179 void i_onSnapshotChanged(const Guid &aMachineId, const Guid &aSnapshotId);
180
181#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
182 int i_clipboardAreaCreate(ULONG uAreaID, uint32_t fFlags, SharedClipboardAreaData **ppAreaData);
183 int i_clipboardAreaDestroy(SharedClipboardAreaData *pAreaData);
184
185 HRESULT i_onClipboardAreaRegister(const std::vector<com::Utf8Str> &aParms, ULONG *aID);
186 HRESULT i_onClipboardAreaUnregister(ULONG aID);
187 HRESULT i_onClipboardAreaAttach(ULONG aID);
188 HRESULT i_onClipboardAreaDetach(ULONG aID);
189 ULONG i_onClipboardAreaGetMostRecent(void);
190 ULONG i_onClipboardAreaGetRefCount(ULONG aID);
191#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
192
193 void i_onGuestPropertyChanged(const Guid &aMachineId, const Utf8Str &aName, const Utf8Str &aValue, const Utf8Str &aFlags);
194 void i_onNatRedirectChanged(const Guid &aMachineId, ULONG ulSlot, bool fRemove, const Utf8Str &aName,
195 NATProtocol_T aProto, const Utf8Str &aHostIp, uint16_t aHostPort,
196 const Utf8Str &aGuestIp, uint16_t aGuestPort);
197 void i_onNATNetworkChanged(const Utf8Str &aNetworkName);
198 void i_onNATNetworkStartStop(const Utf8Str &aNetworkName, BOOL aStart);
199 void i_onNATNetworkSetting(const Utf8Str &aNetworkName, BOOL aEnabled, const Utf8Str &aNetwork,
200 const Utf8Str &aGateway, BOOL aAdvertiseDefaultIpv6RouteEnabled,
201 BOOL fNeedDhcpServer);
202 void i_onNATNetworkPortForward(const Utf8Str &aNetworkName, BOOL create, BOOL fIpv6,
203 const Utf8Str &aRuleName, NATProtocol_T proto,
204 const Utf8Str &aHostIp, LONG aHostPort,
205 const Utf8Str &aGuestIp, LONG aGuestPort);
206 void i_onHostNameResolutionConfigurationChange();
207
208 int i_natNetworkRefInc(const Utf8Str &aNetworkName);
209 int i_natNetworkRefDec(const Utf8Str &aNetworkName);
210
211 void i_onCloudProviderListChanged(BOOL aRegistered);
212 void i_onCloudProviderRegistered(const Utf8Str &aProviderId, BOOL aRegistered);
213 void i_onCloudProviderUninstall(const Utf8Str &aProviderId);
214
215#ifdef VBOX_WITH_CLOUD_NET
216 HRESULT i_findCloudNetworkByName(const com::Utf8Str &aNetworkName,
217 ComObjPtr<CloudNetwork> *aNetwork = NULL);
218 HRESULT i_getEventSource(ComPtr<IEventSource>& aSource);
219#endif /* VBOX_WITH_CLOUD_NET */
220
221 ComObjPtr<GuestOSType> i_getUnknownOSType();
222
223 void i_getOpenedMachines(SessionMachinesList &aMachines,
224 InternalControlList *aControls = NULL);
225 MachinesOList &i_getMachinesList();
226
227 HRESULT i_findMachine(const Guid &aId,
228 bool fPermitInaccessible,
229 bool aSetError,
230 ComObjPtr<Machine> *aMachine = NULL);
231
232 HRESULT i_findMachineByName(const Utf8Str &aName,
233 bool aSetError,
234 ComObjPtr<Machine> *aMachine = NULL);
235
236 HRESULT i_validateMachineGroup(const com::Utf8Str &aGroup, bool fPrimary);
237 HRESULT i_convertMachineGroups(const std::vector<com::Utf8Str> aMachineGroups, StringsList *pllMachineGroups);
238
239 HRESULT i_findHardDiskById(const Guid &id,
240 bool aSetError,
241 ComObjPtr<Medium> *aHardDisk = NULL);
242 HRESULT i_findHardDiskByLocation(const Utf8Str &strLocation,
243 bool aSetError,
244 ComObjPtr<Medium> *aHardDisk = NULL);
245 HRESULT i_findDVDOrFloppyImage(DeviceType_T mediumType,
246 const Guid *aId,
247 const Utf8Str &aLocation,
248 bool aSetError,
249 ComObjPtr<Medium> *aImage = NULL);
250 HRESULT i_findRemoveableMedium(DeviceType_T mediumType,
251 const Guid &uuid,
252 bool fRefresh,
253 bool aSetError,
254 ComObjPtr<Medium> &pMedium);
255
256 HRESULT i_findGuestOSType(const Utf8Str &strOSType,
257 ComObjPtr<GuestOSType> &guestOSType);
258
259 const Guid &i_getGlobalRegistryId() const;
260
261 const ComObjPtr<Host> &i_host() const;
262 SystemProperties *i_getSystemProperties() const;
263 CloudProviderManager *i_getCloudProviderManager() const;
264#ifdef VBOX_WITH_EXTPACK
265 ExtPackManager *i_getExtPackManager() const;
266#endif
267#ifdef VBOX_WITH_RESOURCE_USAGE_API
268 const ComObjPtr<PerformanceCollector> &i_performanceCollector() const;
269#endif /* VBOX_WITH_RESOURCE_USAGE_API */
270
271 void i_getDefaultMachineFolder(Utf8Str &str) const;
272 void i_getDefaultHardDiskFormat(Utf8Str &str) const;
273
274 /** Returns the VirtualBox home directory */
275 const Utf8Str &i_homeDir() const;
276 int i_calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult);
277 void i_copyPathRelativeToConfig(const Utf8Str &strSource, Utf8Str &strTarget);
278 HRESULT i_registerMedium(const ComObjPtr<Medium> &pMedium, ComObjPtr<Medium> *ppMedium,
279 AutoWriteLock &mediaTreeLock, bool fCalledFromMediumInit = false);
280 HRESULT i_unregisterMedium(Medium *pMedium);
281 void i_pushMediumToListWithChildren(MediaList &llMedia, Medium *pMedium);
282 HRESULT i_unregisterMachineMedia(const Guid &id);
283 HRESULT i_unregisterMachine(Machine *pMachine, const Guid &id);
284 void i_rememberMachineNameChangeForMedia(const Utf8Str &strOldConfigDir,
285 const Utf8Str &strNewConfigDir);
286 void i_saveMediaRegistry(settings::MediaRegistry &mediaRegistry,
287 const Guid &uuidRegistry,
288 const Utf8Str &strMachineFolder);
289 HRESULT i_saveSettings();
290 void i_markRegistryModified(const Guid &uuid);
291 void i_unmarkRegistryModified(const Guid &uuid);
292 void i_saveModifiedRegistries();
293 static const com::Utf8Str &i_getVersionNormalized();
294 static HRESULT i_ensureFilePathExists(const Utf8Str &strFileName, bool fCreate);
295 const Utf8Str& i_settingsFilePath();
296 AutostartDb* i_getAutostartDb() const;
297 RWLockHandle& i_getMachinesListLockHandle();
298 RWLockHandle& i_getMediaTreeLockHandle();
299 int i_encryptSetting(const Utf8Str &aPlaintext, Utf8Str *aCiphertext);
300 int i_decryptSetting(Utf8Str *aPlaintext, const Utf8Str &aCiphertext);
301 void i_storeSettingsKey(const Utf8Str &aKey);
302 bool i_isMediaUuidInUse(const Guid &aId, DeviceType_T deviceType);
303
304
305
306private:
307 class ClientWatcher;
308
309 // wrapped IVirtualBox properties
310 HRESULT getVersion(com::Utf8Str &aVersion);
311 HRESULT getVersionNormalized(com::Utf8Str &aVersionNormalized);
312 HRESULT getRevision(ULONG *aRevision);
313 HRESULT getPackageType(com::Utf8Str &aPackageType);
314 HRESULT getAPIVersion(com::Utf8Str &aAPIVersion);
315 HRESULT getAPIRevision(LONG64 *aAPIRevision);
316 HRESULT getHomeFolder(com::Utf8Str &aHomeFolder);
317 HRESULT getSettingsFilePath(com::Utf8Str &aSettingsFilePath);
318 HRESULT getHost(ComPtr<IHost> &aHost);
319 HRESULT getSystemProperties(ComPtr<ISystemProperties> &aSystemProperties);
320 HRESULT getMachines(std::vector<ComPtr<IMachine> > &aMachines);
321 HRESULT getMachineGroups(std::vector<com::Utf8Str> &aMachineGroups);
322 HRESULT getHardDisks(std::vector<ComPtr<IMedium> > &aHardDisks);
323 HRESULT getDVDImages(std::vector<ComPtr<IMedium> > &aDVDImages);
324 HRESULT getFloppyImages(std::vector<ComPtr<IMedium> > &aFloppyImages);
325 HRESULT getProgressOperations(std::vector<ComPtr<IProgress> > &aProgressOperations);
326 HRESULT getGuestOSTypes(std::vector<ComPtr<IGuestOSType> > &aGuestOSTypes);
327 HRESULT getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders);
328 HRESULT getPerformanceCollector(ComPtr<IPerformanceCollector> &aPerformanceCollector);
329 HRESULT getDHCPServers(std::vector<ComPtr<IDHCPServer> > &aDHCPServers);
330 HRESULT getNATNetworks(std::vector<ComPtr<INATNetwork> > &aNATNetworks);
331 HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
332 HRESULT getExtensionPackManager(ComPtr<IExtPackManager> &aExtensionPackManager);
333 HRESULT getInternalNetworks(std::vector<com::Utf8Str> &aInternalNetworks);
334 HRESULT getGenericNetworkDrivers(std::vector<com::Utf8Str> &aGenericNetworkDrivers);
335 HRESULT getCloudNetworks(std::vector<ComPtr<ICloudNetwork> > &aCloudNetworks);
336 HRESULT getCloudProviderManager(ComPtr<ICloudProviderManager> &aCloudProviderManager);
337
338 // wrapped IVirtualBox methods
339 HRESULT composeMachineFilename(const com::Utf8Str &aName,
340 const com::Utf8Str &aGroup,
341 const com::Utf8Str &aCreateFlags,
342 const com::Utf8Str &aBaseFolder,
343 com::Utf8Str &aFile);
344 HRESULT createMachine(const com::Utf8Str &aSettingsFile,
345 const com::Utf8Str &aName,
346 const std::vector<com::Utf8Str> &aGroups,
347 const com::Utf8Str &aOsTypeId,
348 const com::Utf8Str &aFlags,
349 ComPtr<IMachine> &aMachine);
350 HRESULT openMachine(const com::Utf8Str &aSettingsFile,
351 ComPtr<IMachine> &aMachine);
352 HRESULT registerMachine(const ComPtr<IMachine> &aMachine);
353 HRESULT findMachine(const com::Utf8Str &aNameOrId,
354 ComPtr<IMachine> &aMachine);
355 HRESULT getMachinesByGroups(const std::vector<com::Utf8Str> &aGroups,
356 std::vector<ComPtr<IMachine> > &aMachines);
357 HRESULT getMachineStates(const std::vector<ComPtr<IMachine> > &aMachines,
358 std::vector<MachineState_T> &aStates);
359 HRESULT createAppliance(ComPtr<IAppliance> &aAppliance);
360 HRESULT createUnattendedInstaller(ComPtr<IUnattended> &aUnattended);
361 HRESULT createMedium(const com::Utf8Str &aFormat,
362 const com::Utf8Str &aLocation,
363 AccessMode_T aAccessMode,
364 DeviceType_T aDeviceType,
365 ComPtr<IMedium> &aMedium);
366 HRESULT openMedium(const com::Utf8Str &aLocation,
367 DeviceType_T aDeviceType,
368 AccessMode_T aAccessMode,
369 BOOL aForceNewUuid,
370 ComPtr<IMedium> &aMedium);
371 HRESULT getGuestOSType(const com::Utf8Str &aId,
372 ComPtr<IGuestOSType> &aType);
373 HRESULT createSharedFolder(const com::Utf8Str &aName,
374 const com::Utf8Str &aHostPath,
375 BOOL aWritable,
376 BOOL aAutomount,
377 const com::Utf8Str &aAutoMountPoint);
378 HRESULT removeSharedFolder(const com::Utf8Str &aName);
379 HRESULT getExtraDataKeys(std::vector<com::Utf8Str> &aKeys);
380 HRESULT getExtraData(const com::Utf8Str &aKey,
381 com::Utf8Str &aValue);
382 HRESULT setExtraData(const com::Utf8Str &aKey,
383 const com::Utf8Str &aValue);
384 HRESULT setSettingsSecret(const com::Utf8Str &aPassword);
385 HRESULT createDHCPServer(const com::Utf8Str &aName,
386 ComPtr<IDHCPServer> &aServer);
387 HRESULT findDHCPServerByNetworkName(const com::Utf8Str &aName,
388 ComPtr<IDHCPServer> &aServer);
389 HRESULT removeDHCPServer(const ComPtr<IDHCPServer> &aServer);
390 HRESULT createNATNetwork(const com::Utf8Str &aNetworkName,
391 ComPtr<INATNetwork> &aNetwork);
392 HRESULT findNATNetworkByName(const com::Utf8Str &aNetworkName,
393 ComPtr<INATNetwork> &aNetwork);
394 HRESULT removeNATNetwork(const ComPtr<INATNetwork> &aNetwork);
395 HRESULT createCloudNetwork(const com::Utf8Str &aNetworkName,
396 ComPtr<ICloudNetwork> &aNetwork);
397 HRESULT findCloudNetworkByName(const com::Utf8Str &aNetworkName,
398 ComPtr<ICloudNetwork> &aNetwork);
399 HRESULT removeCloudNetwork(const ComPtr<ICloudNetwork> &aNetwork);
400 HRESULT checkFirmwarePresent(FirmwareType_T aFirmwareType,
401 const com::Utf8Str &aVersion,
402 com::Utf8Str &aUrl,
403 com::Utf8Str &aFile,
404 BOOL *aResult);
405
406 static HRESULT i_setErrorStaticBoth(HRESULT aResultCode, int vrc, const Utf8Str &aText)
407 {
408 return setErrorInternal(aResultCode, getStaticClassIID(), getStaticComponentName(), aText, false, true, vrc);
409 }
410
411 HRESULT i_registerMachine(Machine *aMachine);
412 HRESULT i_registerDHCPServer(DHCPServer *aDHCPServer,
413 bool aSaveRegistry = true);
414 HRESULT i_unregisterDHCPServer(DHCPServer *aDHCPServer);
415 HRESULT i_registerNATNetwork(NATNetwork *aNATNetwork,
416 bool aSaveRegistry = true);
417 HRESULT i_unregisterNATNetwork(NATNetwork *aNATNetwork,
418 bool aSaveRegistry = true);
419 HRESULT i_checkMediaForConflicts(const Guid &aId,
420 const Utf8Str &aLocation,
421 Utf8Str &aConflictType,
422 ComObjPtr<Medium> *pDupMedium);
423 int i_decryptSettings();
424 int i_decryptMediumSettings(Medium *pMedium);
425 int i_decryptSettingBytes(uint8_t *aPlaintext,
426 const uint8_t *aCiphertext,
427 size_t aCiphertextSize) const;
428 int i_encryptSettingBytes(const uint8_t *aPlaintext,
429 uint8_t *aCiphertext,
430 size_t aPlaintextSize,
431 size_t aCiphertextSize) const;
432 void i_reportDriverVersions(void);
433
434 struct Data; // opaque data structure, defined in VirtualBoxImpl.cpp
435
436 Data *m;
437
438 /* static variables (defined in VirtualBoxImpl.cpp) */
439 static com::Utf8Str sVersion;
440 static com::Utf8Str sVersionNormalized;
441 static ULONG sRevision;
442 static com::Utf8Str sPackageType;
443 static com::Utf8Str sAPIVersion;
444 static std::map<com::Utf8Str, int> sNatNetworkNameToRefCount;
445 static RWLockHandle* spMtxNatNetworkNameToRefCountLock;
446
447 static DECLCALLBACK(int) AsyncEventHandler(RTTHREAD thread, void *pvUser);
448
449#ifdef RT_OS_WINDOWS
450 friend class StartSVCHelperClientData;
451 static void i_SVCHelperClientThreadTask(StartSVCHelperClientData *pTask);
452#endif
453
454#if defined(RT_OS_WINDOWS) && defined(VBOXSVC_WITH_CLIENT_WATCHER)
455protected:
456 void i_callHook(const char *a_pszFunction) RT_OVERRIDE;
457 bool i_watchClientProcess(RTPROCESS a_pidClient, const char *a_pszFunction);
458public:
459 static void i_logCaller(const char *a_pszFormat, ...);
460private:
461
462#endif
463};
464
465////////////////////////////////////////////////////////////////////////////////
466
467#endif /* !MAIN_INCLUDED_VirtualBoxImpl_h */
468
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use