1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
|
/* $Id: MediumFormatImpl.cpp $ */
/** @file
* MediumFormat COM class implementation
*/
/*
* Copyright (C) 2008-2023 Oracle and/or its affiliates.
*
* This file is part of VirtualBox base platform packages, as
* available from https://www.virtualbox.org.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation, in version 3 of the
* License.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <https://www.gnu.org/licenses>.
*
* SPDX-License-Identifier: GPL-3.0-only
*/
#define LOG_GROUP LOG_GROUP_MAIN_MEDIUMFORMAT
#include "MediumFormatImpl.h"
#include "AutoCaller.h"
#include "LoggingNew.h"
#include <VBox/vd.h>
#include <iprt/cpp/utils.h>
// constructor / destructor
/////////////////////////////////////////////////////////////////////////////
DEFINE_EMPTY_CTOR_DTOR(MediumFormat)
HRESULT MediumFormat::FinalConstruct()
{
return BaseFinalConstruct();
}
void MediumFormat::FinalRelease()
{
uninit();
BaseFinalRelease();
}
// public initializer/uninitializer for internal purposes only
/////////////////////////////////////////////////////////////////////////////
/**
* Initializes the hard disk format object.
*
* @param aVDInfo Pointer to a backend info object.
*/
HRESULT MediumFormat::init(const VDBACKENDINFO *aVDInfo)
{
LogFlowThisFunc(("aVDInfo=%p\n", aVDInfo));
ComAssertRet(aVDInfo, E_INVALIDARG);
/* Enclose the state transition NotReady->InInit->Ready */
AutoInitSpan autoInitSpan(this);
AssertReturn(autoInitSpan.isOk(), E_FAIL);
/* The ID of the backend */
unconst(m.strId) = aVDInfo->pszBackend;
/* The Name of the backend */
/* Use id for now as long as VDBACKENDINFO hasn't any extra
* name/description field. */
unconst(m.strName) = aVDInfo->pszBackend;
/* The capabilities of the backend. Assumes 1:1 mapping! */
unconst(m.capabilities) = (MediumFormatCapabilities_T)aVDInfo->uBackendCaps;
/* Save the supported file extensions in a list */
if (aVDInfo->paFileExtensions)
{
PCVDFILEEXTENSION papExtension = aVDInfo->paFileExtensions;
while (papExtension->pszExtension != NULL)
{
DeviceType_T devType;
unconst(m.maFileExtensions).push_back(papExtension->pszExtension);
switch(papExtension->enmType)
{
case VDTYPE_HDD:
devType = DeviceType_HardDisk;
break;
case VDTYPE_OPTICAL_DISC:
devType = DeviceType_DVD;
break;
case VDTYPE_FLOPPY:
devType = DeviceType_Floppy;
break;
default:
AssertMsgFailed(("Invalid enm type %d!\n", papExtension->enmType));
return E_INVALIDARG;
}
unconst(m.maDeviceTypes).push_back(devType);
++papExtension;
}
}
/* Save a list of configure properties */
if (aVDInfo->paConfigInfo)
{
PCVDCONFIGINFO pa = aVDInfo->paConfigInfo;
/* Walk through all available keys */
while (pa->pszKey != NULL)
{
Utf8Str defaultValue("");
DataType_T dt;
ULONG flags = static_cast<ULONG>(pa->uKeyFlags);
/* Check for the configure data type */
switch (pa->enmValueType)
{
case VDCFGVALUETYPE_INTEGER:
{
dt = DataType_Int32;
/* If there is a default value get them in the right format */
if (pa->pszDefaultValue)
defaultValue = pa->pszDefaultValue;
break;
}
case VDCFGVALUETYPE_BYTES:
{
dt = DataType_Int8;
/* If there is a default value get them in the right format */
if (pa->pszDefaultValue)
{
/* Copy the bytes over - treated simply as a string */
defaultValue = pa->pszDefaultValue;
flags |= DataFlags_Array;
}
break;
}
case VDCFGVALUETYPE_STRING:
{
dt = DataType_String;
/* If there is a default value get them in the right format */
if (pa->pszDefaultValue)
defaultValue = pa->pszDefaultValue;
break;
}
default:
AssertMsgFailed(("Invalid enm type %d!\n", pa->enmValueType));
return E_INVALIDARG;
}
/// @todo add extendedFlags to Property when we reach the 32 bit
/// limit (or make the argument ULONG64 after checking that COM is
/// capable of defining enums (used to represent bit flags) that
/// contain 64-bit values)
ComAssertRet(pa->uKeyFlags == ((ULONG)pa->uKeyFlags), E_FAIL);
/* Create one property structure */
const Property prop = { Utf8Str(pa->pszKey),
Utf8Str(""),
dt,
flags,
defaultValue };
unconst(m.maProperties).push_back(prop);
++pa;
}
}
/* Confirm a successful initialization */
autoInitSpan.setSucceeded();
return S_OK;
}
/**
* Uninitializes the instance and sets the ready flag to FALSE.
* Called either from FinalRelease() or by the parent when it gets destroyed.
*/
void MediumFormat::uninit()
{
LogFlowThisFunc(("\n"));
/* Enclose the state transition Ready->InUninit->NotReady */
AutoUninitSpan autoUninitSpan(this);
if (autoUninitSpan.uninitDone())
return;
unconst(m.maProperties).clear();
unconst(m.maFileExtensions).clear();
unconst(m.maDeviceTypes).clear();
unconst(m.capabilities) = (MediumFormatCapabilities_T)0;
unconst(m.strName).setNull();
unconst(m.strId).setNull();
}
// IMediumFormat properties
/////////////////////////////////////////////////////////////////////////////
HRESULT MediumFormat::getId(com::Utf8Str &aId)
{
/* this is const, no need to lock */
aId = m.strId;
return S_OK;
}
HRESULT MediumFormat::getName(com::Utf8Str &aName)
{
/* this is const, no need to lock */
aName = m.strName;
return S_OK;
}
HRESULT MediumFormat::getCapabilities(std::vector<MediumFormatCapabilities_T> &aCapabilities)
{
/* m.capabilities is const, no need to lock */
aCapabilities.resize(sizeof(MediumFormatCapabilities_T) * 8);
size_t cCapabilities = 0;
for (size_t i = 0; i < aCapabilities.size(); i++)
{
uint64_t tmp = m.capabilities;
tmp &= 1ULL << i;
if (tmp)
aCapabilities[cCapabilities++] = (MediumFormatCapabilities_T)tmp;
}
aCapabilities.resize(RT_MAX(cCapabilities, 1));
return S_OK;
}
// IMediumFormat methods
/////////////////////////////////////////////////////////////////////////////
HRESULT MediumFormat::describeFileExtensions(std::vector<com::Utf8Str> &aExtensions,
std::vector<DeviceType_T> &aTypes)
{
/* this is const, no need to lock */
aExtensions = m.maFileExtensions;
aTypes = m.maDeviceTypes;
return S_OK;
}
HRESULT MediumFormat::describeProperties(std::vector<com::Utf8Str> &aNames,
std::vector<com::Utf8Str> &aDescriptions,
std::vector<DataType_T> &aTypes,
std::vector<ULONG> &aFlags,
std::vector<com::Utf8Str> &aDefaults)
{
/* this is const, no need to lock */
size_t c = m.maProperties.size();
aNames.resize(c);
aDescriptions.resize(c);
aTypes.resize(c);
aFlags.resize(c);
aDefaults.resize(c);
for (size_t i = 0; i < c; i++)
{
const Property &prop = m.maProperties[i];
aNames[i] = prop.strName;
aDescriptions[i] = prop.strDescription;
aTypes[i] = prop.type;
aFlags[i] = prop.flags;
aDefaults[i] = prop.strDefaultValue;
}
return S_OK;
}
// public methods only for internal purposes
/////////////////////////////////////////////////////////////////////////////
/* vi: set tabstop=4 shiftwidth=4 expandtab: */
|
