VirtualBox

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

Last change on this file since 55631 was 55255, checked in by vboxsync, 10 years ago

Main/Snapshot: only update the machine state on the VM process if there is one,
and introduce a new event when a snapshot has been restored instead of abusing t
he one for deleting a snapshot.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 16.7 KB
Line 
1/* $Id: VirtualBoxImpl.h 55255 2015-04-14 15:45:46Z 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_onSnapshotRestored(const Guid &aMachineId, const Guid &aSnapshotId);
144 void i_onSnapshotChange(const Guid &aMachineId, const Guid &aSnapshotId);
145 void i_onGuestPropertyChange(const Guid &aMachineId, IN_BSTR aName, IN_BSTR aValue,
146 IN_BSTR aFlags);
147 void i_onNatRedirectChange(const Guid &aMachineId, ULONG ulSlot, bool fRemove, IN_BSTR aName,
148 NATProtocol_T aProto, IN_BSTR aHostIp, uint16_t aHostPort,
149 IN_BSTR aGuestIp, uint16_t aGuestPort);
150 void i_onNATNetworkChange(IN_BSTR aNetworkName);
151 void i_onNATNetworkStartStop(IN_BSTR aNetworkName, BOOL aStart);
152 void i_onNATNetworkSetting(IN_BSTR aNetworkName, BOOL aEnabled, IN_BSTR aNetwork,
153 IN_BSTR aGateway, BOOL aAdvertiseDefaultIpv6RouteEnabled,
154 BOOL fNeedDhcpServer);
155 void i_onNATNetworkPortForward(IN_BSTR aNetworkName, BOOL create, BOOL fIpv6,
156 IN_BSTR aRuleName, NATProtocol_T proto,
157 IN_BSTR aHostIp, LONG aHostPort,
158 IN_BSTR aGuestIp, LONG aGuestPort);
159 void i_onHostNameResolutionConfigurationChange();
160
161 int i_natNetworkRefInc(IN_BSTR aNetworkName);
162 int i_natNetworkRefDec(IN_BSTR aNetworkName);
163
164 ComObjPtr<GuestOSType> i_getUnknownOSType();
165
166 void i_getOpenedMachines(SessionMachinesList &aMachines,
167 InternalControlList *aControls = NULL);
168 MachinesOList &i_getMachinesList();
169
170 HRESULT i_findMachine(const Guid &aId,
171 bool fPermitInaccessible,
172 bool aSetError,
173 ComObjPtr<Machine> *aMachine = NULL);
174
175 HRESULT i_findMachineByName(const Utf8Str &aName,
176 bool aSetError,
177 ComObjPtr<Machine> *aMachine = NULL);
178
179 HRESULT i_validateMachineGroup(const Utf8Str &aGroup, bool fPrimary);
180 HRESULT i_convertMachineGroups(const std::vector<com::Utf8Str> aMachineGroups, StringsList *pllMachineGroups);
181
182 HRESULT i_findHardDiskById(const Guid &id,
183 bool aSetError,
184 ComObjPtr<Medium> *aHardDisk = NULL);
185 HRESULT i_findHardDiskByLocation(const Utf8Str &strLocation,
186 bool aSetError,
187 ComObjPtr<Medium> *aHardDisk = NULL);
188 HRESULT i_findDVDOrFloppyImage(DeviceType_T mediumType,
189 const Guid *aId,
190 const Utf8Str &aLocation,
191 bool aSetError,
192 ComObjPtr<Medium> *aImage = NULL);
193 HRESULT i_findRemoveableMedium(DeviceType_T mediumType,
194 const Guid &uuid,
195 bool fRefresh,
196 bool aSetError,
197 ComObjPtr<Medium> &pMedium);
198
199 HRESULT i_findGuestOSType(const Bstr &bstrOSType,
200 GuestOSType*& pGuestOSType);
201
202 const Guid &i_getGlobalRegistryId() const;
203
204 const ComObjPtr<Host>& i_host() const;
205 SystemProperties* i_getSystemProperties() const;
206#ifdef VBOX_WITH_EXTPACK
207 ExtPackManager* i_getExtPackManager() const;
208#endif
209#ifdef VBOX_WITH_RESOURCE_USAGE_API
210 const ComObjPtr<PerformanceCollector>& i_performanceCollector() const;
211#endif /* VBOX_WITH_RESOURCE_USAGE_API */
212
213 void i_getDefaultMachineFolder(Utf8Str &str) const;
214 void i_getDefaultHardDiskFormat(Utf8Str &str) const;
215
216 /** Returns the VirtualBox home directory */
217 const Utf8Str& i_homeDir() const;
218 int i_calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult);
219 void i_copyPathRelativeToConfig(const Utf8Str &strSource, Utf8Str &strTarget);
220 HRESULT i_registerMedium(const ComObjPtr<Medium> &pMedium, ComObjPtr<Medium> *ppMedium,
221 AutoWriteLock &mediaTreeLock);
222 HRESULT i_unregisterMedium(Medium *pMedium);
223 void i_pushMediumToListWithChildren(MediaList &llMedia, Medium *pMedium);
224 HRESULT i_unregisterMachineMedia(const Guid &id);
225 HRESULT i_unregisterMachine(Machine *pMachine, const Guid &id);
226 void i_rememberMachineNameChangeForMedia(const Utf8Str &strOldConfigDir,
227 const Utf8Str &strNewConfigDir);
228 void i_saveMediaRegistry(settings::MediaRegistry &mediaRegistry,
229 const Guid &uuidRegistry,
230 const Utf8Str &strMachineFolder);
231 HRESULT i_saveSettings();
232 void i_markRegistryModified(const Guid &uuid);
233 void i_unmarkRegistryModified(const Guid &uuid);
234 void i_saveModifiedRegistries();
235 static const com::Utf8Str &i_getVersionNormalized();
236 static HRESULT i_ensureFilePathExists(const Utf8Str &strFileName, bool fCreate);
237 const Utf8Str& i_settingsFilePath();
238 AutostartDb* i_getAutostartDb() const;
239 RWLockHandle& i_getMachinesListLockHandle();
240 RWLockHandle& i_getMediaTreeLockHandle();
241 int i_encryptSetting(const Utf8Str &aPlaintext, Utf8Str *aCiphertext);
242 int i_decryptSetting(Utf8Str *aPlaintext, const Utf8Str &aCiphertext);
243 void i_storeSettingsKey(const Utf8Str &aKey);
244 bool i_isMediaUuidInUse(const Guid &aId, DeviceType_T deviceType);
245
246
247
248private:
249 class ClientWatcher;
250
251 // wrapped IVirtualBox properties
252 HRESULT getVersion(com::Utf8Str &aVersion);
253 HRESULT getVersionNormalized(com::Utf8Str &aVersionNormalized);
254 HRESULT getRevision(ULONG *aRevision);
255 HRESULT getPackageType(com::Utf8Str &aPackageType);
256 HRESULT getAPIVersion(com::Utf8Str &aAPIVersion);
257 HRESULT getHomeFolder(com::Utf8Str &aHomeFolder);
258 HRESULT getSettingsFilePath(com::Utf8Str &aSettingsFilePath);
259 HRESULT getHost(ComPtr<IHost> &aHost);
260 HRESULT getSystemProperties(ComPtr<ISystemProperties> &aSystemProperties);
261 HRESULT getMachines(std::vector<ComPtr<IMachine> > &aMachines);
262 HRESULT getMachineGroups(std::vector<com::Utf8Str> &aMachineGroups);
263 HRESULT getHardDisks(std::vector<ComPtr<IMedium> > &aHardDisks);
264 HRESULT getDVDImages(std::vector<ComPtr<IMedium> > &aDVDImages);
265 HRESULT getFloppyImages(std::vector<ComPtr<IMedium> > &aFloppyImages);
266 HRESULT getProgressOperations(std::vector<ComPtr<IProgress> > &aProgressOperations);
267 HRESULT getGuestOSTypes(std::vector<ComPtr<IGuestOSType> > &aGuestOSTypes);
268 HRESULT getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders);
269 HRESULT getPerformanceCollector(ComPtr<IPerformanceCollector> &aPerformanceCollector);
270 HRESULT getDHCPServers(std::vector<ComPtr<IDHCPServer> > &aDHCPServers);
271 HRESULT getNATNetworks(std::vector<ComPtr<INATNetwork> > &aNATNetworks);
272 HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
273 HRESULT getExtensionPackManager(ComPtr<IExtPackManager> &aExtensionPackManager);
274 HRESULT getInternalNetworks(std::vector<com::Utf8Str> &aInternalNetworks);
275 HRESULT getGenericNetworkDrivers(std::vector<com::Utf8Str> &aGenericNetworkDrivers);
276
277 // wrapped IVirtualBox methods
278 HRESULT composeMachineFilename(const com::Utf8Str &aName,
279 const com::Utf8Str &aGroup,
280 const com::Utf8Str &aCreateFlags,
281 const com::Utf8Str &aBaseFolder,
282 com::Utf8Str &aFile);
283 HRESULT createMachine(const com::Utf8Str &aSettingsFile,
284 const com::Utf8Str &aName,
285 const std::vector<com::Utf8Str> &aGroups,
286 const com::Utf8Str &aOsTypeId,
287 const com::Utf8Str &aFlags,
288 ComPtr<IMachine> &aMachine);
289 HRESULT openMachine(const com::Utf8Str &aSettingsFile,
290 ComPtr<IMachine> &aMachine);
291 HRESULT registerMachine(const ComPtr<IMachine> &aMachine);
292 HRESULT findMachine(const com::Utf8Str &aNameOrId,
293 ComPtr<IMachine> &aMachine);
294 HRESULT getMachinesByGroups(const std::vector<com::Utf8Str> &aGroups,
295 std::vector<ComPtr<IMachine> > &aMachines);
296 HRESULT getMachineStates(const std::vector<ComPtr<IMachine> > &aMachines,
297 std::vector<MachineState_T> &aStates);
298 HRESULT createAppliance(ComPtr<IAppliance> &aAppliance);
299 HRESULT createMedium(const com::Utf8Str &aFormat,
300 const com::Utf8Str &aLocation,
301 AccessMode_T aAccessMode,
302 DeviceType_T aDeviceType,
303 ComPtr<IMedium> &aMedium);
304 HRESULT openMedium(const com::Utf8Str &aLocation,
305 DeviceType_T aDeviceType,
306 AccessMode_T aAccessMode,
307 BOOL aForceNewUuid,
308 ComPtr<IMedium> &aMedium);
309 HRESULT getGuestOSType(const com::Utf8Str &aId,
310 ComPtr<IGuestOSType> &aType);
311 HRESULT createSharedFolder(const com::Utf8Str &aName,
312 const com::Utf8Str &aHostPath,
313 BOOL aWritable,
314 BOOL aAutomount);
315 HRESULT removeSharedFolder(const com::Utf8Str &aName);
316 HRESULT getExtraDataKeys(std::vector<com::Utf8Str> &aKeys);
317 HRESULT getExtraData(const com::Utf8Str &aKey,
318 com::Utf8Str &aValue);
319 HRESULT setExtraData(const com::Utf8Str &aKey,
320 const com::Utf8Str &aValue);
321 HRESULT setSettingsSecret(const com::Utf8Str &aPassword);
322 HRESULT createDHCPServer(const com::Utf8Str &aName,
323 ComPtr<IDHCPServer> &aServer);
324 HRESULT findDHCPServerByNetworkName(const com::Utf8Str &aName,
325 ComPtr<IDHCPServer> &aServer);
326 HRESULT removeDHCPServer(const ComPtr<IDHCPServer> &aServer);
327 HRESULT createNATNetwork(const com::Utf8Str &aNetworkName,
328 ComPtr<INATNetwork> &aNetwork);
329 HRESULT findNATNetworkByName(const com::Utf8Str &aNetworkName,
330 ComPtr<INATNetwork> &aNetwork);
331 HRESULT removeNATNetwork(const ComPtr<INATNetwork> &aNetwork);
332 HRESULT checkFirmwarePresent(FirmwareType_T aFirmwareType,
333 const com::Utf8Str &aVersion,
334 com::Utf8Str &aUrl,
335 com::Utf8Str &aFile,
336 BOOL *aResult);
337
338 static HRESULT i_setErrorStatic(HRESULT aResultCode,
339 const Utf8Str &aText)
340 {
341 return setErrorInternal(aResultCode, getStaticClassIID(), getStaticComponentName(), aText, false, true);
342 }
343
344 HRESULT i_registerMachine(Machine *aMachine);
345 HRESULT i_registerDHCPServer(DHCPServer *aDHCPServer,
346 bool aSaveRegistry = true);
347 HRESULT i_unregisterDHCPServer(DHCPServer *aDHCPServer);
348 HRESULT i_registerNATNetwork(NATNetwork *aNATNetwork,
349 bool aSaveRegistry = true);
350 HRESULT i_unregisterNATNetwork(NATNetwork *aNATNetwork,
351 bool aSaveRegistry = true);
352 HRESULT i_checkMediaForConflicts(const Guid &aId,
353 const Utf8Str &aLocation,
354 Utf8Str &aConflictType,
355 ComObjPtr<Medium> *pDupMedium);
356 int i_decryptSettings();
357 int i_decryptMediumSettings(Medium *pMedium);
358 int i_decryptSettingBytes(uint8_t *aPlaintext,
359 const uint8_t *aCiphertext,
360 size_t aCiphertextSize) const;
361 int i_encryptSettingBytes(const uint8_t *aPlaintext,
362 uint8_t *aCiphertext,
363 size_t aPlaintextSize,
364 size_t aCiphertextSize) const;
365
366 struct Data; // opaque data structure, defined in VirtualBoxImpl.cpp
367
368 Data *m;
369
370 /* static variables (defined in VirtualBoxImpl.cpp) */
371 static com::Utf8Str sVersion;
372 static com::Utf8Str sVersionNormalized;
373 static ULONG sRevision;
374 static com::Utf8Str sPackageType;
375 static com::Utf8Str sAPIVersion;
376 static std::map<com::Utf8Str, int> sNatNetworkNameToRefCount;
377 static RWLockHandle* spMtxNatNetworkNameToRefCountLock;
378
379 static DECLCALLBACK(int) AsyncEventHandler(RTTHREAD thread, void *pvUser);
380
381#ifdef RT_OS_WINDOWS
382 static DECLCALLBACK(int) SVCHelperClientThread(RTTHREAD aThread, void *aUser);
383#endif
384};
385
386////////////////////////////////////////////////////////////////////////////////
387
388#endif // !____H_VIRTUALBOXIMPL
389
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