VirtualBox

source: vbox/trunk/src/VBox/Main/src-server/ApplianceImpl.cpp@ 107116

Last change on this file since 107116 was 106971, checked in by vboxsync, 5 months ago

VBox/ostypes.h+Main/{Global,Appliance}+VMMDev: Add a new OStype for Windows
Server 2025. This complements the icon changes made in r165859.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 74.2 KB
Line 
1/* $Id: ApplianceImpl.cpp 106971 2024-11-12 20:31:00Z vboxsync $ */
2/** @file
3 * IAppliance and IVirtualSystem COM class implementations.
4 */
5
6/*
7 * Copyright (C) 2008-2024 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28
29/*********************************************************************************************************************************
30* Header Files *
31*********************************************************************************************************************************/
32#define LOG_GROUP LOG_GROUP_MAIN_APPLIANCE
33#include <iprt/path.h>
34#include <iprt/cpp/path.h>
35#include <iprt/cpp/utils.h>
36#include <VBox/com/array.h>
37#include <map>
38
39#include "ApplianceImpl.h"
40#include "VFSExplorerImpl.h"
41#include "VirtualBoxImpl.h"
42#include "GuestOSTypeImpl.h"
43#include "Global.h"
44#include "ProgressImpl.h"
45#include "MachineImpl.h"
46#include "SystemPropertiesImpl.h"
47#include "AutoCaller.h"
48#include "LoggingNew.h"
49#include "CertificateImpl.h"
50
51#include "ApplianceImplPrivate.h"
52
53using namespace std;
54
55
56/*********************************************************************************************************************************
57* Global Variables *
58*********************************************************************************************************************************/
59static const char * const g_pszISOURI = "http://www.ecma-international.org/publications/standards/Ecma-119.htm";
60static const char * const g_pszVMDKStreamURI = "http://www.vmware.com/interfaces/specifications/vmdk.html#streamOptimized";
61static const char * const g_pszVMDKSparseURI = "http://www.vmware.com/specifications/vmdk.html#sparse";
62static const char * const g_pszVMDKCompressedURI = "http://www.vmware.com/specifications/vmdk.html#compressed";
63static const char * const g_pszVMDKCompressedURI2 = "http://www.vmware.com/interfaces/specifications/vmdk.html#compressed";
64static const char * const g_pszrVHDURI = "http://go.microsoft.com/fwlink/?LinkId=137171";
65static char g_szIsoBackend[128];
66static char g_szVmdkBackend[128];
67static char g_szVhdBackend[128];
68/** Set after the g_szXxxxBackend variables has been initialized. */
69static bool volatile g_fInitializedBackendNames = false;
70
71static struct
72{
73 const char *pszUri, *pszBackend;
74} const g_aUriToBackend[] =
75{
76 { g_pszISOURI, g_szIsoBackend },
77 { g_pszVMDKStreamURI, g_szVmdkBackend },
78 { g_pszVMDKSparseURI, g_szVmdkBackend },
79 { g_pszVMDKCompressedURI, g_szVmdkBackend },
80 { g_pszVMDKCompressedURI2, g_szVmdkBackend },
81 { g_pszrVHDURI, g_szVhdBackend },
82};
83
84static std::map<Utf8Str, Utf8Str> supportedStandardsURI;
85
86static struct
87{
88 ovf::CIMOSType_T cim;
89 VBOXOSTYPE osType;
90} const g_aOsTypes[] =
91{
92 { ovf::CIMOSType_CIMOS_Unknown, VBOXOSTYPE_Unknown },
93 { ovf::CIMOSType_CIMOS_OS2, VBOXOSTYPE_OS2 },
94 { ovf::CIMOSType_CIMOS_OS2, VBOXOSTYPE_OS2Warp3 },
95 { ovf::CIMOSType_CIMOS_OS2, VBOXOSTYPE_OS2Warp4 },
96 { ovf::CIMOSType_CIMOS_OS2, VBOXOSTYPE_OS2Warp45 },
97 { ovf::CIMOSType_CIMOS_OS2, VBOXOSTYPE_OS21x },
98 { ovf::CIMOSType_CIMOS_OS2, VBOXOSTYPE_ECS },
99 { ovf::CIMOSType_CIMOS_OS2, VBOXOSTYPE_ArcaOS },
100 { ovf::CIMOSType_CIMOS_MSDOS, VBOXOSTYPE_DOS },
101 { ovf::CIMOSType_CIMOS_WIN3x, VBOXOSTYPE_Win31 },
102 { ovf::CIMOSType_CIMOS_WIN95, VBOXOSTYPE_Win95 },
103 { ovf::CIMOSType_CIMOS_WIN98, VBOXOSTYPE_Win98 },
104 { ovf::CIMOSType_CIMOS_WINNT, VBOXOSTYPE_WinNT },
105 { ovf::CIMOSType_CIMOS_WINNT, VBOXOSTYPE_WinNT4 },
106 { ovf::CIMOSType_CIMOS_WINNT, VBOXOSTYPE_WinNT3x },
107 { ovf::CIMOSType_CIMOS_NetWare, VBOXOSTYPE_Netware },
108 { ovf::CIMOSType_CIMOS_NovellOES, VBOXOSTYPE_Netware },
109 { ovf::CIMOSType_CIMOS_Solaris, VBOXOSTYPE_Solaris },
110 { ovf::CIMOSType_CIMOS_Solaris_64, VBOXOSTYPE_Solaris_x64 },
111 { ovf::CIMOSType_CIMOS_Solaris, VBOXOSTYPE_Solaris10U8_or_later },
112 { ovf::CIMOSType_CIMOS_Solaris_64, VBOXOSTYPE_Solaris10U8_or_later_x64 },
113 { ovf::CIMOSType_CIMOS_SunOS, VBOXOSTYPE_Solaris },
114 { ovf::CIMOSType_CIMOS_FreeBSD, VBOXOSTYPE_FreeBSD },
115 { ovf::CIMOSType_CIMOS_NetBSD, VBOXOSTYPE_NetBSD },
116 { ovf::CIMOSType_CIMOS_QNX, VBOXOSTYPE_QNX },
117 { ovf::CIMOSType_CIMOS_Windows2000, VBOXOSTYPE_Win2k },
118 { ovf::CIMOSType_CIMOS_WindowsMe, VBOXOSTYPE_WinMe },
119 { ovf::CIMOSType_CIMOS_OpenBSD, VBOXOSTYPE_OpenBSD },
120 { ovf::CIMOSType_CIMOS_WindowsXP, VBOXOSTYPE_WinXP },
121 { ovf::CIMOSType_CIMOS_WindowsXPEmbedded, VBOXOSTYPE_WinXP },
122 { ovf::CIMOSType_CIMOS_WindowsEmbeddedforPointofService, VBOXOSTYPE_WinXP },
123 { ovf::CIMOSType_CIMOS_MicrosoftWindowsServer2003, VBOXOSTYPE_Win2k3 },
124 { ovf::CIMOSType_CIMOS_MicrosoftWindowsServer2003_64, VBOXOSTYPE_Win2k3_x64 },
125 { ovf::CIMOSType_CIMOS_WindowsXP_64, VBOXOSTYPE_WinXP_x64 },
126 { ovf::CIMOSType_CIMOS_WindowsVista, VBOXOSTYPE_WinVista },
127 { ovf::CIMOSType_CIMOS_WindowsVista_64, VBOXOSTYPE_WinVista_x64 },
128 { ovf::CIMOSType_CIMOS_MicrosoftWindowsServer2008, VBOXOSTYPE_Win2k8 },
129 { ovf::CIMOSType_CIMOS_MicrosoftWindowsServer2008_64, VBOXOSTYPE_Win2k8_x64 },
130 { ovf::CIMOSType_CIMOS_FreeBSD_64, VBOXOSTYPE_FreeBSD_x64 },
131 { ovf::CIMOSType_CIMOS_MACOS, VBOXOSTYPE_MacOS },
132 { ovf::CIMOSType_CIMOS_MACOS, VBOXOSTYPE_MacOS_x64 }, // there is no CIM 64-bit type for this
133 { ovf::CIMOSType_CIMOS_MACOS, VBOXOSTYPE_MacOS106 },
134 { ovf::CIMOSType_CIMOS_MACOS, VBOXOSTYPE_MacOS106_x64 },
135 { ovf::CIMOSType_CIMOS_MACOS, VBOXOSTYPE_MacOS107_x64 },
136 { ovf::CIMOSType_CIMOS_MACOS, VBOXOSTYPE_MacOS108_x64 },
137 { ovf::CIMOSType_CIMOS_MACOS, VBOXOSTYPE_MacOS109_x64 },
138 { ovf::CIMOSType_CIMOS_MACOS, VBOXOSTYPE_MacOS1010_x64 },
139 { ovf::CIMOSType_CIMOS_MACOS, VBOXOSTYPE_MacOS1011_x64 },
140 { ovf::CIMOSType_CIMOS_MACOS, VBOXOSTYPE_MacOS1012_x64 },
141 { ovf::CIMOSType_CIMOS_MACOS, VBOXOSTYPE_MacOS1013_x64 },
142
143 // Linuxes
144 { ovf::CIMOSType_CIMOS_RedHatEnterpriseLinux, VBOXOSTYPE_RedHat },
145 { ovf::CIMOSType_CIMOS_RedHatEnterpriseLinux_64, VBOXOSTYPE_RedHat_x64 },
146 { ovf::CIMOSType_CIMOS_RedHatEnterpriseLinux, VBOXOSTYPE_RedHat3 },
147 { ovf::CIMOSType_CIMOS_RedHatEnterpriseLinux_64, VBOXOSTYPE_RedHat3_x64 },
148 { ovf::CIMOSType_CIMOS_RedHatEnterpriseLinux, VBOXOSTYPE_RedHat4 },
149 { ovf::CIMOSType_CIMOS_RedHatEnterpriseLinux_64, VBOXOSTYPE_RedHat4_x64 },
150 { ovf::CIMOSType_CIMOS_RedHatEnterpriseLinux, VBOXOSTYPE_RedHat5 },
151 { ovf::CIMOSType_CIMOS_RedHatEnterpriseLinux_64, VBOXOSTYPE_RedHat5_x64 },
152 { ovf::CIMOSType_CIMOS_RedHatEnterpriseLinux, VBOXOSTYPE_RedHat6 },
153 { ovf::CIMOSType_CIMOS_RedHatEnterpriseLinux_64, VBOXOSTYPE_RedHat6_x64 },
154 { ovf::CIMOSType_CIMOS_RedHatEnterpriseLinux_64, VBOXOSTYPE_RedHat7_x64 }, // 64-bit only
155 { ovf::CIMOSType_CIMOS_RedHatEnterpriseLinux_64, VBOXOSTYPE_RedHat8_x64 }, // 64-bit only
156 { ovf::CIMOSType_CIMOS_RedHatEnterpriseLinux_64, VBOXOSTYPE_RedHat9_x64 }, // 64-bit only
157 { ovf::CIMOSType_CIMOS_SUSE, VBOXOSTYPE_OpenSUSE },
158 { ovf::CIMOSType_CIMOS_SLES, VBOXOSTYPE_SUSE_LE },
159 { ovf::CIMOSType_CIMOS_NovellLinuxDesktop, VBOXOSTYPE_OpenSUSE },
160 { ovf::CIMOSType_CIMOS_SUSE_64, VBOXOSTYPE_OpenSUSE_x64 },
161 { ovf::CIMOSType_CIMOS_SLES_64, VBOXOSTYPE_SUSE_LE_x64 },
162 { ovf::CIMOSType_CIMOS_SUSE_64, VBOXOSTYPE_OpenSUSE_Leap_x64 }, // 64-bit only
163 { ovf::CIMOSType_CIMOS_SUSE, VBOXOSTYPE_OpenSUSE_Tumbleweed },
164 { ovf::CIMOSType_CIMOS_SUSE_64, VBOXOSTYPE_OpenSUSE_Tumbleweed_x64 },
165 { ovf::CIMOSType_CIMOS_LINUX, VBOXOSTYPE_Linux },
166 { ovf::CIMOSType_CIMOS_LINUX, VBOXOSTYPE_Linux22 },
167 { ovf::CIMOSType_CIMOS_SunJavaDesktopSystem, VBOXOSTYPE_Linux },
168 { ovf::CIMOSType_CIMOS_TurboLinux, VBOXOSTYPE_Turbolinux },
169 { ovf::CIMOSType_CIMOS_TurboLinux_64, VBOXOSTYPE_Turbolinux_x64 },
170 { ovf::CIMOSType_CIMOS_Mandriva, VBOXOSTYPE_Mandriva },
171 { ovf::CIMOSType_CIMOS_Mandriva_64, VBOXOSTYPE_Mandriva_x64 },
172 { ovf::CIMOSType_CIMOS_Mandriva, VBOXOSTYPE_OpenMandriva_Lx },
173 { ovf::CIMOSType_CIMOS_Mandriva_64, VBOXOSTYPE_OpenMandriva_Lx_x64 },
174 { ovf::CIMOSType_CIMOS_Mandriva, VBOXOSTYPE_PCLinuxOS },
175 { ovf::CIMOSType_CIMOS_Mandriva_64, VBOXOSTYPE_PCLinuxOS_x64 },
176 { ovf::CIMOSType_CIMOS_Mandriva, VBOXOSTYPE_Mageia },
177 { ovf::CIMOSType_CIMOS_Mandriva_64, VBOXOSTYPE_Mageia_x64 },
178 { ovf::CIMOSType_CIMOS_Ubuntu, VBOXOSTYPE_Ubuntu },
179 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu_x64 },
180 { ovf::CIMOSType_CIMOS_Ubuntu, VBOXOSTYPE_Ubuntu10_LTS },
181 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu10_LTS_x64 },
182 { ovf::CIMOSType_CIMOS_Ubuntu, VBOXOSTYPE_Ubuntu10 },
183 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu10_x64 },
184 { ovf::CIMOSType_CIMOS_Ubuntu, VBOXOSTYPE_Ubuntu11 },
185 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu11_x64 },
186 { ovf::CIMOSType_CIMOS_Ubuntu, VBOXOSTYPE_Ubuntu12_LTS },
187 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu12_LTS_x64 },
188 { ovf::CIMOSType_CIMOS_Ubuntu, VBOXOSTYPE_Ubuntu12 },
189 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu12_x64 },
190 { ovf::CIMOSType_CIMOS_Ubuntu, VBOXOSTYPE_Ubuntu13 },
191 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu13_x64 },
192 { ovf::CIMOSType_CIMOS_Ubuntu, VBOXOSTYPE_Ubuntu14_LTS },
193 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu14_LTS_x64 },
194 { ovf::CIMOSType_CIMOS_Ubuntu, VBOXOSTYPE_Ubuntu14 },
195 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu14_x64 },
196 { ovf::CIMOSType_CIMOS_Ubuntu, VBOXOSTYPE_Ubuntu15 },
197 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu15_x64 },
198 { ovf::CIMOSType_CIMOS_Ubuntu, VBOXOSTYPE_Ubuntu16_LTS },
199 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu16_LTS_x64 },
200 { ovf::CIMOSType_CIMOS_Ubuntu, VBOXOSTYPE_Ubuntu16 },
201 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu16_x64 },
202 { ovf::CIMOSType_CIMOS_Ubuntu, VBOXOSTYPE_Ubuntu17 },
203 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu17_x64 },
204 { ovf::CIMOSType_CIMOS_Ubuntu, VBOXOSTYPE_Ubuntu18_LTS },
205 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu18_LTS_x64 },
206 { ovf::CIMOSType_CIMOS_Ubuntu, VBOXOSTYPE_Ubuntu18 },
207 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu18_x64 },
208 { ovf::CIMOSType_CIMOS_Ubuntu, VBOXOSTYPE_Ubuntu19 },
209 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu19_x64 },
210 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu20_LTS_x64 },
211 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu20_x64 },
212 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu21_x64 },
213 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu22_LTS_x64 },
214 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu22_x64 },
215 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Ubuntu23_x64 },
216 { ovf::CIMOSType_CIMOS_Ubuntu, VBOXOSTYPE_Lubuntu },
217 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Lubuntu_x64 },
218 { ovf::CIMOSType_CIMOS_Ubuntu, VBOXOSTYPE_Xubuntu },
219 { ovf::CIMOSType_CIMOS_Ubuntu_64, VBOXOSTYPE_Xubuntu_x64 },
220 { ovf::CIMOSType_CIMOS_Debian, VBOXOSTYPE_Debian },
221 { ovf::CIMOSType_CIMOS_Debian_64, VBOXOSTYPE_Debian_x64 },
222 { ovf::CIMOSType_CIMOS_Debian, VBOXOSTYPE_Debian31 },
223 { ovf::CIMOSType_CIMOS_Debian, VBOXOSTYPE_Debian4 },
224 { ovf::CIMOSType_CIMOS_Debian_64, VBOXOSTYPE_Debian4_x64 },
225 { ovf::CIMOSType_CIMOS_Debian, VBOXOSTYPE_Debian5 },
226 { ovf::CIMOSType_CIMOS_Debian_64, VBOXOSTYPE_Debian5_x64 },
227 { ovf::CIMOSType_CIMOS_Debian, VBOXOSTYPE_Debian6 },
228 { ovf::CIMOSType_CIMOS_Debian_64, VBOXOSTYPE_Debian6_x64 },
229 { ovf::CIMOSType_CIMOS_Debian, VBOXOSTYPE_Debian7 },
230 { ovf::CIMOSType_CIMOS_Debian_64, VBOXOSTYPE_Debian7_x64 },
231 { ovf::CIMOSType_CIMOS_Debian, VBOXOSTYPE_Debian8 },
232 { ovf::CIMOSType_CIMOS_Debian_64, VBOXOSTYPE_Debian8_x64 },
233 { ovf::CIMOSType_CIMOS_Debian, VBOXOSTYPE_Debian9 },
234 { ovf::CIMOSType_CIMOS_Debian_64, VBOXOSTYPE_Debian9_x64 },
235 { ovf::CIMOSType_CIMOS_Debian, VBOXOSTYPE_Debian10 },
236 { ovf::CIMOSType_CIMOS_Debian_64, VBOXOSTYPE_Debian10_x64 },
237 { ovf::CIMOSType_CIMOS_Debian, VBOXOSTYPE_Debian11 },
238 { ovf::CIMOSType_CIMOS_Debian_64, VBOXOSTYPE_Debian11_x64 },
239 { ovf::CIMOSType_CIMOS_Debian, VBOXOSTYPE_Debian12 },
240 { ovf::CIMOSType_CIMOS_Debian_64, VBOXOSTYPE_Debian12_x64 },
241 { ovf::CIMOSType_CIMOS_Linux_2_4_x, VBOXOSTYPE_Linux24 },
242 { ovf::CIMOSType_CIMOS_Linux_2_4_x_64, VBOXOSTYPE_Linux24_x64 },
243 { ovf::CIMOSType_CIMOS_Linux_2_6_x, VBOXOSTYPE_Linux26 },
244 { ovf::CIMOSType_CIMOS_Linux_2_6_x_64, VBOXOSTYPE_Linux26_x64 },
245 { ovf::CIMOSType_CIMOS_Linux_64, VBOXOSTYPE_Linux26_x64 },
246
247 // types that we have support for but CIM doesn't
248 { ovf::CIMOSType_CIMOS_Linux_2_6_x, VBOXOSTYPE_ArchLinux },
249 { ovf::CIMOSType_CIMOS_Linux_2_6_x_64, VBOXOSTYPE_ArchLinux_x64 },
250 { ovf::CIMOSType_CIMOS_Linux_2_6_x, VBOXOSTYPE_FedoraCore },
251 { ovf::CIMOSType_CIMOS_Linux_2_6_x_64, VBOXOSTYPE_FedoraCore_x64 },
252 { ovf::CIMOSType_CIMOS_Linux_2_6_x, VBOXOSTYPE_Gentoo },
253 { ovf::CIMOSType_CIMOS_Linux_2_6_x_64, VBOXOSTYPE_Gentoo_x64 },
254 { ovf::CIMOSType_CIMOS_Linux_2_6_x, VBOXOSTYPE_Xandros },
255 { ovf::CIMOSType_CIMOS_Linux_2_6_x_64, VBOXOSTYPE_Xandros_x64 },
256 { ovf::CIMOSType_CIMOS_Solaris, VBOXOSTYPE_OpenSolaris },
257 { ovf::CIMOSType_CIMOS_Solaris_64, VBOXOSTYPE_OpenSolaris_x64 },
258
259 // types added with CIM 2.25.0 follow:
260 { ovf::CIMOSType_CIMOS_WindowsServer2008R2, VBOXOSTYPE_Win2k8 }, // duplicate, see above
261// { ovf::CIMOSType_CIMOS_VMwareESXi = 104, // we can't run ESX in a VM
262 { ovf::CIMOSType_CIMOS_Windows7, VBOXOSTYPE_Win7 },
263 { ovf::CIMOSType_CIMOS_Windows7, VBOXOSTYPE_Win7_x64 }, // there is no
264 // CIM 64-bit type for this
265 { ovf::CIMOSType_CIMOS_CentOS, VBOXOSTYPE_RedHat },
266 { ovf::CIMOSType_CIMOS_CentOS_64, VBOXOSTYPE_RedHat_x64 },
267 { ovf::CIMOSType_CIMOS_OracleLinux, VBOXOSTYPE_Oracle },
268 { ovf::CIMOSType_CIMOS_OracleLinux_64, VBOXOSTYPE_Oracle_x64 },
269 { ovf::CIMOSType_CIMOS_OracleLinux, VBOXOSTYPE_Oracle4 },
270 { ovf::CIMOSType_CIMOS_OracleLinux_64, VBOXOSTYPE_Oracle4_x64 },
271 { ovf::CIMOSType_CIMOS_OracleLinux, VBOXOSTYPE_Oracle5 },
272 { ovf::CIMOSType_CIMOS_OracleLinux_64, VBOXOSTYPE_Oracle5_x64 },
273 { ovf::CIMOSType_CIMOS_OracleLinux, VBOXOSTYPE_Oracle6 },
274 { ovf::CIMOSType_CIMOS_OracleLinux_64, VBOXOSTYPE_Oracle6_x64 },
275 { ovf::CIMOSType_CIMOS_OracleLinux_64, VBOXOSTYPE_Oracle7_x64 }, // 64-bit only
276 { ovf::CIMOSType_CIMOS_OracleLinux_64, VBOXOSTYPE_Oracle8_x64 }, // 64-bit only
277 { ovf::CIMOSType_CIMOS_OracleLinux_64, VBOXOSTYPE_Oracle9_x64 }, // 64-bit only
278 { ovf::CIMOSType_CIMOS_eComStation, VBOXOSTYPE_ECS },
279
280 { ovf::CIMOSType_CIMOS_WindowsServer2011, VBOXOSTYPE_Win2k8_x64 }, // no 1:1 match on the VBox side
281 { ovf::CIMOSType_CIMOS_WindowsServer2012, VBOXOSTYPE_Win2k12_x64 },
282 { ovf::CIMOSType_CIMOS_Windows8, VBOXOSTYPE_Win8 },
283 { ovf::CIMOSType_CIMOS_Windows8_64, VBOXOSTYPE_Win8_x64 },
284 { ovf::CIMOSType_CIMOS_WindowsServer2012R2, VBOXOSTYPE_Win2k12_x64 },
285 { ovf::CIMOSType_CIMOS_Windows8_1, VBOXOSTYPE_Win81 },
286 { ovf::CIMOSType_CIMOS_Windows8_1_64, VBOXOSTYPE_Win81_x64 },
287 { ovf::CIMOSType_CIMOS_WindowsServer2016, VBOXOSTYPE_Win2k16_x64 },
288 { ovf::CIMOSType_CIMOS_Windows10, VBOXOSTYPE_Win10 },
289 { ovf::CIMOSType_CIMOS_Windows10_64, VBOXOSTYPE_Win10_x64 },
290 { ovf::CIMOSType_CIMOS_WindowsServer2016, VBOXOSTYPE_Win2k19_x64 }, // no CIM type for this yet
291 { ovf::CIMOSType_CIMOS_WindowsServer2016, VBOXOSTYPE_Win2k22_x64 }, // no CIM type for this yet
292 { ovf::CIMOSType_CIMOS_WindowsServer2016, VBOXOSTYPE_Win2k25_x64 }, // no CIM type for this yet
293
294 // there are no CIM types for these, so these turn to "other" on export:
295 // VBOXOSTYPE_OpenBSD
296 // VBOXOSTYPE_OpenBSD_x64
297 // VBOXOSTYPE_NetBSD
298 // VBOXOSTYPE_NetBSD_x64
299
300};
301
302/* Pattern structure for matching the OS type description field */
303struct osTypePattern
304{
305 const char *pcszPattern;
306 VBOXOSTYPE osType;
307};
308
309/* These are the 32-Bit ones. They are sorted by priority. */
310static const osTypePattern g_aOsTypesPattern[] =
311{
312 {"Windows NT", VBOXOSTYPE_WinNT4},
313 {"Windows XP", VBOXOSTYPE_WinXP},
314 {"Windows 2000", VBOXOSTYPE_Win2k},
315 {"Windows 2003", VBOXOSTYPE_Win2k3},
316 {"Windows Vista", VBOXOSTYPE_WinVista},
317 {"Windows 2008", VBOXOSTYPE_Win2k8},
318 {"Windows 7", VBOXOSTYPE_Win7},
319 {"Windows 8.1", VBOXOSTYPE_Win81},
320 {"Windows 8", VBOXOSTYPE_Win8},
321 {"Windows 10", VBOXOSTYPE_Win10},
322 {"SUSE", VBOXOSTYPE_OpenSUSE},
323 {"Novell", VBOXOSTYPE_OpenSUSE},
324 {"Red Hat", VBOXOSTYPE_RedHat},
325 {"Mandriva", VBOXOSTYPE_Mandriva},
326 {"Ubuntu", VBOXOSTYPE_Ubuntu},
327 {"Debian", VBOXOSTYPE_Debian},
328 {"QNX", VBOXOSTYPE_QNX},
329 {"Linux 2.4", VBOXOSTYPE_Linux24},
330 {"Linux 2.6", VBOXOSTYPE_Linux26},
331 {"Linux", VBOXOSTYPE_Linux},
332 {"OpenSolaris", VBOXOSTYPE_OpenSolaris},
333 {"Solaris", VBOXOSTYPE_OpenSolaris},
334 {"FreeBSD", VBOXOSTYPE_FreeBSD},
335 {"NetBSD", VBOXOSTYPE_NetBSD},
336 {"Windows 95", VBOXOSTYPE_Win95},
337 {"Windows 98", VBOXOSTYPE_Win98},
338 {"Windows Me", VBOXOSTYPE_WinMe},
339 {"Windows 3.", VBOXOSTYPE_Win31},
340 {"DOS", VBOXOSTYPE_DOS},
341 {"OS2", VBOXOSTYPE_OS2}
342};
343
344/* These are the 64-Bit ones. They are sorted by priority. */
345static const osTypePattern g_aOsTypesPattern64[] =
346{
347 {"Windows XP", VBOXOSTYPE_WinXP_x64},
348 {"Windows 2003", VBOXOSTYPE_Win2k3_x64},
349 {"Windows Vista", VBOXOSTYPE_WinVista_x64},
350 {"Windows 2008", VBOXOSTYPE_Win2k8_x64},
351 {"Windows 7", VBOXOSTYPE_Win7_x64},
352 {"Windows 8.1", VBOXOSTYPE_Win81_x64},
353 {"Windows 8", VBOXOSTYPE_Win8_x64},
354 {"Windows 2012", VBOXOSTYPE_Win2k12_x64},
355 {"Windows 10", VBOXOSTYPE_Win10_x64},
356 {"Windows 2016", VBOXOSTYPE_Win2k16_x64},
357 {"Windows 2019", VBOXOSTYPE_Win2k19_x64},
358 {"SUSE", VBOXOSTYPE_OpenSUSE_x64},
359 {"Novell", VBOXOSTYPE_OpenSUSE_x64},
360 {"Red Hat", VBOXOSTYPE_RedHat_x64},
361 {"Mandriva", VBOXOSTYPE_Mandriva_x64},
362 {"Ubuntu", VBOXOSTYPE_Ubuntu_x64},
363 {"Debian", VBOXOSTYPE_Debian_x64},
364 {"Linux 2.4", VBOXOSTYPE_Linux24_x64},
365 {"Linux 2.6", VBOXOSTYPE_Linux26_x64},
366 {"Linux", VBOXOSTYPE_Linux26_x64},
367 {"OpenSolaris", VBOXOSTYPE_OpenSolaris_x64},
368 {"Solaris", VBOXOSTYPE_OpenSolaris_x64},
369 {"FreeBSD", VBOXOSTYPE_FreeBSD_x64},
370};
371
372/**
373 * Private helper func that suggests a VirtualBox guest OS type
374 * for the given OVF operating system type.
375 */
376void convertCIMOSType2VBoxOSType(Utf8Str &strType, ovf::CIMOSType_T c, const Utf8Str &cStr)
377{
378 /* First check if the type is other/other_64 */
379 if (c == ovf::CIMOSType_CIMOS_Other)
380 {
381 for (size_t i = 0; i < RT_ELEMENTS(g_aOsTypesPattern); ++i)
382 if (cStr.contains(g_aOsTypesPattern[i].pcszPattern, Utf8Str::CaseInsensitive))
383 {
384 strType = Global::OSTypeId(g_aOsTypesPattern[i].osType);
385 return;
386 }
387 }
388 else if (c == ovf::CIMOSType_CIMOS_Other_64)
389 {
390 for (size_t i = 0; i < RT_ELEMENTS(g_aOsTypesPattern64); ++i)
391 if (cStr.contains(g_aOsTypesPattern64[i].pcszPattern, Utf8Str::CaseInsensitive))
392 {
393 strType = Global::OSTypeId(g_aOsTypesPattern64[i].osType);
394 return;
395 }
396 }
397
398 for (size_t i = 0; i < RT_ELEMENTS(g_aOsTypes); ++i)
399 {
400 if (c == g_aOsTypes[i].cim)
401 {
402 strType = Global::OSTypeId(g_aOsTypes[i].osType);
403 return;
404 }
405 }
406
407 if (c == ovf::CIMOSType_CIMOS_Other_64)
408 strType = Global::OSTypeId(VBOXOSTYPE_Unknown_x64);
409 else
410 strType = Global::OSTypeId(VBOXOSTYPE_Unknown);
411}
412
413/**
414 * Private helper func that suggests a VirtualBox guest OS type
415 * for the given OVF operating system type.
416 * @returns CIM OS type.
417 * @param pcszVBox Our guest OS type identifier string.
418 * @param fLongMode Whether long mode is enabled and a 64-bit CIM type is
419 * preferred even if the VBox guest type isn't 64-bit.
420 */
421ovf::CIMOSType_T convertVBoxOSType2CIMOSType(const char *pcszVBox, BOOL fLongMode)
422{
423 for (size_t i = 0; i < RT_ELEMENTS(g_aOsTypes); ++i)
424 {
425 if (!RTStrICmp(pcszVBox, Global::OSTypeId(g_aOsTypes[i].osType)))
426 {
427 if (fLongMode && !(g_aOsTypes[i].osType & VBOXOSTYPE_x64))
428 {
429 VBOXOSTYPE enmDesiredOsType = (VBOXOSTYPE)((int)g_aOsTypes[i].osType | (int)VBOXOSTYPE_x64);
430 for (size_t j = i+1; j < RT_ELEMENTS(g_aOsTypes); j++)
431 if (g_aOsTypes[j].osType == enmDesiredOsType)
432 return g_aOsTypes[j].cim;
433 if (i > 0)
434 {
435 for (size_t j = i-1; j > 0; j++)
436 if (g_aOsTypes[j].osType == enmDesiredOsType)
437 return g_aOsTypes[j].cim;
438 }
439 /* Not all OSes have 64-bit versions, so just return the 32-bit variant. */
440 }
441 return g_aOsTypes[i].cim;
442 }
443 }
444
445 return fLongMode ? ovf::CIMOSType_CIMOS_Other_64 : ovf::CIMOSType_CIMOS_Other;
446}
447
448Utf8Str convertNetworkAttachmentTypeToString(NetworkAttachmentType_T type)
449{
450 Utf8Str strType;
451 switch (type)
452 {
453 case NetworkAttachmentType_NAT: strType = "NAT"; break;
454 case NetworkAttachmentType_Bridged: strType = "Bridged"; break;
455 case NetworkAttachmentType_Internal: strType = "Internal"; break;
456 case NetworkAttachmentType_HostOnly: strType = "HostOnly"; break;
457 case NetworkAttachmentType_HostOnlyNetwork: strType = "HostOnlyNetwork"; break;
458 case NetworkAttachmentType_Generic: strType = "Generic"; break;
459 case NetworkAttachmentType_NATNetwork: strType = "NATNetwork"; break;
460 case NetworkAttachmentType_Null: strType = "Null"; break;
461 case NetworkAttachmentType_Cloud: strType = "Cloud"; break;
462#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
463 case NetworkAttachmentType_32BitHack: AssertFailedBreak(); /* (compiler warnings) */
464#endif
465 }
466 return strType;
467}
468
469
470////////////////////////////////////////////////////////////////////////////////
471//
472// Appliance constructor / destructor
473//
474// ////////////////////////////////////////////////////////////////////////////////
475
476DEFINE_EMPTY_CTOR_DTOR(VirtualSystemDescription)
477
478HRESULT VirtualSystemDescription::FinalConstruct()
479{
480 return BaseFinalConstruct();
481}
482
483void VirtualSystemDescription::FinalRelease()
484{
485 uninit();
486
487 BaseFinalRelease();
488}
489
490Appliance::Appliance()
491 : mVirtualBox(NULL)
492{
493}
494
495Appliance::~Appliance()
496{
497}
498
499
500HRESULT Appliance::FinalConstruct()
501{
502 return BaseFinalConstruct();
503}
504
505void Appliance::FinalRelease()
506{
507 uninit();
508
509 BaseFinalRelease();
510}
511
512
513////////////////////////////////////////////////////////////////////////////////
514//
515// Internal helpers
516//
517////////////////////////////////////////////////////////////////////////////////
518
519
520////////////////////////////////////////////////////////////////////////////////
521//
522// IVirtualBox public methods
523//
524////////////////////////////////////////////////////////////////////////////////
525
526// This code is here so we won't have to include the appliance headers in the
527// IVirtualBox implementation.
528
529/**
530 * Implementation for IVirtualBox::createAppliance.
531 *
532 * @param aAppliance IAppliance object created if S_OK is returned.
533 * @return S_OK or error.
534 */
535HRESULT VirtualBox::createAppliance(ComPtr<IAppliance> &aAppliance)
536{
537 ComObjPtr<Appliance> appliance;
538 HRESULT hrc = appliance.createObject();
539 if (SUCCEEDED(hrc))
540 {
541 hrc = appliance->init(this);
542 if (SUCCEEDED(hrc))
543 hrc = appliance.queryInterfaceTo(aAppliance.asOutParam());
544 }
545 return hrc;
546}
547
548/**
549 * Appliance COM initializer.
550 * @param aVirtualBox The VirtualBox object.
551 */
552HRESULT Appliance::init(VirtualBox *aVirtualBox)
553{
554 /* Enclose the state transition NotReady->InInit->Ready */
555 AutoInitSpan autoInitSpan(this);
556 AssertReturn(autoInitSpan.isOk(), E_FAIL);
557
558 /* Weak reference to a VirtualBox object */
559 unconst(mVirtualBox) = aVirtualBox;
560
561 // initialize data
562 m = new Data;
563 m->m_pSecretKeyStore = new SecretKeyStore(false /* fRequireNonPageable*/);
564 AssertReturn(m->m_pSecretKeyStore, E_FAIL);
565
566 HRESULT hrc = i_initBackendNames();
567
568 /* Confirm a successful initialization */
569 autoInitSpan.setSucceeded();
570
571 return hrc;
572}
573
574/**
575 * Appliance COM uninitializer.
576 */
577void Appliance::uninit()
578{
579 /* Enclose the state transition Ready->InUninit->NotReady */
580 AutoUninitSpan autoUninitSpan(this);
581 if (autoUninitSpan.uninitDone())
582 return;
583
584 if (m->m_pSecretKeyStore)
585 delete m->m_pSecretKeyStore;
586
587 delete m;
588 m = NULL;
589}
590
591////////////////////////////////////////////////////////////////////////////////
592//
593// IAppliance public methods
594//
595////////////////////////////////////////////////////////////////////////////////
596
597/**
598 * Public method implementation.
599 */
600HRESULT Appliance::getPath(com::Utf8Str &aPath)
601{
602 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
603
604 aPath = m->locInfo.strPath;
605
606 return S_OK;
607}
608
609/**
610 * Public method implementation.
611 */
612HRESULT Appliance::getDisks(std::vector<com::Utf8Str> &aDisks)
613{
614 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
615
616 aDisks.resize(0);
617
618 if (m->pReader) // OVFReader instantiated?
619 {
620 aDisks.resize(m->pReader->m_mapDisks.size());
621
622 ovf::DiskImagesMap::const_iterator it;
623 size_t i = 0;
624 for (it = m->pReader->m_mapDisks.begin();
625 it != m->pReader->m_mapDisks.end();
626 ++it, ++i)
627 {
628 // create a string representing this disk
629 const ovf::DiskImage &d = it->second;
630 char *psz = NULL;
631 RTStrAPrintf(&psz,
632 "%s\t"
633 "%RI64\t"
634 "%RI64\t"
635 "%s\t"
636 "%s\t"
637 "%RI64\t"
638 "%RI64\t"
639 "%s",
640 d.strDiskId.c_str(),
641 d.iCapacity,
642 d.iPopulatedSize,
643 d.strFormat.c_str(),
644 d.strHref.c_str(),
645 d.iSize,
646 d.iChunkSize,
647 d.strCompression.c_str());
648 Utf8Str utf(psz);
649 aDisks[i] = utf;
650 RTStrFree(psz);
651 }
652 }
653
654 return S_OK;
655}
656
657/**
658 * Public method implementation.
659 */
660HRESULT Appliance::getCertificate(ComPtr<ICertificate> &aCertificateInfo)
661{
662 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
663
664 /* Can be NULL at this point, queryInterfaceto handles that. */
665 m->ptrCertificateInfo.queryInterfaceTo(aCertificateInfo.asOutParam());
666 return S_OK;
667}
668
669/**
670 * Public method implementation.
671 */
672HRESULT Appliance::getVirtualSystemDescriptions(std::vector<ComPtr<IVirtualSystemDescription> > &aVirtualSystemDescriptions)
673{
674 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
675
676 aVirtualSystemDescriptions.resize(m->virtualSystemDescriptions.size());
677 std::list< ComObjPtr<VirtualSystemDescription> > vsds(m->virtualSystemDescriptions);
678 size_t i = 0;
679 for (std::list< ComObjPtr<VirtualSystemDescription> >::iterator it = vsds.begin(); it != vsds.end(); ++it, ++i)
680 {
681 (*it).queryInterfaceTo(aVirtualSystemDescriptions[i].asOutParam());
682 }
683 return S_OK;
684}
685
686/**
687 * Public method implementation.
688 */
689HRESULT Appliance::getMachines(std::vector<com::Utf8Str> &aMachines)
690{
691 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
692
693 aMachines.resize(m->llGuidsMachinesCreated.size());
694 size_t i = 0;
695 for (std::list<Guid>::const_iterator it = m->llGuidsMachinesCreated.begin();
696 it != m->llGuidsMachinesCreated.end();
697 ++it, ++i)
698 {
699 const Guid &uuid = *it;
700 aMachines[i] = uuid.toUtf16();
701 }
702 return S_OK;
703}
704
705HRESULT Appliance::createVFSExplorer(const com::Utf8Str &aURI, ComPtr<IVFSExplorer> &aExplorer)
706{
707 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
708
709 ComObjPtr<VFSExplorer> explorer;
710 HRESULT hrc;
711 try
712 {
713 Utf8Str uri(aURI);
714 /* Check which kind of export the user has requested */
715 LocationInfo li;
716 i_parseURI(aURI, li);
717 /* Create the explorer object */
718 explorer.createObject();
719 hrc = explorer->init(li.storageType, li.strPath, li.strHostname, li.strUsername, li.strPassword, mVirtualBox);
720 }
721 catch (HRESULT hrcXcpt)
722 {
723 hrc = hrcXcpt;
724 }
725
726 if (SUCCEEDED(hrc))
727 /* Return explorer to the caller */
728 explorer.queryInterfaceTo(aExplorer.asOutParam());
729
730 return hrc;
731}
732
733
734/**
735 * Public method implementation.
736 * Add the "aRequested" numbers of new empty objects of VSD into the list
737 * "virtualSystemDescriptions".
738 * The parameter "aCreated" keeps the actual number of the added objects.
739 * In case of exception all added objects are removed from the list.
740 */
741HRESULT Appliance::createVirtualSystemDescriptions(ULONG aRequested, ULONG *aCreated)
742{
743 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
744
745 HRESULT hrc = S_OK;
746 uint32_t lQuantity = aRequested;
747 uint32_t i=0;
748
749 if (lQuantity < 1)
750 return setError(E_FAIL, tr("The number of VirtualSystemDescription objects must be at least 1 or more."));
751 try
752 {
753 for (; i<lQuantity; ++i)
754 {
755 ComObjPtr<VirtualSystemDescription> opVSD;
756 hrc = opVSD.createObject();
757 if (SUCCEEDED(hrc))
758 {
759 hrc = opVSD->init();
760 if (SUCCEEDED(hrc))
761 m->virtualSystemDescriptions.push_back(opVSD);
762 else
763 break;
764 }
765 else
766 break;
767 }
768
769 if (i<lQuantity)
770 LogRel(("Number of created VirtualSystemDescription objects is less than requested"
771 "(Requested %d, Created %d)",lQuantity, i));
772
773 *aCreated = i;
774 }
775 catch (HRESULT hrcXcpt)
776 {
777 for (; i>0; --i)
778 {
779 if (!m->virtualSystemDescriptions.empty())
780 m->virtualSystemDescriptions.pop_back();
781 else
782 break;
783 }
784 hrc = hrcXcpt;
785 }
786
787 return hrc;
788}
789
790/**
791 * Public method implementation.
792 */
793HRESULT Appliance::getWarnings(std::vector<com::Utf8Str> &aWarnings)
794{
795 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
796
797 aWarnings.resize(m->llWarnings.size());
798
799 list<Utf8Str>::const_iterator it;
800 size_t i = 0;
801 for (it = m->llWarnings.begin();
802 it != m->llWarnings.end();
803 ++it, ++i)
804 {
805 aWarnings[i] = *it;
806 }
807
808 return S_OK;
809}
810
811HRESULT Appliance::getPasswordIds(std::vector<com::Utf8Str> &aIdentifiers)
812{
813 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
814
815 aIdentifiers = m->m_vecPasswordIdentifiers;
816 return S_OK;
817}
818
819HRESULT Appliance::getMediumIdsForPasswordId(const com::Utf8Str &aPasswordId, std::vector<com::Guid> &aIdentifiers)
820{
821 HRESULT hrc = S_OK;
822 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
823
824 std::map<com::Utf8Str, GUIDVEC>::const_iterator it = m->m_mapPwIdToMediumIds.find(aPasswordId);
825 if (it != m->m_mapPwIdToMediumIds.end())
826 aIdentifiers = it->second;
827 else
828 hrc = setError(E_FAIL, tr("The given password identifier is not associated with any medium"));
829
830 return hrc;
831}
832
833HRESULT Appliance::addPasswords(const std::vector<com::Utf8Str> &aIdentifiers,
834 const std::vector<com::Utf8Str> &aPasswords)
835{
836 HRESULT hrc = S_OK;
837
838 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
839
840 /* Check that the IDs do not exist already before changing anything. */
841 for (unsigned i = 0; i < aIdentifiers.size(); i++)
842 {
843 SecretKey *pKey = NULL;
844 int vrc = m->m_pSecretKeyStore->retainSecretKey(aIdentifiers[i], &pKey);
845 if (vrc != VERR_NOT_FOUND)
846 {
847 AssertPtr(pKey);
848 if (pKey)
849 pKey->release();
850 return setError(VBOX_E_OBJECT_IN_USE, tr("A password with the given ID already exists"));
851 }
852 }
853
854 for (unsigned i = 0; i < aIdentifiers.size() && SUCCEEDED(hrc); i++)
855 {
856 size_t cbKey = aPasswords[i].length() + 1; /* Include terminator */
857 const uint8_t *pbKey = (const uint8_t *)aPasswords[i].c_str();
858
859 int vrc = m->m_pSecretKeyStore->addSecretKey(aIdentifiers[i], pbKey, cbKey);
860 if (RT_SUCCESS(vrc))
861 m->m_cPwProvided++;
862 else if (vrc == VERR_NO_MEMORY)
863 hrc = setError(E_OUTOFMEMORY, tr("Failed to allocate enough secure memory for the key"));
864 else
865 hrc = setErrorBoth(E_FAIL, vrc, tr("Unknown error happened while adding a password (%Rrc)"), vrc);
866 }
867
868 return hrc;
869}
870
871////////////////////////////////////////////////////////////////////////////////
872//
873// Appliance private methods
874//
875////////////////////////////////////////////////////////////////////////////////
876
877HRESULT Appliance::i_initBackendNames()
878{
879 HRESULT hrc = S_OK;
880 if (!g_fInitializedBackendNames)
881 {
882 /*
883 * Use the system properties to translate file extensions into
884 * storage backend names.
885 */
886 static struct
887 {
888 const char *pszExt; /**< extension */
889 char *pszBackendName;
890 size_t cbBackendName;
891 } const s_aFormats[] =
892 {
893 { "iso", g_szIsoBackend, sizeof(g_szIsoBackend) },
894 { "vmdk", g_szVmdkBackend, sizeof(g_szVmdkBackend) },
895 { "vhd", g_szVhdBackend, sizeof(g_szVhdBackend) },
896 };
897 SystemProperties *pSysProps = mVirtualBox->i_getSystemProperties();
898 for (unsigned i = 0; i < RT_ELEMENTS(s_aFormats); i++)
899 {
900 ComObjPtr<MediumFormat> trgFormat = pSysProps->i_mediumFormatFromExtension(s_aFormats[i].pszExt);
901 if (trgFormat.isNotNull())
902 {
903 const char *pszName = trgFormat->i_getName().c_str();
904 int vrc = RTStrCopy(s_aFormats[i].pszBackendName, s_aFormats[i].cbBackendName, pszName);
905 AssertRCStmt(vrc, hrc = setError(E_FAIL, "Unexpected storage backend name copy error %Rrc for %s.", vrc, pszName));
906 }
907 else
908 hrc = setError(E_FAIL, tr("Can't find appropriate medium format for ISO type of a virtual disk."));
909 }
910
911 if (SUCCEEDED(hrc))
912 g_fInitializedBackendNames = true;
913 }
914
915 return hrc;
916}
917
918Utf8Str Appliance::i_typeOfVirtualDiskFormatFromURI(Utf8Str uri) const
919{
920 Assert(g_fInitializedBackendNames);
921
922 unsigned i = RT_ELEMENTS(g_aUriToBackend);
923 while (i-- > 0)
924 if (RTStrICmp(g_aUriToBackend[i].pszUri, uri.c_str()) == 0)
925 return Utf8Str(g_aUriToBackend[i].pszBackend);
926 return Utf8Str();
927}
928
929#if 0 /* unused */
930std::set<Utf8Str> Appliance::i_URIFromTypeOfVirtualDiskFormat(Utf8Str type)
931{
932 Assert(g_fInitializedBackendNames);
933
934 std::set<Utf8Str> UriSet;
935 unsigned i = RT_ELEMENTS(g_aUriToBackend);
936 while (i-- > 0)
937 if (RTStrICmp(g_aUriToBackend[i].pszBackend, type.c_str()) == 0)
938 UriSet.insert(g_aUriToBackend[i].pszUri);
939 return UriSet;
940}
941#endif
942
943/**
944 * Returns a medium format object corresponding to the given
945 * disk image or null if no such format.
946 *
947 * @param di Disk Image
948 * @param mf Medium Format
949 *
950 * @return ComObjPtr<MediumFormat>
951 */
952HRESULT Appliance::i_findMediumFormatFromDiskImage(const ovf::DiskImage &di, ComObjPtr<MediumFormat>& mf)
953{
954 HRESULT hrc = S_OK;
955
956 /* Get the system properties. */
957 SystemProperties *pSysProps = mVirtualBox->i_getSystemProperties();
958
959 /* We need a proper source format description */
960 /* Which format to use? */
961 Utf8Str strSrcFormat = i_typeOfVirtualDiskFormatFromURI(di.strFormat);
962
963 /*
964 * fallback, if we can't determine virtual disk format using URI from the attribute ovf:format
965 * in the corresponding section <Disk> in the OVF file.
966 */
967 if (strSrcFormat.isEmpty())
968 {
969 strSrcFormat = di.strHref;
970
971 /* check either file gzipped or not
972 * if "yes" then remove last extension,
973 * i.e. "image.vmdk.gz"->"image.vmdk"
974 */
975 if (di.strCompression == "gzip")
976 {
977 if (RTPathHasSuffix(strSrcFormat.c_str()))
978 {
979 strSrcFormat.stripSuffix();
980 }
981 else
982 {
983 mf.setNull();
984 hrc = setError(E_FAIL, tr("Internal inconsistency looking up medium format for the disk image '%s'"),
985 di.strHref.c_str());
986 return hrc;
987 }
988 }
989 /* Figure out from extension which format the image of disk has. */
990 if (RTPathHasSuffix(strSrcFormat.c_str()))
991 {
992 const char *pszExt = RTPathSuffix(strSrcFormat.c_str());
993 if (pszExt)
994 pszExt++;
995 mf = pSysProps->i_mediumFormatFromExtension(pszExt);
996 }
997 else
998 mf.setNull();
999 }
1000 else
1001 mf = pSysProps->i_mediumFormat(strSrcFormat);
1002
1003 if (mf.isNull())
1004 hrc = setError(E_FAIL, tr("Internal inconsistency looking up medium format for the disk image '%s'"), di.strHref.c_str());
1005
1006 return hrc;
1007}
1008
1009/**
1010 * Setup automatic I/O stream digest calculation, adding it to hOurManifest.
1011 *
1012 * @returns Passthru I/O stream, of @a hVfsIos if no digest calc needed.
1013 * @param hVfsIos The stream to wrap. Always consumed.
1014 * @param pszManifestEntry The manifest entry.
1015 * @param fRead Set if read stream, clear if write.
1016 * @throws Nothing.
1017 */
1018RTVFSIOSTREAM Appliance::i_manifestSetupDigestCalculationForGivenIoStream(RTVFSIOSTREAM hVfsIos, const char *pszManifestEntry,
1019 bool fRead /*= true */)
1020{
1021 int vrc;
1022 Assert(!RTManifestPtIosIsInstanceOf(hVfsIos));
1023
1024 if (m->fDigestTypes == 0)
1025 return hVfsIos;
1026
1027 /* Create the manifest if necessary. */
1028 if (m->hOurManifest == NIL_RTMANIFEST)
1029 {
1030 vrc = RTManifestCreate(0 /*fFlags*/, &m->hOurManifest);
1031 AssertRCReturnStmt(vrc, RTVfsIoStrmRelease(hVfsIos), NIL_RTVFSIOSTREAM);
1032 }
1033
1034 /* Setup the stream. */
1035 RTVFSIOSTREAM hVfsIosPt;
1036 vrc = RTManifestEntryAddPassthruIoStream(m->hOurManifest, hVfsIos, pszManifestEntry, m->fDigestTypes, fRead, &hVfsIosPt);
1037
1038 RTVfsIoStrmRelease(hVfsIos); /* always consumed! */
1039 if (RT_SUCCESS(vrc))
1040 return hVfsIosPt;
1041
1042 setErrorVrc(vrc, tr("RTManifestEntryAddPassthruIoStream failed with vrc=%Rrc"), vrc);
1043 return NIL_RTVFSIOSTREAM;
1044}
1045
1046/**
1047 * Returns true if the appliance is in "idle" state. This should always be the
1048 * case unless an import or export is currently in progress. Similar to machine
1049 * states, this permits the Appliance implementation code to let go of the
1050 * Appliance object lock while a time-consuming disk conversion is in progress
1051 * without exposing the appliance to conflicting calls.
1052 *
1053 * This sets an error on "this" (the appliance) and returns false if the appliance
1054 * is busy. The caller should then return E_ACCESSDENIED.
1055 *
1056 * Must be called from under the object lock!
1057 */
1058bool Appliance::i_isApplianceIdle()
1059{
1060 if (m->state == ApplianceImporting)
1061 setError(VBOX_E_INVALID_OBJECT_STATE, tr("The appliance is busy importing files"));
1062 else if (m->state == ApplianceExporting)
1063 setError(VBOX_E_INVALID_OBJECT_STATE, tr("The appliance is busy exporting files"));
1064 else
1065 return true;
1066
1067 return false;
1068}
1069
1070HRESULT Appliance::i_searchUniqueVMName(Utf8Str &aName) const
1071{
1072 ComPtr<IMachine> ptrMachine;
1073 char *tmpName = RTStrDup(aName.c_str());
1074 int i = 1;
1075 while (mVirtualBox->FindMachine(Bstr(tmpName).raw(), ptrMachine.asOutParam()) != VBOX_E_OBJECT_NOT_FOUND)
1076 {
1077 RTStrFree(tmpName);
1078 RTStrAPrintf(&tmpName, "%s %d", aName.c_str(), i);
1079 ++i;
1080 }
1081 aName = tmpName;
1082 RTStrFree(tmpName);
1083
1084 return S_OK;
1085}
1086
1087HRESULT Appliance::i_ensureUniqueImageFilePath(const Utf8Str &aMachineFolder, DeviceType_T aDeviceType, Utf8Str &aName) const
1088{
1089 /*
1090 * Check if the file exists or if a medium with this path is registered already
1091 */
1092 Utf8Str strAbsName;
1093 size_t offDashNum = ~(size_t)0;
1094 size_t cchDashNum = 0;
1095 for (unsigned i = 1;; i++)
1096 {
1097 /* Complete the path (could be relative to machine folder). */
1098 int vrc = RTPathAbsExCxx(strAbsName, aMachineFolder, aName);
1099 AssertRCReturn(vrc, Global::vboxStatusCodeToCOM(vrc)); /** @todo stupid caller ignores this */
1100
1101 /* Check that the file does not exist and that there is no media somehow matching the name. */
1102 if (!RTPathExists(strAbsName.c_str()))
1103 {
1104 ComPtr<IMedium> ptrMedium;
1105 HRESULT hrc = mVirtualBox->OpenMedium(Bstr(strAbsName).raw(), aDeviceType, AccessMode_ReadWrite,
1106 FALSE /* fForceNewUuid */, ptrMedium.asOutParam());
1107 if (hrc == VBOX_E_OBJECT_NOT_FOUND)
1108 return S_OK;
1109 }
1110
1111 /* Insert '_%i' before the suffix and try again. */
1112 if (offDashNum == ~(size_t)0)
1113 {
1114 const char *pszSuffix = RTPathSuffix(aName.c_str());
1115 offDashNum = pszSuffix ? (size_t)(pszSuffix - aName.c_str()) : aName.length();
1116 }
1117 char szTmp[32];
1118 size_t cchTmp = RTStrPrintf(szTmp, sizeof(szTmp), "_%u", i);
1119 aName.replace(offDashNum, cchDashNum, szTmp, cchTmp);
1120 cchDashNum = cchTmp;
1121 }
1122}
1123
1124/**
1125 * Called from Appliance::importImpl() and Appliance::writeImpl() to set up a
1126 * progress object with the proper weights and maximum progress values.
1127 */
1128HRESULT Appliance::i_setUpProgress(ComObjPtr<Progress> &pProgress,
1129 const Utf8Str &strDescription,
1130 SetUpProgressMode mode)
1131{
1132 HRESULT hrc;
1133
1134 /* Create the progress object */
1135 try
1136 {
1137 hrc = pProgress.createObject();
1138 if (FAILED(hrc))
1139 return hrc;
1140 }
1141 catch (std::bad_alloc &)
1142 {
1143 return E_OUTOFMEMORY;
1144 }
1145
1146 // compute the disks weight (this sets ulTotalDisksMB and cDisks in the instance data)
1147 i_disksWeight();
1148
1149 m->ulWeightForManifestOperation = 0;
1150
1151 ULONG cOperations = 1 // one for XML setup
1152 + m->cDisks; // plus one per disk
1153 ULONG ulTotalOperationsWeight;
1154 if (m->ulTotalDisksMB)
1155 {
1156 m->ulWeightForXmlOperation = (ULONG)((double)m->ulTotalDisksMB * 1 / 100); // use 1% of the progress for the XML
1157 ulTotalOperationsWeight = m->ulTotalDisksMB + m->ulWeightForXmlOperation;
1158 }
1159 else
1160 {
1161 // no disks to export:
1162 m->ulWeightForXmlOperation = 1;
1163 ulTotalOperationsWeight = 1;
1164 }
1165
1166 switch (mode)
1167 {
1168 case ImportFile:
1169 {
1170 break;
1171 }
1172 case WriteFile:
1173 {
1174 // assume that creating the manifest will take .1% of the time it takes to export the disks
1175 if (m->fManifest)
1176 {
1177 ++cOperations; // another one for creating the manifest
1178
1179 m->ulWeightForManifestOperation = (ULONG)((double)m->ulTotalDisksMB * .1 / 100); // use .5% of the
1180 // progress for the manifest
1181 ulTotalOperationsWeight += m->ulWeightForManifestOperation;
1182 }
1183 break;
1184 }
1185 case ImportS3:
1186 {
1187 cOperations += 1 + 1; // another one for the manifest file & another one for the import
1188 ulTotalOperationsWeight = m->ulTotalDisksMB;
1189 if (!m->ulTotalDisksMB)
1190 // no disks to export:
1191 ulTotalOperationsWeight = 1;
1192
1193 ULONG ulImportWeight = (ULONG)((double)ulTotalOperationsWeight * 50 / 100); // use 50% for import
1194 ulTotalOperationsWeight += ulImportWeight;
1195
1196 m->ulWeightForXmlOperation = ulImportWeight; /* save for using later */
1197
1198 ULONG ulInitWeight = (ULONG)((double)ulTotalOperationsWeight * 0.1 / 100); // use 0.1% for init
1199 ulTotalOperationsWeight += ulInitWeight;
1200 break;
1201 }
1202 case WriteS3:
1203 {
1204 cOperations += 1 + 1; // another one for the mf & another one for temporary creation
1205
1206 if (m->ulTotalDisksMB)
1207 {
1208 m->ulWeightForXmlOperation = (ULONG)((double)m->ulTotalDisksMB * 1 / 100); // use 1% of the progress
1209 // for OVF file upload
1210 // (we didn't know the
1211 // size at this point)
1212 ulTotalOperationsWeight = m->ulTotalDisksMB + m->ulWeightForXmlOperation;
1213 }
1214 else
1215 {
1216 // no disks to export:
1217 ulTotalOperationsWeight = 1;
1218 m->ulWeightForXmlOperation = 1;
1219 }
1220 ULONG ulOVFCreationWeight = (ULONG)((double)ulTotalOperationsWeight * 50.0 / 100.0); /* Use 50% for the
1221 creation of the OVF
1222 & the disks */
1223 ulTotalOperationsWeight += ulOVFCreationWeight;
1224 break;
1225 }
1226 case ExportCloud:
1227 case ImportCloud:
1228 break;
1229 }
1230 Log(("Setting up progress object: ulTotalMB = %d, cDisks = %d, => cOperations = %d, ulTotalOperationsWeight = %d, m->ulWeightForXmlOperation = %d\n",
1231 m->ulTotalDisksMB, m->cDisks, cOperations, ulTotalOperationsWeight, m->ulWeightForXmlOperation));
1232
1233 return pProgress->init(mVirtualBox, static_cast<IAppliance*>(this),
1234 strDescription,
1235 TRUE /* aCancelable */,
1236 cOperations, // ULONG cOperations,
1237 ulTotalOperationsWeight, // ULONG ulTotalOperationsWeight,
1238 strDescription, // CBSTR bstrFirstOperationDescription,
1239 m->ulWeightForXmlOperation); // ULONG ulFirstOperationWeight,
1240}
1241
1242void Appliance::i_addWarning(const char* aWarning, ...)
1243{
1244 try
1245 {
1246 va_list args;
1247 va_start(args, aWarning);
1248 Utf8Str str(aWarning, args);
1249 va_end(args);
1250 m->llWarnings.push_back(str);
1251 }
1252 catch (...)
1253 {
1254 AssertFailed();
1255 }
1256}
1257
1258/**
1259 * Refreshes the cDisks and ulTotalDisksMB members in the instance data.
1260 * Requires that virtual system descriptions are present.
1261 */
1262void Appliance::i_disksWeight()
1263{
1264 m->ulTotalDisksMB = 0;
1265 m->cDisks = 0;
1266 // weigh the disk images according to their sizes
1267 list< ComObjPtr<VirtualSystemDescription> >::const_iterator it;
1268 for (it = m->virtualSystemDescriptions.begin();
1269 it != m->virtualSystemDescriptions.end();
1270 ++it)
1271 {
1272 ComObjPtr<VirtualSystemDescription> vsdescThis = (*it);
1273 /* One for every medium of the Virtual System */
1274 std::list<VirtualSystemDescriptionEntry*> avsdeHDs = vsdescThis->i_findByType(VirtualSystemDescriptionType_HardDiskImage);
1275 std::list<VirtualSystemDescriptionEntry*>::const_iterator itH;
1276 for (itH = avsdeHDs.begin();
1277 itH != avsdeHDs.end();
1278 ++itH)
1279 {
1280 const VirtualSystemDescriptionEntry *pHD = *itH;
1281 m->ulTotalDisksMB += pHD->ulSizeMB;
1282 ++m->cDisks;
1283 }
1284
1285 avsdeHDs = vsdescThis->i_findByType(VirtualSystemDescriptionType_CDROM);
1286 for (itH = avsdeHDs.begin();
1287 itH != avsdeHDs.end();
1288 ++itH)
1289 {
1290 const VirtualSystemDescriptionEntry *pHD = *itH;
1291 m->ulTotalDisksMB += pHD->ulSizeMB;
1292 ++m->cDisks;
1293 }
1294 }
1295
1296}
1297
1298void Appliance::i_parseBucket(Utf8Str &aPath, Utf8Str &aBucket)
1299{
1300 /* Buckets are S3 specific. So parse the bucket out of the file path */
1301 if (!aPath.startsWith("/"))
1302 throw setError(E_INVALIDARG,
1303 tr("The path '%s' must start with /"), aPath.c_str());
1304 size_t bpos = aPath.find("/", 1);
1305 if (bpos != Utf8Str::npos)
1306 {
1307 aBucket = aPath.substr(1, bpos - 1); /* The bucket without any slashes */
1308 aPath = aPath.substr(bpos); /* The rest of the file path */
1309 }
1310 /* If there is no bucket name provided reject it */
1311 if (aBucket.isEmpty())
1312 throw setError(E_INVALIDARG,
1313 tr("You doesn't provide a bucket name in the URI '%s'"), aPath.c_str());
1314}
1315
1316/**
1317 * Worker for TaskOVF::handler.
1318 *
1319 * The TaskOVF is started in Appliance::readImpl() and Appliance::importImpl()
1320 * and Appliance::writeImpl().
1321 *
1322 * This will in turn call Appliance::readFS() or Appliance::importFS() or
1323 * Appliance::writeFS().
1324 *
1325 * @thread pTask The task.
1326 */
1327/* static */ void Appliance::i_importOrExportThreadTask(TaskOVF *pTask)
1328{
1329 LogFlowFuncEnter();
1330 AssertReturnVoid(pTask);
1331
1332 Appliance *pAppliance = pTask->pAppliance;
1333 LogFlowFunc(("Appliance %p taskType=%d\n", pAppliance, pTask->taskType));
1334
1335 switch (pTask->taskType)
1336 {
1337 case TaskOVF::Read:
1338 pAppliance->m->resetReadData();
1339 if (pTask->locInfo.storageType == VFSType_File)
1340 pTask->hrc = pAppliance->i_readFS(pTask);
1341 else
1342 pTask->hrc = E_NOTIMPL;
1343 break;
1344
1345 case TaskOVF::Import:
1346 /** @todo allow overriding these? */
1347 if (!pAppliance->m->fSignatureValid && pAppliance->m->pbSignedDigest)
1348 pTask->hrc = pAppliance->setError(E_FAIL, tr("The manifest signature for '%s' is not valid"),
1349 pTask->locInfo.strPath.c_str());
1350 else if (!pAppliance->m->fCertificateValid && pAppliance->m->pbSignedDigest)
1351 {
1352 if (pAppliance->m->strCertError.isNotEmpty())
1353 pTask->hrc = pAppliance->setError(E_FAIL, tr("The certificate used to signed '%s' is not valid: %s"),
1354 pTask->locInfo.strPath.c_str(), pAppliance->m->strCertError.c_str());
1355 else
1356 pTask->hrc = pAppliance->setError(E_FAIL, tr("The certificate used to signed '%s' is not valid"),
1357 pTask->locInfo.strPath.c_str());
1358 }
1359 // fusion does not consider this a show stopper (we've filed a warning during read).
1360 //else if (pAppliance->m->fCertificateMissingPath && pAppliance->m->pbSignedDigest)
1361 // pTask->hrc = pAppliance->setError(E_FAIL, tr("The certificate used to signed '%s' is does not have a valid CA path"),
1362 // pTask->locInfo.strPath.c_str());
1363 else
1364 {
1365 if (pTask->locInfo.storageType == VFSType_File)
1366 pTask->hrc = pAppliance->i_importFS(pTask);
1367 else
1368 pTask->hrc = E_NOTIMPL;
1369 }
1370 break;
1371
1372 case TaskOVF::Write:
1373 if (pTask->locInfo.storageType == VFSType_File)
1374 pTask->hrc = pAppliance->i_writeFS(pTask);
1375 else
1376 pTask->hrc = E_NOTIMPL;
1377 break;
1378
1379 default:
1380 AssertFailed();
1381 pTask->hrc = E_FAIL;
1382 break;
1383 }
1384
1385 if (!pTask->pProgress.isNull())
1386 pTask->pProgress->i_notifyComplete(pTask->hrc);
1387
1388 LogFlowFuncLeave();
1389}
1390
1391/* static */ DECLCALLBACK(int) Appliance::TaskOVF::updateProgress(unsigned uPercent, void *pvUser)
1392{
1393 Appliance::TaskOVF* pTask = *(Appliance::TaskOVF**)pvUser;
1394
1395 if ( pTask
1396 && !pTask->pProgress.isNull())
1397 {
1398 BOOL fCanceled;
1399 pTask->pProgress->COMGETTER(Canceled)(&fCanceled);
1400 if (fCanceled)
1401 return -1;
1402 pTask->pProgress->SetCurrentOperationProgress(uPercent);
1403 }
1404 return VINF_SUCCESS;
1405}
1406
1407/**
1408 * Worker for TaskOPC::handler.
1409 * @thread pTask The task.
1410 */
1411/* static */
1412void Appliance::i_exportOPCThreadTask(TaskOPC *pTask)
1413{
1414 LogFlowFuncEnter();
1415 AssertReturnVoid(pTask);
1416
1417 Appliance *pAppliance = pTask->pAppliance;
1418 LogFlowFunc(("Appliance %p taskType=%d\n", pAppliance, pTask->taskType));
1419
1420 switch (pTask->taskType)
1421 {
1422 case TaskOPC::Export:
1423 pTask->hrc = pAppliance->i_writeFSOPC(pTask);
1424 break;
1425
1426 default:
1427 AssertFailed();
1428 pTask->hrc = E_FAIL;
1429 break;
1430 }
1431
1432 if (!pTask->pProgress.isNull())
1433 pTask->pProgress->i_notifyComplete(pTask->hrc);
1434
1435 LogFlowFuncLeave();
1436}
1437
1438/* static */
1439DECLCALLBACK(int) Appliance::TaskOPC::updateProgress(unsigned uPercent, void *pvUser)
1440{
1441 Appliance::TaskOPC* pTask = *(Appliance::TaskOPC**)pvUser;
1442
1443 if ( pTask
1444 && !pTask->pProgress.isNull())
1445 {
1446 BOOL fCanceled;
1447 pTask->pProgress->COMGETTER(Canceled)(&fCanceled);
1448 if (fCanceled)
1449 return -1;
1450 pTask->pProgress->SetCurrentOperationProgress(uPercent);
1451 }
1452 return VINF_SUCCESS;
1453}
1454
1455/**
1456 * Worker for TaskCloud::handler.
1457 * @thread pTask The task.
1458 */
1459/* static */
1460void Appliance::i_importOrExportCloudThreadTask(TaskCloud *pTask)
1461{
1462 LogFlowFuncEnter();
1463 AssertReturnVoid(pTask);
1464
1465 Appliance *pAppliance = pTask->pAppliance;
1466 LogFlowFunc(("Appliance %p taskType=%d\n", pAppliance, pTask->taskType));
1467
1468 switch (pTask->taskType)
1469 {
1470 case TaskCloud::Export:
1471 pAppliance->i_setApplianceState(ApplianceExporting);
1472 pTask->hrc = pAppliance->i_exportCloudImpl(pTask);
1473 break;
1474 case TaskCloud::Import:
1475 pAppliance->i_setApplianceState(ApplianceImporting);
1476 pTask->hrc = pAppliance->i_importCloudImpl(pTask);
1477 break;
1478 case TaskCloud::ReadData:
1479 pAppliance->i_setApplianceState(ApplianceImporting);
1480 pTask->hrc = pAppliance->i_gettingCloudData(pTask);
1481 break;
1482 default:
1483 AssertFailed();
1484 pTask->hrc = E_FAIL;
1485 break;
1486 }
1487
1488 pAppliance->i_setApplianceState(ApplianceIdle);
1489
1490 if (!pTask->pProgress.isNull())
1491 pTask->pProgress->i_notifyComplete(pTask->hrc);
1492
1493 LogFlowFuncLeave();
1494}
1495
1496/* static */
1497DECLCALLBACK(int) Appliance::TaskCloud::updateProgress(unsigned uPercent, void *pvUser)
1498{
1499 Appliance::TaskCloud* pTask = *(Appliance::TaskCloud**)pvUser;
1500
1501 if ( pTask
1502 && !pTask->pProgress.isNull())
1503 {
1504 BOOL fCanceled;
1505 pTask->pProgress->COMGETTER(Canceled)(&fCanceled);
1506 if (fCanceled)
1507 return -1;
1508 pTask->pProgress->SetCurrentOperationProgress(uPercent);
1509 }
1510 return VINF_SUCCESS;
1511}
1512
1513void i_parseURI(Utf8Str strUri, LocationInfo &locInfo)
1514{
1515 /* Check the URI for the protocol */
1516 if (strUri.startsWith("file://", Utf8Str::CaseInsensitive)) /* File based */
1517 {
1518 locInfo.storageType = VFSType_File;
1519 strUri = strUri.substr(sizeof("file://") - 1);
1520 }
1521 else if (strUri.startsWith("SunCloud://", Utf8Str::CaseInsensitive)) /* Sun Cloud service */
1522 {
1523 locInfo.storageType = VFSType_S3;
1524 strUri = strUri.substr(sizeof("SunCloud://") - 1);
1525 }
1526 else if (strUri.startsWith("S3://", Utf8Str::CaseInsensitive)) /* S3 service */
1527 {
1528 locInfo.storageType = VFSType_S3;
1529 strUri = strUri.substr(sizeof("S3://") - 1);
1530 }
1531 else if (strUri.startsWith("OCI://", Utf8Str::CaseInsensitive)) /* OCI service (storage or compute) */
1532 {
1533 locInfo.storageType = VFSType_Cloud;
1534 locInfo.strProvider = "OCI";
1535 strUri = strUri.substr(sizeof("OCI://") - 1);
1536 }
1537 else if (strUri.startsWith("webdav://", Utf8Str::CaseInsensitive)) /* webdav service */
1538 throw E_NOTIMPL;
1539
1540 /* Not necessary on a file based URI */
1541// if (locInfo.storageType != VFSType_File)
1542// {
1543// size_t uppos = strUri.find("@"); /* username:password combo */
1544// if (uppos != Utf8Str::npos)
1545// {
1546// locInfo.strUsername = strUri.substr(0, uppos);
1547// strUri = strUri.substr(uppos + 1);
1548// size_t upos = locInfo.strUsername.find(":");
1549// if (upos != Utf8Str::npos)
1550// {
1551// locInfo.strPassword = locInfo.strUsername.substr(upos + 1);
1552// locInfo.strUsername = locInfo.strUsername.substr(0, upos);
1553// }
1554// }
1555// size_t hpos = strUri.find("/"); /* hostname part */
1556// if (hpos != Utf8Str::npos)
1557// {
1558// locInfo.strHostname = strUri.substr(0, hpos);
1559// strUri = strUri.substr(hpos);
1560// }
1561// }
1562
1563 locInfo.strPath = strUri;
1564}
1565
1566
1567////////////////////////////////////////////////////////////////////////////////
1568//
1569// IVirtualSystemDescription constructor / destructor
1570//
1571////////////////////////////////////////////////////////////////////////////////
1572
1573/**
1574 * COM initializer.
1575 * @return
1576 */
1577HRESULT VirtualSystemDescription::init()
1578{
1579 /* Enclose the state transition NotReady->InInit->Ready */
1580 AutoInitSpan autoInitSpan(this);
1581 AssertReturn(autoInitSpan.isOk(), E_FAIL);
1582
1583 /* Initialize data */
1584 m = new Data();
1585 m->pConfig = NULL;
1586
1587 /* Confirm a successful initialization */
1588 autoInitSpan.setSucceeded();
1589 return S_OK;
1590}
1591
1592/**
1593* COM uninitializer.
1594*/
1595
1596void VirtualSystemDescription::uninit()
1597{
1598 if (m->pConfig)
1599 delete m->pConfig;
1600 delete m;
1601 m = NULL;
1602}
1603
1604
1605////////////////////////////////////////////////////////////////////////////////
1606//
1607// IVirtualSystemDescription public methods
1608//
1609////////////////////////////////////////////////////////////////////////////////
1610
1611/**
1612 * Public method implementation.
1613 */
1614HRESULT VirtualSystemDescription::getCount(ULONG *aCount)
1615{
1616 if (!aCount)
1617 return E_POINTER;
1618
1619 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1620
1621 *aCount = (ULONG)m->maDescriptions.size();
1622 return S_OK;
1623}
1624
1625/**
1626 * Public method implementation.
1627 */
1628HRESULT VirtualSystemDescription::getDescription(std::vector<VirtualSystemDescriptionType_T> &aTypes,
1629 std::vector<com::Utf8Str> &aRefs,
1630 std::vector<com::Utf8Str> &aOVFValues,
1631 std::vector<com::Utf8Str> &aVBoxValues,
1632 std::vector<com::Utf8Str> &aExtraConfigValues)
1633
1634{
1635 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1636 size_t c = m->maDescriptions.size();
1637 aTypes.resize(c);
1638 aRefs.resize(c);
1639 aOVFValues.resize(c);
1640 aVBoxValues.resize(c);
1641 aExtraConfigValues.resize(c);
1642
1643 for (size_t i = 0; i < c; i++)
1644 {
1645 const VirtualSystemDescriptionEntry &vsde = m->maDescriptions[i];
1646 aTypes[i] = vsde.type;
1647 aRefs[i] = vsde.strRef;
1648 aOVFValues[i] = vsde.strOvf;
1649 aVBoxValues[i] = vsde.strVBoxCurrent;
1650 aExtraConfigValues[i] = vsde.strExtraConfigCurrent;
1651 }
1652 return S_OK;
1653}
1654
1655/**
1656 * Public method implementation.
1657 */
1658HRESULT VirtualSystemDescription::getDescriptionByType(VirtualSystemDescriptionType_T aType,
1659 std::vector<VirtualSystemDescriptionType_T> &aTypes,
1660 std::vector<com::Utf8Str> &aRefs,
1661 std::vector<com::Utf8Str> &aOVFValues,
1662 std::vector<com::Utf8Str> &aVBoxValues,
1663 std::vector<com::Utf8Str> &aExtraConfigValues)
1664{
1665 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1666 std::list<VirtualSystemDescriptionEntry*> vsd = i_findByType(aType);
1667
1668 size_t c = vsd.size();
1669 aTypes.resize(c);
1670 aRefs.resize(c);
1671 aOVFValues.resize(c);
1672 aVBoxValues.resize(c);
1673 aExtraConfigValues.resize(c);
1674
1675 size_t i = 0;
1676 for (list<VirtualSystemDescriptionEntry*>::const_iterator it = vsd.begin(); it != vsd.end(); ++it, ++i)
1677 {
1678 const VirtualSystemDescriptionEntry *vsde = (*it);
1679 aTypes[i] = vsde->type;
1680 aRefs[i] = vsde->strRef;
1681 aOVFValues[i] = vsde->strOvf;
1682 aVBoxValues[i] = vsde->strVBoxCurrent;
1683 aExtraConfigValues[i] = vsde->strExtraConfigCurrent;
1684 }
1685
1686 return S_OK;
1687}
1688
1689/**
1690 * Public method implementation.
1691 */
1692HRESULT VirtualSystemDescription::getValuesByType(VirtualSystemDescriptionType_T aType,
1693 VirtualSystemDescriptionValueType_T aWhich,
1694 std::vector<com::Utf8Str> &aValues)
1695{
1696 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1697
1698 std::list<VirtualSystemDescriptionEntry*> vsd = i_findByType (aType);
1699 aValues.resize((ULONG)vsd.size());
1700
1701 list<VirtualSystemDescriptionEntry*>::const_iterator it;
1702 size_t i = 0;
1703 for (it = vsd.begin();
1704 it != vsd.end();
1705 ++it, ++i)
1706 {
1707 const VirtualSystemDescriptionEntry *vsde = (*it);
1708
1709 Bstr bstr;
1710 switch (aWhich)
1711 {
1712 case VirtualSystemDescriptionValueType_Reference: aValues[i] = vsde->strRef; break;
1713 case VirtualSystemDescriptionValueType_Original: aValues[i] = vsde->strOvf; break;
1714 case VirtualSystemDescriptionValueType_Auto: aValues[i] = vsde->strVBoxCurrent; break;
1715 case VirtualSystemDescriptionValueType_ExtraConfig: aValues[i] = vsde->strExtraConfigCurrent; break;
1716#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
1717 case VirtualSystemDescriptionValueType_32BitHack: AssertFailedBreak(); /* (compiler warnings) */
1718#endif
1719 }
1720 }
1721
1722 return S_OK;
1723}
1724
1725/**
1726 * Public method implementation.
1727 */
1728HRESULT VirtualSystemDescription::setFinalValues(const std::vector<BOOL> &aEnabled,
1729 const std::vector<com::Utf8Str> &aVBoxValues,
1730 const std::vector<com::Utf8Str> &aExtraConfigValues)
1731{
1732#ifndef RT_OS_WINDOWS
1733 // NOREF(aEnabledSize);
1734#endif /* RT_OS_WINDOWS */
1735 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1736
1737 if ( (aEnabled.size() != m->maDescriptions.size())
1738 || (aVBoxValues.size() != m->maDescriptions.size())
1739 || (aExtraConfigValues.size() != m->maDescriptions.size())
1740 )
1741 return E_INVALIDARG;
1742
1743 size_t i = 0;
1744 for (vector<VirtualSystemDescriptionEntry>::iterator it = m->maDescriptions.begin();
1745 it != m->maDescriptions.end();
1746 ++it, ++i)
1747 {
1748 VirtualSystemDescriptionEntry& vsde = *it;
1749
1750 if (aEnabled[i])
1751 {
1752 vsde.strVBoxCurrent = aVBoxValues[i];
1753 vsde.strExtraConfigCurrent = aExtraConfigValues[i];
1754 }
1755 else
1756 vsde.type = VirtualSystemDescriptionType_Ignore;
1757 }
1758
1759 return S_OK;
1760}
1761
1762/**
1763 * Public method implementation.
1764 */
1765HRESULT VirtualSystemDescription::addDescription(VirtualSystemDescriptionType_T aType,
1766 const com::Utf8Str &aVBoxValue,
1767 const com::Utf8Str &aExtraConfigValue)
1768
1769{
1770 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1771 i_addEntry(aType, "", aVBoxValue, aVBoxValue, 0, aExtraConfigValue);
1772 return S_OK;
1773}
1774
1775/**
1776 * Internal method; adds a new description item to the member list.
1777 * @param aType Type of description for the new item.
1778 * @param strRef Reference item; only used with storage controllers.
1779 * @param aOvfValue Corresponding original value from OVF.
1780 * @param aVBoxValue Initial configuration value (can be overridden by caller with setFinalValues).
1781 * @param ulSizeMB Weight for IProgress
1782 * @param strExtraConfig Extra configuration; meaning dependent on type.
1783 */
1784void VirtualSystemDescription::i_addEntry(VirtualSystemDescriptionType_T aType,
1785 const Utf8Str &strRef,
1786 const Utf8Str &aOvfValue,
1787 const Utf8Str &aVBoxValue,
1788 uint32_t ulSizeMB,
1789 const Utf8Str &strExtraConfig /*= ""*/)
1790{
1791 VirtualSystemDescriptionEntry vsde;
1792 vsde.ulIndex = (uint32_t)m->maDescriptions.size(); // each entry gets an index so the client side can reference them
1793 vsde.type = aType;
1794 vsde.strRef = strRef;
1795 vsde.strOvf = aOvfValue;
1796 vsde.strVBoxSuggested /* remember original value */
1797 = vsde.strVBoxCurrent /* and set current value which can be overridden by setFinalValues() */
1798 = aVBoxValue;
1799 vsde.strExtraConfigSuggested
1800 = vsde.strExtraConfigCurrent
1801 = strExtraConfig;
1802 vsde.ulSizeMB = ulSizeMB;
1803
1804 vsde.skipIt = false;
1805
1806 m->maDescriptions.push_back(vsde);
1807}
1808
1809/**
1810 * Private method; returns a list of description items containing all the items from the member
1811 * description items of this virtual system that match the given type.
1812 */
1813std::list<VirtualSystemDescriptionEntry*> VirtualSystemDescription::i_findByType(VirtualSystemDescriptionType_T aType)
1814{
1815 std::list<VirtualSystemDescriptionEntry*> vsd;
1816 for (vector<VirtualSystemDescriptionEntry>::iterator it = m->maDescriptions.begin();
1817 it != m->maDescriptions.end();
1818 ++it)
1819 {
1820 if (it->type == aType)
1821 vsd.push_back(&(*it));
1822 }
1823
1824 return vsd;
1825}
1826
1827HRESULT VirtualSystemDescription::removeDescriptionByType(VirtualSystemDescriptionType_T aType)
1828{
1829 std::vector<VirtualSystemDescriptionEntry>::iterator it = m->maDescriptions.begin();
1830 while (it != m->maDescriptions.end())
1831 {
1832 if (it->type == aType)
1833 it = m->maDescriptions.erase(it);
1834 else
1835 ++it;
1836 }
1837
1838 return S_OK;
1839}
1840
1841/* Private method; delete all records from the list
1842 * m->llDescriptions that match the given type.
1843 */
1844void VirtualSystemDescription::i_removeByType(VirtualSystemDescriptionType_T aType)
1845{
1846 std::vector<VirtualSystemDescriptionEntry>::iterator it = m->maDescriptions.begin();
1847 while (it != m->maDescriptions.end())
1848 {
1849 if (it->type == aType)
1850 it = m->maDescriptions.erase(it);
1851 else
1852 ++it;
1853 }
1854}
1855
1856/**
1857 * Private method; looks thru the member hardware items for the IDE, SATA, or SCSI controller with
1858 * the given reference ID. Useful when needing the controller for a particular
1859 * virtual disk.
1860 */
1861const VirtualSystemDescriptionEntry* VirtualSystemDescription::i_findControllerFromID(const Utf8Str &id)
1862{
1863 vector<VirtualSystemDescriptionEntry>::const_iterator it;
1864 for (it = m->maDescriptions.begin();
1865 it != m->maDescriptions.end();
1866 ++it)
1867 {
1868 const VirtualSystemDescriptionEntry &d = *it;
1869 switch (d.type)
1870 {
1871 case VirtualSystemDescriptionType_HardDiskControllerIDE:
1872 case VirtualSystemDescriptionType_HardDiskControllerSATA:
1873 case VirtualSystemDescriptionType_HardDiskControllerSCSI:
1874 case VirtualSystemDescriptionType_HardDiskControllerVirtioSCSI:
1875 case VirtualSystemDescriptionType_HardDiskControllerNVMe:
1876 case VirtualSystemDescriptionType_HardDiskControllerSAS:
1877 if (d.strRef == id)
1878 return &d;
1879 break;
1880 default: break; /* Shut up MSC. */
1881 }
1882 }
1883
1884 return NULL;
1885}
1886
1887/**
1888 * Method called from Appliance::Interpret() if the source OVF for a virtual system
1889 * contains a <vbox:Machine> element. This method then attempts to parse that and
1890 * create a MachineConfigFile instance from it which is stored in this instance data
1891 * and can then be used to create a machine.
1892 *
1893 * This must only be called once per instance.
1894 *
1895 * This rethrows all XML and logic errors from MachineConfigFile.
1896 *
1897 * @param elmMachine <vbox:Machine> element with attributes and subelements from some
1898 * DOM tree.
1899 */
1900void VirtualSystemDescription::i_importVBoxMachineXML(const xml::ElementNode &elmMachine)
1901{
1902 settings::MachineConfigFile *pConfig = NULL;
1903
1904 Assert(m->pConfig == NULL);
1905
1906 try
1907 {
1908 pConfig = new settings::MachineConfigFile(NULL);
1909 pConfig->importMachineXML(elmMachine);
1910
1911 m->pConfig = pConfig;
1912 }
1913 catch (...)
1914 {
1915 if (pConfig)
1916 delete pConfig;
1917 throw;
1918 }
1919}
1920
1921/**
1922 * Returns the machine config created by importVBoxMachineXML() or NULL if there's none.
1923 */
1924const settings::MachineConfigFile* VirtualSystemDescription::i_getMachineConfig() const
1925{
1926 return m->pConfig;
1927}
1928
1929/**
1930 * Private method; walks through the array of VirtualSystemDescriptionEntry entries
1931 * and returns the one matching the given index.
1932 */
1933const VirtualSystemDescriptionEntry* VirtualSystemDescription::i_findByIndex(const uint32_t aIndex)
1934{
1935 vector<VirtualSystemDescriptionEntry>::const_iterator it;
1936 for (it = m->maDescriptions.begin();
1937 it != m->maDescriptions.end();
1938 ++it)
1939 {
1940 const VirtualSystemDescriptionEntry &d = *it;
1941 if (d.ulIndex == aIndex)
1942 return &d;
1943 }
1944
1945 return NULL;
1946}
1947
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