VirtualBox

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

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

NAT/Net: Refuse to modify NATNetwork when an instance of it is
running. Use existing infrastructure that keeps track of the number
of VMs that use any given natnet (though it's exposes to natnet in a
somewhat haphazard way). bugref:9909.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 19.6 KB
Line 
1/* $Id: VirtualBoxImpl.h 87949 2021-03-04 12:49:43Z 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
77class ATL_NO_VTABLE VirtualBox :
78 public VirtualBoxWrap
79#ifdef RT_OS_WINDOWS
80 , public ATL::CComCoClass<VirtualBox, &CLSID_VirtualBox>
81#endif
82{
83
84public:
85
86 typedef std::list<ComPtr<IInternalSessionControl> > InternalControlList;
87 typedef ObjectsList<Machine> MachinesOList;
88
89#if 0 /* obsoleted by AsyncEvent */
90 class CallbackEvent;
91 friend class CallbackEvent;
92#endif
93 class AsyncEvent;
94 friend class AsyncEvent;
95
96#ifndef VBOX_WITH_XPCOM
97# ifdef VBOX_WITH_SDS
98 DECLARE_CLASSFACTORY_EX(VirtualBoxClassFactory)
99# else
100 DECLARE_CLASSFACTORY_SINGLETON(VirtualBox)
101# endif
102#endif
103
104 // Do not use any ATL registry support.
105 //DECLARE_REGISTRY_RESOURCEID(IDR_VIRTUALBOX)
106
107 // Kind of redundant (VirtualBoxWrap declares itself not aggregatable and
108 // CComCoClass<VirtualBox, &CLSID_VirtualBox> as aggregatable, the former
109 // is the first inheritance), but the C++ multiple inheritance rules and
110 // the class factory in svcmain.cpp needs this to disambiguate.
111 DECLARE_NOT_AGGREGATABLE(VirtualBox)
112
113 // to postpone generation of the default ctor/dtor
114 DECLARE_EMPTY_CTOR_DTOR(VirtualBox)
115
116 HRESULT FinalConstruct();
117 void FinalRelease();
118
119 // public initializer/uninitializer for internal purposes only
120 HRESULT init();
121 HRESULT initMachines();
122 HRESULT initMedia(const Guid &uuidMachineRegistry,
123 const settings::MediaRegistry &mediaRegistry,
124 const Utf8Str &strMachineFolder);
125 void uninit();
126
127 // public methods only for internal purposes
128
129 /**
130 * Override of the default locking class to be used for validating lock
131 * order with the standard member lock handle.
132 */
133 virtual VBoxLockingClass getLockingClass() const
134 {
135 return LOCKCLASS_VIRTUALBOXOBJECT;
136 }
137
138#ifdef DEBUG
139 void i_dumpAllBackRefs();
140#endif
141
142 HRESULT i_postEvent(Event *event);
143
144 HRESULT i_addProgress(IProgress *aProgress);
145 HRESULT i_removeProgress(IN_GUID aId);
146
147#ifdef RT_OS_WINDOWS
148 typedef DECLCALLBACKPTR(HRESULT, SVCHelperClientFunc,(SVCHlpClient *aClient, Progress *aProgress, void *aUser, int *aVrc));
149 HRESULT i_startSVCHelperClient(bool aPrivileged,
150 SVCHelperClientFunc aFunc,
151 void *aUser, Progress *aProgress);
152#endif
153
154 void i_addProcessToReap(RTPROCESS pid);
155 void i_updateClientWatcher();
156
157 int i_loadVDPlugin(const char *pszPluginLibrary);
158 int i_unloadVDPlugin(const char *pszPluginLibrary);
159
160 void i_onMediumRegistered(const Guid &aMediumId, const DeviceType_T aDevType, const BOOL aRegistered);
161 void i_onMediumConfigChanged(IMedium *aMedium);
162 void i_onMediumChanged(IMediumAttachment* aMediumAttachment);
163 void i_onStorageControllerChanged(const Guid &aMachineId, const com::Utf8Str &aControllerName);
164 void i_onStorageDeviceChanged(IMediumAttachment* aStorageDevice, const BOOL fRemoved, const BOOL fSilent);
165 void i_onMachineStateChanged(const Guid &aId, MachineState_T aState);
166 void i_onMachineDataChanged(const Guid &aId, BOOL aTemporary = FALSE);
167 BOOL i_onExtraDataCanChange(const Guid &aId, const Utf8Str &aKey, const Utf8Str &aValue, Bstr &aError);
168 void i_onExtraDataChanged(const Guid &aId, const Utf8Str &aKey, const Utf8Str &aValue);
169 void i_onMachineRegistered(const Guid &aId, BOOL aRegistered);
170 void i_onSessionStateChanged(const Guid &aId, SessionState_T aState);
171
172 void i_onSnapshotTaken(const Guid &aMachineId, const Guid &aSnapshotId);
173 void i_onSnapshotDeleted(const Guid &aMachineId, const Guid &aSnapshotId);
174 void i_onSnapshotRestored(const Guid &aMachineId, const Guid &aSnapshotId);
175 void i_onSnapshotChanged(const Guid &aMachineId, const Guid &aSnapshotId);
176
177 void i_onGuestPropertyChanged(const Guid &aMachineId, const Utf8Str &aName, const Utf8Str &aValue, const Utf8Str &aFlags);
178 void i_onNatRedirectChanged(const Guid &aMachineId, ULONG ulSlot, bool fRemove, const Utf8Str &aName,
179 NATProtocol_T aProto, const Utf8Str &aHostIp, uint16_t aHostPort,
180 const Utf8Str &aGuestIp, uint16_t aGuestPort);
181 void i_onNATNetworkChanged(const Utf8Str &aNetworkName);
182 void i_onNATNetworkStartStop(const Utf8Str &aNetworkName, BOOL aStart);
183 void i_onNATNetworkSetting(const Utf8Str &aNetworkName, BOOL aEnabled, const Utf8Str &aNetwork,
184 const Utf8Str &aGateway, BOOL aAdvertiseDefaultIpv6RouteEnabled,
185 BOOL fNeedDhcpServer);
186 void i_onNATNetworkPortForward(const Utf8Str &aNetworkName, BOOL create, BOOL fIpv6,
187 const Utf8Str &aRuleName, NATProtocol_T proto,
188 const Utf8Str &aHostIp, LONG aHostPort,
189 const Utf8Str &aGuestIp, LONG aGuestPort);
190 void i_onHostNameResolutionConfigurationChange();
191
192 int i_natNetworkRefInc(const Utf8Str &aNetworkName);
193 int i_natNetworkRefDec(const Utf8Str &aNetworkName);
194
195 RWLockHandle *i_getNatNetLock() const;
196 bool i_isNatNetStarted(const Utf8Str &aNetworkName) const;
197
198 void i_onCloudProviderListChanged(BOOL aRegistered);
199 void i_onCloudProviderRegistered(const Utf8Str &aProviderId, BOOL aRegistered);
200 void i_onCloudProviderUninstall(const Utf8Str &aProviderId);
201
202#ifdef VBOX_WITH_CLOUD_NET
203 HRESULT i_findCloudNetworkByName(const com::Utf8Str &aNetworkName,
204 ComObjPtr<CloudNetwork> *aNetwork = NULL);
205 HRESULT i_getEventSource(ComPtr<IEventSource>& aSource);
206#endif /* VBOX_WITH_CLOUD_NET */
207
208 ComObjPtr<GuestOSType> i_getUnknownOSType();
209
210 void i_getOpenedMachines(SessionMachinesList &aMachines,
211 InternalControlList *aControls = NULL);
212 MachinesOList &i_getMachinesList();
213
214 HRESULT i_findMachine(const Guid &aId,
215 bool fPermitInaccessible,
216 bool aSetError,
217 ComObjPtr<Machine> *aMachine = NULL);
218
219 HRESULT i_findMachineByName(const Utf8Str &aName,
220 bool aSetError,
221 ComObjPtr<Machine> *aMachine = NULL);
222
223 HRESULT i_validateMachineGroup(const com::Utf8Str &aGroup, bool fPrimary);
224 HRESULT i_convertMachineGroups(const std::vector<com::Utf8Str> aMachineGroups, StringsList *pllMachineGroups);
225
226 HRESULT i_findHardDiskById(const Guid &id,
227 bool aSetError,
228 ComObjPtr<Medium> *aHardDisk = NULL);
229 HRESULT i_findHardDiskByLocation(const Utf8Str &strLocation,
230 bool aSetError,
231 ComObjPtr<Medium> *aHardDisk = NULL);
232 HRESULT i_findDVDOrFloppyImage(DeviceType_T mediumType,
233 const Guid *aId,
234 const Utf8Str &aLocation,
235 bool aSetError,
236 ComObjPtr<Medium> *aImage = NULL);
237 HRESULT i_findRemoveableMedium(DeviceType_T mediumType,
238 const Guid &uuid,
239 bool fRefresh,
240 bool aSetError,
241 ComObjPtr<Medium> &pMedium);
242
243 HRESULT i_findGuestOSType(const Utf8Str &strOSType,
244 ComObjPtr<GuestOSType> &guestOSType);
245
246 const Guid &i_getGlobalRegistryId() const;
247
248 const ComObjPtr<Host> &i_host() const;
249 SystemProperties *i_getSystemProperties() const;
250 CloudProviderManager *i_getCloudProviderManager() const;
251#ifdef VBOX_WITH_EXTPACK
252 ExtPackManager *i_getExtPackManager() const;
253#endif
254#ifdef VBOX_WITH_RESOURCE_USAGE_API
255 const ComObjPtr<PerformanceCollector> &i_performanceCollector() const;
256#endif /* VBOX_WITH_RESOURCE_USAGE_API */
257
258 void i_getDefaultMachineFolder(Utf8Str &str) const;
259 void i_getDefaultHardDiskFormat(Utf8Str &str) const;
260
261 /** Returns the VirtualBox home directory */
262 const Utf8Str &i_homeDir() const;
263 int i_calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult);
264 void i_copyPathRelativeToConfig(const Utf8Str &strSource, Utf8Str &strTarget);
265 HRESULT i_registerMedium(const ComObjPtr<Medium> &pMedium, ComObjPtr<Medium> *ppMedium,
266 AutoWriteLock &mediaTreeLock, bool fCalledFromMediumInit = false);
267 HRESULT i_unregisterMedium(Medium *pMedium);
268 void i_pushMediumToListWithChildren(MediaList &llMedia, Medium *pMedium);
269 HRESULT i_unregisterMachineMedia(const Guid &id);
270 HRESULT i_unregisterMachine(Machine *pMachine, const Guid &id);
271 void i_rememberMachineNameChangeForMedia(const Utf8Str &strOldConfigDir,
272 const Utf8Str &strNewConfigDir);
273 void i_saveMediaRegistry(settings::MediaRegistry &mediaRegistry,
274 const Guid &uuidRegistry,
275 const Utf8Str &strMachineFolder);
276 HRESULT i_saveSettings();
277 void i_markRegistryModified(const Guid &uuid);
278 void i_unmarkRegistryModified(const Guid &uuid);
279 void i_saveModifiedRegistries();
280 static const com::Utf8Str &i_getVersionNormalized();
281 static HRESULT i_ensureFilePathExists(const Utf8Str &strFileName, bool fCreate);
282 const Utf8Str& i_settingsFilePath();
283 AutostartDb* i_getAutostartDb() const;
284 RWLockHandle& i_getMachinesListLockHandle();
285 RWLockHandle& i_getMediaTreeLockHandle();
286 int i_encryptSetting(const Utf8Str &aPlaintext, Utf8Str *aCiphertext);
287 int i_decryptSetting(Utf8Str *aPlaintext, const Utf8Str &aCiphertext);
288 void i_storeSettingsKey(const Utf8Str &aKey);
289 bool i_isMediaUuidInUse(const Guid &aId, DeviceType_T deviceType);
290
291
292
293private:
294 class ClientWatcher;
295
296 // wrapped IVirtualBox properties
297 HRESULT getVersion(com::Utf8Str &aVersion);
298 HRESULT getVersionNormalized(com::Utf8Str &aVersionNormalized);
299 HRESULT getRevision(ULONG *aRevision);
300 HRESULT getPackageType(com::Utf8Str &aPackageType);
301 HRESULT getAPIVersion(com::Utf8Str &aAPIVersion);
302 HRESULT getAPIRevision(LONG64 *aAPIRevision);
303 HRESULT getHomeFolder(com::Utf8Str &aHomeFolder);
304 HRESULT getSettingsFilePath(com::Utf8Str &aSettingsFilePath);
305 HRESULT getHost(ComPtr<IHost> &aHost);
306 HRESULT getSystemProperties(ComPtr<ISystemProperties> &aSystemProperties);
307 HRESULT getMachines(std::vector<ComPtr<IMachine> > &aMachines);
308 HRESULT getMachineGroups(std::vector<com::Utf8Str> &aMachineGroups);
309 HRESULT getHardDisks(std::vector<ComPtr<IMedium> > &aHardDisks);
310 HRESULT getDVDImages(std::vector<ComPtr<IMedium> > &aDVDImages);
311 HRESULT getFloppyImages(std::vector<ComPtr<IMedium> > &aFloppyImages);
312 HRESULT getProgressOperations(std::vector<ComPtr<IProgress> > &aProgressOperations);
313 HRESULT getGuestOSTypes(std::vector<ComPtr<IGuestOSType> > &aGuestOSTypes);
314 HRESULT getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders);
315 HRESULT getPerformanceCollector(ComPtr<IPerformanceCollector> &aPerformanceCollector);
316 HRESULT getDHCPServers(std::vector<ComPtr<IDHCPServer> > &aDHCPServers);
317 HRESULT getNATNetworks(std::vector<ComPtr<INATNetwork> > &aNATNetworks);
318 HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
319 HRESULT getExtensionPackManager(ComPtr<IExtPackManager> &aExtensionPackManager);
320 HRESULT getInternalNetworks(std::vector<com::Utf8Str> &aInternalNetworks);
321 HRESULT getGenericNetworkDrivers(std::vector<com::Utf8Str> &aGenericNetworkDrivers);
322 HRESULT getCloudNetworks(std::vector<ComPtr<ICloudNetwork> > &aCloudNetworks);
323 HRESULT getCloudProviderManager(ComPtr<ICloudProviderManager> &aCloudProviderManager);
324
325 // wrapped IVirtualBox methods
326 HRESULT composeMachineFilename(const com::Utf8Str &aName,
327 const com::Utf8Str &aGroup,
328 const com::Utf8Str &aCreateFlags,
329 const com::Utf8Str &aBaseFolder,
330 com::Utf8Str &aFile);
331 HRESULT createMachine(const com::Utf8Str &aSettingsFile,
332 const com::Utf8Str &aName,
333 const std::vector<com::Utf8Str> &aGroups,
334 const com::Utf8Str &aOsTypeId,
335 const com::Utf8Str &aFlags,
336 ComPtr<IMachine> &aMachine);
337 HRESULT openMachine(const com::Utf8Str &aSettingsFile,
338 ComPtr<IMachine> &aMachine);
339 HRESULT registerMachine(const ComPtr<IMachine> &aMachine);
340 HRESULT findMachine(const com::Utf8Str &aNameOrId,
341 ComPtr<IMachine> &aMachine);
342 HRESULT getMachinesByGroups(const std::vector<com::Utf8Str> &aGroups,
343 std::vector<ComPtr<IMachine> > &aMachines);
344 HRESULT getMachineStates(const std::vector<ComPtr<IMachine> > &aMachines,
345 std::vector<MachineState_T> &aStates);
346 HRESULT createAppliance(ComPtr<IAppliance> &aAppliance);
347 HRESULT createUnattendedInstaller(ComPtr<IUnattended> &aUnattended);
348 HRESULT createMedium(const com::Utf8Str &aFormat,
349 const com::Utf8Str &aLocation,
350 AccessMode_T aAccessMode,
351 DeviceType_T aDeviceType,
352 ComPtr<IMedium> &aMedium);
353 HRESULT openMedium(const com::Utf8Str &aLocation,
354 DeviceType_T aDeviceType,
355 AccessMode_T aAccessMode,
356 BOOL aForceNewUuid,
357 ComPtr<IMedium> &aMedium);
358 HRESULT getGuestOSType(const com::Utf8Str &aId,
359 ComPtr<IGuestOSType> &aType);
360 HRESULT createSharedFolder(const com::Utf8Str &aName,
361 const com::Utf8Str &aHostPath,
362 BOOL aWritable,
363 BOOL aAutomount,
364 const com::Utf8Str &aAutoMountPoint);
365 HRESULT removeSharedFolder(const com::Utf8Str &aName);
366 HRESULT getExtraDataKeys(std::vector<com::Utf8Str> &aKeys);
367 HRESULT getExtraData(const com::Utf8Str &aKey,
368 com::Utf8Str &aValue);
369 HRESULT setExtraData(const com::Utf8Str &aKey,
370 const com::Utf8Str &aValue);
371 HRESULT setSettingsSecret(const com::Utf8Str &aPassword);
372 HRESULT createDHCPServer(const com::Utf8Str &aName,
373 ComPtr<IDHCPServer> &aServer);
374 HRESULT findDHCPServerByNetworkName(const com::Utf8Str &aName,
375 ComPtr<IDHCPServer> &aServer);
376 HRESULT removeDHCPServer(const ComPtr<IDHCPServer> &aServer);
377 HRESULT createNATNetwork(const com::Utf8Str &aNetworkName,
378 ComPtr<INATNetwork> &aNetwork);
379 HRESULT findNATNetworkByName(const com::Utf8Str &aNetworkName,
380 ComPtr<INATNetwork> &aNetwork);
381 HRESULT removeNATNetwork(const ComPtr<INATNetwork> &aNetwork);
382 HRESULT createCloudNetwork(const com::Utf8Str &aNetworkName,
383 ComPtr<ICloudNetwork> &aNetwork);
384 HRESULT findCloudNetworkByName(const com::Utf8Str &aNetworkName,
385 ComPtr<ICloudNetwork> &aNetwork);
386 HRESULT removeCloudNetwork(const ComPtr<ICloudNetwork> &aNetwork);
387 HRESULT checkFirmwarePresent(FirmwareType_T aFirmwareType,
388 const com::Utf8Str &aVersion,
389 com::Utf8Str &aUrl,
390 com::Utf8Str &aFile,
391 BOOL *aResult);
392
393 static HRESULT i_setErrorStaticBoth(HRESULT aResultCode, int vrc, const Utf8Str &aText)
394 {
395 return setErrorInternal(aResultCode, getStaticClassIID(), getStaticComponentName(), aText, false, true, vrc);
396 }
397
398 HRESULT i_registerMachine(Machine *aMachine);
399 HRESULT i_registerDHCPServer(DHCPServer *aDHCPServer,
400 bool aSaveRegistry = true);
401 HRESULT i_unregisterDHCPServer(DHCPServer *aDHCPServer);
402 HRESULT i_registerNATNetwork(NATNetwork *aNATNetwork,
403 bool aSaveRegistry = true);
404 HRESULT i_unregisterNATNetwork(NATNetwork *aNATNetwork,
405 bool aSaveRegistry = true);
406 HRESULT i_checkMediaForConflicts(const Guid &aId,
407 const Utf8Str &aLocation,
408 Utf8Str &aConflictType,
409 ComObjPtr<Medium> *pDupMedium);
410 int i_decryptSettings();
411 int i_decryptMediumSettings(Medium *pMedium);
412 int i_decryptSettingBytes(uint8_t *aPlaintext,
413 const uint8_t *aCiphertext,
414 size_t aCiphertextSize) const;
415 int i_encryptSettingBytes(const uint8_t *aPlaintext,
416 uint8_t *aCiphertext,
417 size_t aPlaintextSize,
418 size_t aCiphertextSize) const;
419 void i_reportDriverVersions(void);
420
421 struct Data; // opaque data structure, defined in VirtualBoxImpl.cpp
422
423 Data *m;
424
425 /* static variables (defined in VirtualBoxImpl.cpp) */
426 static com::Utf8Str sVersion;
427 static com::Utf8Str sVersionNormalized;
428 static ULONG sRevision;
429 static com::Utf8Str sPackageType;
430 static com::Utf8Str sAPIVersion;
431 static std::map<com::Utf8Str, int> sNatNetworkNameToRefCount;
432 static RWLockHandle* spMtxNatNetworkNameToRefCountLock;
433
434 static DECLCALLBACK(int) AsyncEventHandler(RTTHREAD thread, void *pvUser);
435
436#ifdef RT_OS_WINDOWS
437 friend class StartSVCHelperClientData;
438 static void i_SVCHelperClientThreadTask(StartSVCHelperClientData *pTask);
439#endif
440
441#if defined(RT_OS_WINDOWS) && defined(VBOXSVC_WITH_CLIENT_WATCHER)
442protected:
443 void i_callHook(const char *a_pszFunction) RT_OVERRIDE;
444 bool i_watchClientProcess(RTPROCESS a_pidClient, const char *a_pszFunction);
445public:
446 static void i_logCaller(const char *a_pszFormat, ...);
447private:
448
449#endif
450};
451
452////////////////////////////////////////////////////////////////////////////////
453
454#endif /* !MAIN_INCLUDED_VirtualBoxImpl_h */
455
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