VirtualBox

source: vbox/trunk/src/VBox/Main/include/MediumImpl.h@ 76553

Last change on this file since 76553 was 76553, checked in by vboxsync, 6 years ago

scm --update-copyright-year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 19.9 KB
Line 
1/* $Id: MediumImpl.h 76553 2019-01-01 01:45:53Z vboxsync $ */
2/** @file
3 * VirtualBox COM class implementation
4 */
5
6/*
7 * Copyright (C) 2008-2019 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
19#ifndef ____H_MEDIUMIMPL
20#define ____H_MEDIUMIMPL
21#ifndef RT_WITHOUT_PRAGMA_ONCE
22# pragma once
23#endif
24
25#include <VBox/vd.h>
26#include "MediumWrap.h"
27#include "VirtualBoxBase.h"
28#include "AutoCaller.h"
29#include "SecretKeyStore.h"
30class Progress;
31class MediumFormat;
32class MediumLockList;
33struct MediumCryptoFilterSettings;
34
35namespace settings
36{
37 struct Medium;
38}
39
40////////////////////////////////////////////////////////////////////////////////
41
42/**
43 * Medium component class for all media types.
44 */
45class ATL_NO_VTABLE Medium :
46 public MediumWrap
47{
48public:
49 DECLARE_EMPTY_CTOR_DTOR(Medium)
50
51 HRESULT FinalConstruct();
52 void FinalRelease();
53
54 enum HDDOpenMode { OpenReadWrite, OpenReadOnly };
55 // have to use a special enum for the overloaded init() below;
56 // can't use AccessMode_T from XIDL because that's mapped to an int
57 // and would be ambiguous
58
59 // public initializer/uninitializer for internal purposes only
60
61 // initializer to create empty medium (VirtualBox::CreateMedium())
62 HRESULT init(VirtualBox *aVirtualBox,
63 const Utf8Str &aFormat,
64 const Utf8Str &aLocation,
65 const Guid &uuidMachineRegistry,
66 const DeviceType_T aDeviceType);
67
68 // initializer for opening existing media
69 // (VirtualBox::OpenMedium(); Machine::AttachDevice())
70 HRESULT init(VirtualBox *aVirtualBox,
71 const Utf8Str &aLocation,
72 HDDOpenMode enOpenMode,
73 bool fForceNewUuid,
74 DeviceType_T aDeviceType);
75
76 // initializer used when loading settings
77 HRESULT initOne(Medium *aParent,
78 DeviceType_T aDeviceType,
79 const Guid &uuidMachineRegistry,
80 const settings::Medium &data,
81 const Utf8Str &strMachineFolder);
82 HRESULT init(VirtualBox *aVirtualBox,
83 Medium *aParent,
84 DeviceType_T aDeviceType,
85 const Guid &uuidMachineRegistry,
86 const settings::Medium &data,
87 const Utf8Str &strMachineFolder,
88 AutoWriteLock &mediaTreeLock);
89
90 // initializer for host floppy/DVD
91 HRESULT init(VirtualBox *aVirtualBox,
92 DeviceType_T aDeviceType,
93 const Utf8Str &aLocation,
94 const Utf8Str &aDescription = Utf8Str::Empty);
95
96 void uninit();
97
98 void i_deparent();
99 void i_setParent(const ComObjPtr<Medium> &pParent);
100
101 // unsafe methods for internal purposes only (ensure there is
102 // a caller and a read lock before calling them!)
103 const ComObjPtr<Medium>& i_getParent() const;
104 const MediaList& i_getChildren() const;
105
106 const Guid& i_getId() const;
107 MediumState_T i_getState() const;
108 MediumVariant_T i_getVariant() const;
109 bool i_isHostDrive() const;
110 const Utf8Str& i_getLocationFull() const;
111 const Utf8Str& i_getFormat() const;
112 const ComObjPtr<MediumFormat> & i_getMediumFormat() const;
113 bool i_isMediumFormatFile() const;
114 uint64_t i_getSize() const;
115 uint64_t i_getLogicalSize() const;
116 DeviceType_T i_getDeviceType() const;
117 MediumType_T i_getType() const;
118 Utf8Str i_getName();
119
120 /* handles caller/locking itself */
121 bool i_addRegistry(const Guid &id);
122 /* handles caller/locking itself, caller is responsible for tree lock */
123 bool i_addRegistryRecursive(const Guid &id);
124 /* handles caller/locking itself */
125 bool i_removeRegistry(const Guid& id);
126 /* handles caller/locking itself, caller is responsible for tree lock */
127 bool i_removeRegistryRecursive(const Guid& id);
128 bool i_isInRegistry(const Guid& id);
129 bool i_getFirstRegistryMachineId(Guid &uuid) const;
130 void i_markRegistriesModified();
131
132 HRESULT i_setPropertyDirect(const Utf8Str &aName, const Utf8Str &aValue);
133
134 HRESULT i_addBackReference(const Guid &aMachineId,
135 const Guid &aSnapshotId = Guid::Empty);
136 HRESULT i_removeBackReference(const Guid &aMachineId,
137 const Guid &aSnapshotId = Guid::Empty);
138
139
140 const Guid* i_getFirstMachineBackrefId() const;
141 const Guid* i_getAnyMachineBackref() const;
142 const Guid* i_getFirstMachineBackrefSnapshotId() const;
143 size_t i_getMachineBackRefCount() const;
144
145#ifdef DEBUG
146 void i_dumpBackRefs();
147#endif
148
149 HRESULT i_updatePath(const Utf8Str &strOldPath, const Utf8Str &strNewPath);
150
151 /* handles caller/locking itself */
152 ComObjPtr<Medium> i_getBase(uint32_t *aLevel = NULL);
153 /* handles caller/locking itself */
154 uint32_t i_getDepth();
155
156 bool i_isReadOnly();
157 void i_updateId(const Guid &id);
158
159 void i_saveSettingsOne(settings::Medium &data,
160 const Utf8Str &strHardDiskFolder);
161 HRESULT i_saveSettings(settings::Medium &data,
162 const Utf8Str &strHardDiskFolder);
163
164 HRESULT i_createMediumLockList(bool fFailIfInaccessible,
165 Medium *pToLock,
166 bool fMediumLockWriteAll,
167 Medium *pToBeParent,
168 MediumLockList &mediumLockList);
169
170 HRESULT i_createDiffStorage(ComObjPtr<Medium> &aTarget,
171 MediumVariant_T aVariant,
172 MediumLockList *pMediumLockList,
173 ComObjPtr<Progress> *aProgress,
174 bool aWait,
175 bool aNotify);
176 Utf8Str i_getPreferredDiffFormat();
177 MediumVariant_T i_getPreferredDiffVariant();
178
179 HRESULT i_close(AutoCaller &autoCaller);
180 HRESULT i_unlockRead(MediumState_T *aState);
181 HRESULT i_unlockWrite(MediumState_T *aState);
182 HRESULT i_deleteStorage(ComObjPtr<Progress> *aProgress, bool aWait, bool aNotify);
183 HRESULT i_markForDeletion();
184 HRESULT i_unmarkForDeletion();
185 HRESULT i_markLockedForDeletion();
186 HRESULT i_unmarkLockedForDeletion();
187
188 HRESULT i_queryPreferredMergeDirection(const ComObjPtr<Medium> &pOther,
189 bool &fMergeForward);
190
191 HRESULT i_prepareMergeTo(const ComObjPtr<Medium> &pTarget,
192 const Guid *aMachineId,
193 const Guid *aSnapshotId,
194 bool fLockMedia,
195 bool &fMergeForward,
196 ComObjPtr<Medium> &pParentForTarget,
197 MediumLockList * &aChildrenToReparent,
198 MediumLockList * &aMediumLockList);
199 HRESULT i_mergeTo(const ComObjPtr<Medium> &pTarget,
200 bool fMergeForward,
201 const ComObjPtr<Medium> &pParentForTarget,
202 MediumLockList *aChildrenToReparent,
203 MediumLockList *aMediumLockList,
204 ComObjPtr<Progress> *aProgress,
205 bool aWait,
206 bool aNotify);
207 void i_cancelMergeTo(MediumLockList *aChildrenToReparent,
208 MediumLockList *aMediumLockList);
209
210 HRESULT i_resize(LONG64 aLogicalSize,
211 MediumLockList *aMediumLockList,
212 ComObjPtr<Progress> *aProgress,
213 bool aWait,
214 bool aNotify);
215
216 HRESULT i_fixParentUuidOfChildren(MediumLockList *pChildrenToReparent);
217
218 HRESULT i_addRawToFss(const char *aFilename, SecretKeyStore *pKeyStore, RTVFSFSSTREAM hVfsFssDst,
219 const ComObjPtr<Progress> &aProgress, bool fSparse);
220
221 HRESULT i_exportFile(const char *aFilename,
222 const ComObjPtr<MediumFormat> &aFormat,
223 MediumVariant_T aVariant,
224 SecretKeyStore *pKeyStore,
225 RTVFSIOSTREAM hVfsIosDst,
226 const ComObjPtr<Progress> &aProgress);
227 HRESULT i_importFile(const char *aFilename,
228 const ComObjPtr<MediumFormat> &aFormat,
229 MediumVariant_T aVariant,
230 RTVFSIOSTREAM hVfsIosSrc,
231 const ComObjPtr<Medium> &aParent,
232 const ComObjPtr<Progress> &aProgress,
233 bool aNotify);
234
235 HRESULT i_cloneToEx(const ComObjPtr<Medium> &aTarget, MediumVariant_T aVariant,
236 const ComObjPtr<Medium> &aParent, IProgress **aProgress,
237 uint32_t idxSrcImageSame, uint32_t idxDstImageSame, bool aNotify);
238
239 const Utf8Str& i_getKeyId();
240
241 HRESULT i_openForIO(bool fWritable, SecretKeyStore *pKeyStore, PVDISK *ppHdd, MediumLockList *pMediumLockList,
242 struct MediumCryptoFilterSettings *pCryptoSettings);
243
244private:
245
246 // wrapped IMedium properties
247 HRESULT getId(com::Guid &aId);
248 HRESULT getDescription(AutoCaller &autoCaller, com::Utf8Str &aDescription);
249 HRESULT setDescription(AutoCaller &autoCaller, const com::Utf8Str &aDescription);
250 HRESULT getState(MediumState_T *aState);
251 HRESULT getVariant(std::vector<MediumVariant_T> &aVariant);
252 HRESULT getLocation(com::Utf8Str &aLocation);
253 HRESULT setLocation(const com::Utf8Str &aLocation);
254 HRESULT getName(com::Utf8Str &aName);
255 HRESULT getDeviceType(DeviceType_T *aDeviceType);
256 HRESULT getHostDrive(BOOL *aHostDrive);
257 HRESULT getSize(LONG64 *aSize);
258 HRESULT getFormat(com::Utf8Str &aFormat);
259 HRESULT getMediumFormat(ComPtr<IMediumFormat> &aMediumFormat);
260 HRESULT getType(AutoCaller &autoCaller, MediumType_T *aType);
261 HRESULT setType(AutoCaller &autoCaller, MediumType_T aType);
262 HRESULT getAllowedTypes(std::vector<MediumType_T> &aAllowedTypes);
263 HRESULT getParent(AutoCaller &autoCaller, ComPtr<IMedium> &aParent);
264 HRESULT getChildren(AutoCaller &autoCaller, std::vector<ComPtr<IMedium> > &aChildren);
265 HRESULT getBase(AutoCaller &autoCaller, ComPtr<IMedium> &aBase);
266 HRESULT getReadOnly(AutoCaller &autoCaller, BOOL *aReadOnly);
267 HRESULT getLogicalSize(LONG64 *aLogicalSize);
268 HRESULT getAutoReset(BOOL *aAutoReset);
269 HRESULT setAutoReset(BOOL aAutoReset);
270 HRESULT getLastAccessError(com::Utf8Str &aLastAccessError);
271 HRESULT getMachineIds(std::vector<com::Guid> &aMachineIds);
272
273 // wrapped IMedium methods
274 HRESULT setIds(AutoCaller &aAutoCaller,
275 BOOL aSetImageId,
276 const com::Guid &aImageId,
277 BOOL aSetParentId,
278 const com::Guid &aParentId);
279 HRESULT refreshState(AutoCaller &aAutoCaller,
280 MediumState_T *aState);
281 HRESULT getSnapshotIds(const com::Guid &aMachineId,
282 std::vector<com::Guid> &aSnapshotIds);
283 HRESULT lockRead(ComPtr<IToken> &aToken);
284 HRESULT lockWrite(ComPtr<IToken> &aToken);
285 HRESULT close(AutoCaller &aAutoCaller);
286 HRESULT getProperty(const com::Utf8Str &aName,
287 com::Utf8Str &aValue);
288 HRESULT setProperty(const com::Utf8Str &aName,
289 const com::Utf8Str &aValue);
290 HRESULT getProperties(const com::Utf8Str &aNames,
291 std::vector<com::Utf8Str> &aReturnNames,
292 std::vector<com::Utf8Str> &aReturnValues);
293 HRESULT setProperties(const std::vector<com::Utf8Str> &aNames,
294 const std::vector<com::Utf8Str> &aValues);
295 HRESULT createBaseStorage(LONG64 aLogicalSize,
296 const std::vector<MediumVariant_T> &aVariant,
297 ComPtr<IProgress> &aProgress);
298 HRESULT deleteStorage(ComPtr<IProgress> &aProgress);
299 HRESULT createDiffStorage(AutoCaller &autoCaller,
300 const ComPtr<IMedium> &aTarget,
301 const std::vector<MediumVariant_T> &aVariant,
302 ComPtr<IProgress> &aProgress);
303 HRESULT mergeTo(const ComPtr<IMedium> &aTarget,
304 ComPtr<IProgress> &aProgress);
305 HRESULT cloneTo(const ComPtr<IMedium> &aTarget,
306 const std::vector<MediumVariant_T> &aVariant,
307 const ComPtr<IMedium> &aParent,
308 ComPtr<IProgress> &aProgress);
309 HRESULT cloneToBase(const ComPtr<IMedium> &aTarget,
310 const std::vector<MediumVariant_T> &aVariant,
311 ComPtr<IProgress> &aProgress);
312 HRESULT moveTo(AutoCaller &autoCaller,
313 const com::Utf8Str &aLocation,
314 ComPtr<IProgress> &aProgress);
315 HRESULT compact(ComPtr<IProgress> &aProgress);
316 HRESULT resize(LONG64 aLogicalSize,
317 ComPtr<IProgress> &aProgress);
318 HRESULT reset(AutoCaller &autoCaller, ComPtr<IProgress> &aProgress);
319 HRESULT changeEncryption(const com::Utf8Str &aCurrentPassword, const com::Utf8Str &aCipher,
320 const com::Utf8Str &aNewPassword, const com::Utf8Str &aNewPasswordId,
321 ComPtr<IProgress> &aProgress);
322 HRESULT getEncryptionSettings(AutoCaller &autoCaller, com::Utf8Str &aCipher, com::Utf8Str &aPasswordId);
323 HRESULT checkEncryptionPassword(const com::Utf8Str &aPassword);
324 HRESULT openForIO(BOOL aWritable, com::Utf8Str const &aPassword, ComPtr<IMediumIO> &aMediumIO);
325
326 // Private internal nmethods
327 HRESULT i_queryInfo(bool fSetImageId, bool fSetParentId, AutoCaller &autoCaller);
328 HRESULT i_canClose();
329 HRESULT i_unregisterWithVirtualBox();
330 HRESULT i_setStateError();
331 HRESULT i_setLocation(const Utf8Str &aLocation, const Utf8Str &aFormat = Utf8Str::Empty);
332 HRESULT i_setFormat(const Utf8Str &aFormat);
333 VDTYPE i_convertDeviceType();
334 DeviceType_T i_convertToDeviceType(VDTYPE enmType);
335 Utf8Str i_vdError(int aVRC);
336
337 bool i_isPropertyForFilter(const com::Utf8Str &aName);
338
339 HRESULT i_getFilterProperties(std::vector<com::Utf8Str> &aReturnNames,
340 std::vector<com::Utf8Str> &aReturnValues);
341
342 HRESULT i_preparationForMoving(const Utf8Str &aLocation);
343 bool i_isMoveOperation(const ComObjPtr<Medium> &pTarget) const;
344 bool i_resetMoveOperationData();
345 Utf8Str i_getNewLocationForMoving() const;
346
347 static DECLCALLBACK(void) i_vdErrorCall(void *pvUser, int rc, RT_SRC_POS_DECL,
348 const char *pszFormat, va_list va);
349 static DECLCALLBACK(bool) i_vdConfigAreKeysValid(void *pvUser,
350 const char *pszzValid);
351 static DECLCALLBACK(int) i_vdConfigQuerySize(void *pvUser, const char *pszName,
352 size_t *pcbValue);
353 static DECLCALLBACK(int) i_vdConfigQuery(void *pvUser, const char *pszName,
354 char *pszValue, size_t cchValue);
355 static DECLCALLBACK(int) i_vdTcpSocketCreate(uint32_t fFlags, PVDSOCKET pSock);
356 static DECLCALLBACK(int) i_vdTcpSocketDestroy(VDSOCKET Sock);
357 static DECLCALLBACK(int) i_vdTcpClientConnect(VDSOCKET Sock, const char *pszAddress, uint32_t uPort,
358 RTMSINTERVAL cMillies);
359 static DECLCALLBACK(int) i_vdTcpClientClose(VDSOCKET Sock);
360 static DECLCALLBACK(bool) i_vdTcpIsClientConnected(VDSOCKET Sock);
361 static DECLCALLBACK(int) i_vdTcpSelectOne(VDSOCKET Sock, RTMSINTERVAL cMillies);
362 static DECLCALLBACK(int) i_vdTcpRead(VDSOCKET Sock, void *pvBuffer, size_t cbBuffer, size_t *pcbRead);
363 static DECLCALLBACK(int) i_vdTcpWrite(VDSOCKET Sock, const void *pvBuffer, size_t cbBuffer);
364 static DECLCALLBACK(int) i_vdTcpSgWrite(VDSOCKET Sock, PCRTSGBUF pSgBuf);
365 static DECLCALLBACK(int) i_vdTcpFlush(VDSOCKET Sock);
366 static DECLCALLBACK(int) i_vdTcpSetSendCoalescing(VDSOCKET Sock, bool fEnable);
367 static DECLCALLBACK(int) i_vdTcpGetLocalAddress(VDSOCKET Sock, PRTNETADDR pAddr);
368 static DECLCALLBACK(int) i_vdTcpGetPeerAddress(VDSOCKET Sock, PRTNETADDR pAddr);
369
370 static DECLCALLBACK(bool) i_vdCryptoConfigAreKeysValid(void *pvUser,
371 const char *pszzValid);
372 static DECLCALLBACK(int) i_vdCryptoConfigQuerySize(void *pvUser, const char *pszName,
373 size_t *pcbValue);
374 static DECLCALLBACK(int) i_vdCryptoConfigQuery(void *pvUser, const char *pszName,
375 char *pszValue, size_t cchValue);
376
377 static DECLCALLBACK(int) i_vdCryptoKeyRetain(void *pvUser, const char *pszId,
378 const uint8_t **ppbKey, size_t *pcbKey);
379 static DECLCALLBACK(int) i_vdCryptoKeyRelease(void *pvUser, const char *pszId);
380 static DECLCALLBACK(int) i_vdCryptoKeyStorePasswordRetain(void *pvUser, const char *pszId, const char **ppszPassword);
381 static DECLCALLBACK(int) i_vdCryptoKeyStorePasswordRelease(void *pvUser, const char *pszId);
382 static DECLCALLBACK(int) i_vdCryptoKeyStoreSave(void *pvUser, const void *pvKeyStore, size_t cbKeyStore);
383 static DECLCALLBACK(int) i_vdCryptoKeyStoreReturnParameters(void *pvUser, const char *pszCipher,
384 const uint8_t *pbDek, size_t cbDek);
385
386 class Task;
387 class CreateBaseTask;
388 class CreateDiffTask;
389 class CloneTask;
390 class MoveTask;
391 class CompactTask;
392 class ResizeTask;
393 class ResetTask;
394 class DeleteTask;
395 class MergeTask;
396 class ImportTask;
397 class EncryptTask;
398 friend class Task;
399 friend class CreateBaseTask;
400 friend class CreateDiffTask;
401 friend class CloneTask;
402 friend class MoveTask;
403 friend class CompactTask;
404 friend class ResizeTask;
405 friend class ResetTask;
406 friend class DeleteTask;
407 friend class MergeTask;
408 friend class ImportTask;
409 friend class EncryptTask;
410
411 HRESULT i_taskCreateBaseHandler(Medium::CreateBaseTask &task);
412 HRESULT i_taskCreateDiffHandler(Medium::CreateDiffTask &task);
413 HRESULT i_taskMergeHandler(Medium::MergeTask &task);
414 HRESULT i_taskCloneHandler(Medium::CloneTask &task);
415 HRESULT i_taskMoveHandler(Medium::MoveTask &task);
416 HRESULT i_taskDeleteHandler(Medium::DeleteTask &task);
417 HRESULT i_taskResetHandler(Medium::ResetTask &task);
418 HRESULT i_taskCompactHandler(Medium::CompactTask &task);
419 HRESULT i_taskResizeHandler(Medium::ResizeTask &task);
420 HRESULT i_taskImportHandler(Medium::ImportTask &task);
421 HRESULT i_taskEncryptHandler(Medium::EncryptTask &task);
422
423 void i_taskEncryptSettingsSetup(struct MediumCryptoFilterSettings *pSettings, const char *pszCipher,
424 const char *pszKeyStore, const char *pszPassword,
425 bool fCreateKeyStore);
426
427 struct Data; // opaque data struct, defined in MediumImpl.cpp
428 Data *m;
429};
430
431
432/**
433 * Settings for a crypto filter instance.
434 */
435struct MediumCryptoFilterSettings
436{
437 MediumCryptoFilterSettings()
438 : fCreateKeyStore(false),
439 pszPassword(NULL),
440 pszKeyStore(NULL),
441 pszKeyStoreLoad(NULL),
442 pbDek(NULL),
443 cbDek(0),
444 pszCipher(NULL),
445 pszCipherReturned(NULL)
446 { }
447
448 bool fCreateKeyStore;
449 const char *pszPassword;
450 char *pszKeyStore;
451 const char *pszKeyStoreLoad;
452
453 const uint8_t *pbDek;
454 size_t cbDek;
455 const char *pszCipher;
456
457 /** The cipher returned by the crypto filter. */
458 char *pszCipherReturned;
459
460 PVDINTERFACE vdFilterIfaces;
461
462 VDINTERFACECONFIG vdIfCfg;
463 VDINTERFACECRYPTO vdIfCrypto;
464};
465
466
467
468#endif /* !____H_MEDIUMIMPL */
469
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