VirtualBox

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

Last change on this file since 73003 was 73003, checked in by vboxsync, 7 years ago

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

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette