VirtualBox

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

Last change on this file since 55184 was 54948, checked in by vboxsync, 10 years ago

Main/Medium+Snapshot: make all code recursing over trees (objects containing lists of child objects) use as little stack as possible, and establish safe depth limits to avoid crashes, plus related cleanups in related code areas
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 16.6 KB
Line 
1/* $Id: VirtualBoxImpl.h 54948 2015-03-25 16:56:48Z vboxsync $ */
2/** @file
3 * VirtualBox COM class implementation
4 */
5
6/*
7 * Copyright (C) 2006-2015 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 ____H_VIRTUALBOXIMPL
19#define ____H_VIRTUALBOXIMPL
20
21#include "VirtualBoxBase.h"
22#include "objectslist.h"
23#include "VirtualBoxWrap.h"
24
25#ifdef RT_OS_WINDOWS
26# include "win/resource.h"
27#endif
28
29namespace com
30{
31 class Event;
32 class EventQueue;
33}
34
35class SessionMachine;
36class GuestOSType;
37class Progress;
38class Host;
39class SystemProperties;
40class DHCPServer;
41class PerformanceCollector;
42#ifdef VBOX_WITH_EXTPACK
43class ExtPackManager;
44#endif
45class AutostartDb;
46class NATNetwork;
47
48
49typedef std::list<ComObjPtr<SessionMachine> > SessionMachinesList;
50
51#ifdef RT_OS_WINDOWS
52class SVCHlpClient;
53#endif
54
55namespace settings
56{
57 class MainConfigFile;
58 struct MediaRegistry;
59}
60class ATL_NO_VTABLE VirtualBox :
61 public VirtualBoxWrap
62#ifdef RT_OS_WINDOWS
63 , public CComCoClass<VirtualBox, &CLSID_VirtualBox>
64#endif
65{
66
67public:
68
69 typedef std::list<ComPtr<IInternalSessionControl> > InternalControlList;
70 typedef ObjectsList<Machine> MachinesOList;
71
72 class CallbackEvent;
73 friend class CallbackEvent;
74
75 DECLARE_CLASSFACTORY_SINGLETON(VirtualBox)
76
77 DECLARE_REGISTRY_RESOURCEID(IDR_VIRTUALBOX)
78
79 // Kind of redundant (VirtualBoxWrap declares itself not aggregatable and
80 // CComCoClass<VirtualBox, &CLSID_VirtualBox> as aggregatable, the former
81 // is the first inheritance), but the C++ multiple inheritance rules and
82 // the class factory in svcmain.cpp needs this to disambiguate.
83 DECLARE_NOT_AGGREGATABLE(VirtualBox)
84
85 // to postpone generation of the default ctor/dtor
86 DECLARE_EMPTY_CTOR_DTOR(VirtualBox)
87
88 HRESULT FinalConstruct();
89 void FinalRelease();
90
91 /* public initializer/uninitializer for internal purposes only */
92 HRESULT init();
93 HRESULT initMachines();
94 HRESULT initMedia(const Guid &uuidMachineRegistry,
95 const settings::MediaRegistry &mediaRegistry,
96 const Utf8Str &strMachineFolder);
97 void uninit();
98
99 /* public methods only for internal purposes */
100
101 /**
102 * Override of the default locking class to be used for validating lock
103 * order with the standard member lock handle.
104 */
105 virtual VBoxLockingClass getLockingClass() const
106 {
107 return LOCKCLASS_VIRTUALBOXOBJECT;
108 }
109
110#ifdef DEBUG
111 void i_dumpAllBackRefs();
112#endif
113
114 HRESULT i_postEvent(Event *event);
115
116 HRESULT i_addProgress(IProgress *aProgress);
117 HRESULT i_removeProgress(IN_GUID aId);
118
119#ifdef RT_OS_WINDOWS
120 typedef DECLCALLBACKPTR(HRESULT, SVCHelperClientFunc)
121 (SVCHlpClient *aClient, Progress *aProgress, void *aUser, int *aVrc);
122 HRESULT i_startSVCHelperClient(bool aPrivileged,
123 SVCHelperClientFunc aFunc,
124 void *aUser, Progress *aProgress);
125#endif
126
127 void i_addProcessToReap(RTPROCESS pid);
128 void i_updateClientWatcher();
129
130 int i_loadVDPlugin(const char *pszPluginLibrary);
131 int i_unloadVDPlugin(const char *pszPluginLibrary);
132
133 void i_onMachineStateChange(const Guid &aId, MachineState_T aState);
134 void i_onMachineDataChange(const Guid &aId, BOOL aTemporary = FALSE);
135 BOOL i_onExtraDataCanChange(const Guid &aId, IN_BSTR aKey, IN_BSTR aValue,
136 Bstr &aError);
137 void i_onExtraDataChange(const Guid &aId, IN_BSTR aKey, IN_BSTR aValue);
138 void i_onMachineRegistered(const Guid &aId, BOOL aRegistered);
139 void i_onSessionStateChange(const Guid &aId, SessionState_T aState);
140
141 void i_onSnapshotTaken(const Guid &aMachineId, const Guid &aSnapshotId);
142 void i_onSnapshotDeleted(const Guid &aMachineId, const Guid &aSnapshotId);
143 void i_onSnapshotChange(const Guid &aMachineId, const Guid &aSnapshotId);
144 void i_onGuestPropertyChange(const Guid &aMachineId, IN_BSTR aName, IN_BSTR aValue,
145 IN_BSTR aFlags);
146 void i_onNatRedirectChange(const Guid &aMachineId, ULONG ulSlot, bool fRemove, IN_BSTR aName,
147 NATProtocol_T aProto, IN_BSTR aHostIp, uint16_t aHostPort,
148 IN_BSTR aGuestIp, uint16_t aGuestPort);
149 void i_onNATNetworkChange(IN_BSTR aNetworkName);
150 void i_onNATNetworkStartStop(IN_BSTR aNetworkName, BOOL aStart);
151 void i_onNATNetworkSetting(IN_BSTR aNetworkName, BOOL aEnabled, IN_BSTR aNetwork,
152 IN_BSTR aGateway, BOOL aAdvertiseDefaultIpv6RouteEnabled,
153 BOOL fNeedDhcpServer);
154 void i_onNATNetworkPortForward(IN_BSTR aNetworkName, BOOL create, BOOL fIpv6,
155 IN_BSTR aRuleName, NATProtocol_T proto,
156 IN_BSTR aHostIp, LONG aHostPort,
157 IN_BSTR aGuestIp, LONG aGuestPort);
158 void i_onHostNameResolutionConfigurationChange();
159
160 int i_natNetworkRefInc(IN_BSTR aNetworkName);
161 int i_natNetworkRefDec(IN_BSTR aNetworkName);
162
163 ComObjPtr<GuestOSType> i_getUnknownOSType();
164
165 void i_getOpenedMachines(SessionMachinesList &aMachines,
166 InternalControlList *aControls = NULL);
167 MachinesOList &i_getMachinesList();
168
169 HRESULT i_findMachine(const Guid &aId,
170 bool fPermitInaccessible,
171 bool aSetError,
172 ComObjPtr<Machine> *aMachine = NULL);
173
174 HRESULT i_findMachineByName(const Utf8Str &aName,
175 bool aSetError,
176 ComObjPtr<Machine> *aMachine = NULL);
177
178 HRESULT i_validateMachineGroup(const Utf8Str &aGroup, bool fPrimary);
179 HRESULT i_convertMachineGroups(const std::vector<com::Utf8Str> aMachineGroups, StringsList *pllMachineGroups);
180
181 HRESULT i_findHardDiskById(const Guid &id,
182 bool aSetError,
183 ComObjPtr<Medium> *aHardDisk = NULL);
184 HRESULT i_findHardDiskByLocation(const Utf8Str &strLocation,
185 bool aSetError,
186 ComObjPtr<Medium> *aHardDisk = NULL);
187 HRESULT i_findDVDOrFloppyImage(DeviceType_T mediumType,
188 const Guid *aId,
189 const Utf8Str &aLocation,
190 bool aSetError,
191 ComObjPtr<Medium> *aImage = NULL);
192 HRESULT i_findRemoveableMedium(DeviceType_T mediumType,
193 const Guid &uuid,
194 bool fRefresh,
195 bool aSetError,
196 ComObjPtr<Medium> &pMedium);
197
198 HRESULT i_findGuestOSType(const Bstr &bstrOSType,
199 GuestOSType*& pGuestOSType);
200
201 const Guid &i_getGlobalRegistryId() const;
202
203 const ComObjPtr<Host>& i_host() const;
204 SystemProperties* i_getSystemProperties() const;
205#ifdef VBOX_WITH_EXTPACK
206 ExtPackManager* i_getExtPackManager() const;
207#endif
208#ifdef VBOX_WITH_RESOURCE_USAGE_API
209 const ComObjPtr<PerformanceCollector>& i_performanceCollector() const;
210#endif /* VBOX_WITH_RESOURCE_USAGE_API */
211
212 void i_getDefaultMachineFolder(Utf8Str &str) const;
213 void i_getDefaultHardDiskFormat(Utf8Str &str) const;
214
215 /** Returns the VirtualBox home directory */
216 const Utf8Str& i_homeDir() const;
217 int i_calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult);
218 void i_copyPathRelativeToConfig(const Utf8Str &strSource, Utf8Str &strTarget);
219 HRESULT i_registerMedium(const ComObjPtr<Medium> &pMedium, ComObjPtr<Medium> *ppMedium,
220 AutoWriteLock &mediaTreeLock);
221 HRESULT i_unregisterMedium(Medium *pMedium);
222 void i_pushMediumToListWithChildren(MediaList &llMedia, Medium *pMedium);
223 HRESULT i_unregisterMachineMedia(const Guid &id);
224 HRESULT i_unregisterMachine(Machine *pMachine, const Guid &id);
225 void i_rememberMachineNameChangeForMedia(const Utf8Str &strOldConfigDir,
226 const Utf8Str &strNewConfigDir);
227 void i_saveMediaRegistry(settings::MediaRegistry &mediaRegistry,
228 const Guid &uuidRegistry,
229 const Utf8Str &strMachineFolder);
230 HRESULT i_saveSettings();
231 void i_markRegistryModified(const Guid &uuid);
232 void i_unmarkRegistryModified(const Guid &uuid);
233 void i_saveModifiedRegistries();
234 static const com::Utf8Str &i_getVersionNormalized();
235 static HRESULT i_ensureFilePathExists(const Utf8Str &strFileName, bool fCreate);
236 const Utf8Str& i_settingsFilePath();
237 AutostartDb* i_getAutostartDb() const;
238 RWLockHandle& i_getMachinesListLockHandle();
239 RWLockHandle& i_getMediaTreeLockHandle();
240 int i_encryptSetting(const Utf8Str &aPlaintext, Utf8Str *aCiphertext);
241 int i_decryptSetting(Utf8Str *aPlaintext, const Utf8Str &aCiphertext);
242 void i_storeSettingsKey(const Utf8Str &aKey);
243 bool i_isMediaUuidInUse(const Guid &aId, DeviceType_T deviceType);
244
245
246
247private:
248 class ClientWatcher;
249
250 // wrapped IVirtualBox properties
251 HRESULT getVersion(com::Utf8Str &aVersion);
252 HRESULT getVersionNormalized(com::Utf8Str &aVersionNormalized);
253 HRESULT getRevision(ULONG *aRevision);
254 HRESULT getPackageType(com::Utf8Str &aPackageType);
255 HRESULT getAPIVersion(com::Utf8Str &aAPIVersion);
256 HRESULT getHomeFolder(com::Utf8Str &aHomeFolder);
257 HRESULT getSettingsFilePath(com::Utf8Str &aSettingsFilePath);
258 HRESULT getHost(ComPtr<IHost> &aHost);
259 HRESULT getSystemProperties(ComPtr<ISystemProperties> &aSystemProperties);
260 HRESULT getMachines(std::vector<ComPtr<IMachine> > &aMachines);
261 HRESULT getMachineGroups(std::vector<com::Utf8Str> &aMachineGroups);
262 HRESULT getHardDisks(std::vector<ComPtr<IMedium> > &aHardDisks);
263 HRESULT getDVDImages(std::vector<ComPtr<IMedium> > &aDVDImages);
264 HRESULT getFloppyImages(std::vector<ComPtr<IMedium> > &aFloppyImages);
265 HRESULT getProgressOperations(std::vector<ComPtr<IProgress> > &aProgressOperations);
266 HRESULT getGuestOSTypes(std::vector<ComPtr<IGuestOSType> > &aGuestOSTypes);
267 HRESULT getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders);
268 HRESULT getPerformanceCollector(ComPtr<IPerformanceCollector> &aPerformanceCollector);
269 HRESULT getDHCPServers(std::vector<ComPtr<IDHCPServer> > &aDHCPServers);
270 HRESULT getNATNetworks(std::vector<ComPtr<INATNetwork> > &aNATNetworks);
271 HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
272 HRESULT getExtensionPackManager(ComPtr<IExtPackManager> &aExtensionPackManager);
273 HRESULT getInternalNetworks(std::vector<com::Utf8Str> &aInternalNetworks);
274 HRESULT getGenericNetworkDrivers(std::vector<com::Utf8Str> &aGenericNetworkDrivers);
275
276 // wrapped IVirtualBox methods
277 HRESULT composeMachineFilename(const com::Utf8Str &aName,
278 const com::Utf8Str &aGroup,
279 const com::Utf8Str &aCreateFlags,
280 const com::Utf8Str &aBaseFolder,
281 com::Utf8Str &aFile);
282 HRESULT createMachine(const com::Utf8Str &aSettingsFile,
283 const com::Utf8Str &aName,
284 const std::vector<com::Utf8Str> &aGroups,
285 const com::Utf8Str &aOsTypeId,
286 const com::Utf8Str &aFlags,
287 ComPtr<IMachine> &aMachine);
288 HRESULT openMachine(const com::Utf8Str &aSettingsFile,
289 ComPtr<IMachine> &aMachine);
290 HRESULT registerMachine(const ComPtr<IMachine> &aMachine);
291 HRESULT findMachine(const com::Utf8Str &aNameOrId,
292 ComPtr<IMachine> &aMachine);
293 HRESULT getMachinesByGroups(const std::vector<com::Utf8Str> &aGroups,
294 std::vector<ComPtr<IMachine> > &aMachines);
295 HRESULT getMachineStates(const std::vector<ComPtr<IMachine> > &aMachines,
296 std::vector<MachineState_T> &aStates);
297 HRESULT createAppliance(ComPtr<IAppliance> &aAppliance);
298 HRESULT createMedium(const com::Utf8Str &aFormat,
299 const com::Utf8Str &aLocation,
300 AccessMode_T aAccessMode,
301 DeviceType_T aDeviceType,
302 ComPtr<IMedium> &aMedium);
303 HRESULT openMedium(const com::Utf8Str &aLocation,
304 DeviceType_T aDeviceType,
305 AccessMode_T aAccessMode,
306 BOOL aForceNewUuid,
307 ComPtr<IMedium> &aMedium);
308 HRESULT getGuestOSType(const com::Utf8Str &aId,
309 ComPtr<IGuestOSType> &aType);
310 HRESULT createSharedFolder(const com::Utf8Str &aName,
311 const com::Utf8Str &aHostPath,
312 BOOL aWritable,
313 BOOL aAutomount);
314 HRESULT removeSharedFolder(const com::Utf8Str &aName);
315 HRESULT getExtraDataKeys(std::vector<com::Utf8Str> &aKeys);
316 HRESULT getExtraData(const com::Utf8Str &aKey,
317 com::Utf8Str &aValue);
318 HRESULT setExtraData(const com::Utf8Str &aKey,
319 const com::Utf8Str &aValue);
320 HRESULT setSettingsSecret(const com::Utf8Str &aPassword);
321 HRESULT createDHCPServer(const com::Utf8Str &aName,
322 ComPtr<IDHCPServer> &aServer);
323 HRESULT findDHCPServerByNetworkName(const com::Utf8Str &aName,
324 ComPtr<IDHCPServer> &aServer);
325 HRESULT removeDHCPServer(const ComPtr<IDHCPServer> &aServer);
326 HRESULT createNATNetwork(const com::Utf8Str &aNetworkName,
327 ComPtr<INATNetwork> &aNetwork);
328 HRESULT findNATNetworkByName(const com::Utf8Str &aNetworkName,
329 ComPtr<INATNetwork> &aNetwork);
330 HRESULT removeNATNetwork(const ComPtr<INATNetwork> &aNetwork);
331 HRESULT checkFirmwarePresent(FirmwareType_T aFirmwareType,
332 const com::Utf8Str &aVersion,
333 com::Utf8Str &aUrl,
334 com::Utf8Str &aFile,
335 BOOL *aResult);
336
337 static HRESULT i_setErrorStatic(HRESULT aResultCode,
338 const Utf8Str &aText)
339 {
340 return setErrorInternal(aResultCode, getStaticClassIID(), getStaticComponentName(), aText, false, true);
341 }
342
343 HRESULT i_registerMachine(Machine *aMachine);
344 HRESULT i_registerDHCPServer(DHCPServer *aDHCPServer,
345 bool aSaveRegistry = true);
346 HRESULT i_unregisterDHCPServer(DHCPServer *aDHCPServer);
347 HRESULT i_registerNATNetwork(NATNetwork *aNATNetwork,
348 bool aSaveRegistry = true);
349 HRESULT i_unregisterNATNetwork(NATNetwork *aNATNetwork,
350 bool aSaveRegistry = true);
351 HRESULT i_checkMediaForConflicts(const Guid &aId,
352 const Utf8Str &aLocation,
353 Utf8Str &aConflictType,
354 ComObjPtr<Medium> *pDupMedium);
355 int i_decryptSettings();
356 int i_decryptMediumSettings(Medium *pMedium);
357 int i_decryptSettingBytes(uint8_t *aPlaintext,
358 const uint8_t *aCiphertext,
359 size_t aCiphertextSize) const;
360 int i_encryptSettingBytes(const uint8_t *aPlaintext,
361 uint8_t *aCiphertext,
362 size_t aPlaintextSize,
363 size_t aCiphertextSize) const;
364
365 struct Data; // opaque data structure, defined in VirtualBoxImpl.cpp
366
367 Data *m;
368
369 /* static variables (defined in VirtualBoxImpl.cpp) */
370 static com::Utf8Str sVersion;
371 static com::Utf8Str sVersionNormalized;
372 static ULONG sRevision;
373 static com::Utf8Str sPackageType;
374 static com::Utf8Str sAPIVersion;
375 static std::map<com::Utf8Str, int> sNatNetworkNameToRefCount;
376 static RWLockHandle* spMtxNatNetworkNameToRefCountLock;
377
378 static DECLCALLBACK(int) AsyncEventHandler(RTTHREAD thread, void *pvUser);
379
380#ifdef RT_OS_WINDOWS
381 static DECLCALLBACK(int) SVCHelperClientThread(RTTHREAD aThread, void *aUser);
382#endif
383};
384
385////////////////////////////////////////////////////////////////////////////////
386
387#endif // !____H_VIRTUALBOXIMPL
388
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