1 | /* $Id: ExtPackUtil.cpp 51092 2014-04-16 17:57:25Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * VirtualBox Main - Extension Pack Utilities and definitions, VBoxC, VBoxSVC, ++.
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2010-2012 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 | /*******************************************************************************
|
---|
20 | * Header Files *
|
---|
21 | *******************************************************************************/
|
---|
22 | #include "../include/ExtPackUtil.h"
|
---|
23 |
|
---|
24 | #include <iprt/ctype.h>
|
---|
25 | #include <iprt/dir.h>
|
---|
26 | #include <iprt/file.h>
|
---|
27 | #include <iprt/manifest.h>
|
---|
28 | #include <iprt/param.h>
|
---|
29 | #include <iprt/path.h>
|
---|
30 | #include <iprt/sha.h>
|
---|
31 | #include <iprt/string.h>
|
---|
32 | #include <iprt/vfs.h>
|
---|
33 | #include <iprt/tar.h>
|
---|
34 | #include <iprt/zip.h>
|
---|
35 | #include <iprt/cpp/xml.h>
|
---|
36 |
|
---|
37 | #include <VBox/log.h>
|
---|
38 |
|
---|
39 |
|
---|
40 | /**
|
---|
41 | * Worker for VBoxExtPackLoadDesc that loads the plug-in descriptors.
|
---|
42 | *
|
---|
43 | * @returns Same as VBoxExtPackLoadDesc.
|
---|
44 | * @param pVBoxExtPackElm
|
---|
45 | * @param pcPlugIns Where to return the number of plug-ins in the
|
---|
46 | * array.
|
---|
47 | * @param paPlugIns Where to return the plug-in descriptor array.
|
---|
48 | * (RTMemFree it even on failure)
|
---|
49 | */
|
---|
50 | static RTCString *
|
---|
51 | vboxExtPackLoadPlugInDescs(const xml::ElementNode *pVBoxExtPackElm,
|
---|
52 | uint32_t *pcPlugIns, PVBOXEXTPACKPLUGINDESC *paPlugIns)
|
---|
53 | {
|
---|
54 | *pcPlugIns = 0;
|
---|
55 | *paPlugIns = NULL;
|
---|
56 |
|
---|
57 | /** @todo plug-ins */
|
---|
58 | NOREF(pVBoxExtPackElm);
|
---|
59 |
|
---|
60 | return NULL;
|
---|
61 | }
|
---|
62 |
|
---|
63 | /**
|
---|
64 | * Clears the extension pack descriptor.
|
---|
65 | *
|
---|
66 | * @param a_pExtPackDesc The descriptor to clear.
|
---|
67 | */
|
---|
68 | static void vboxExtPackClearDesc(PVBOXEXTPACKDESC a_pExtPackDesc)
|
---|
69 | {
|
---|
70 | a_pExtPackDesc->strName.setNull();
|
---|
71 | a_pExtPackDesc->strDescription.setNull();
|
---|
72 | a_pExtPackDesc->strVersion.setNull();
|
---|
73 | a_pExtPackDesc->strEdition.setNull();
|
---|
74 | a_pExtPackDesc->uRevision = 0;
|
---|
75 | a_pExtPackDesc->strMainModule.setNull();
|
---|
76 | a_pExtPackDesc->strVrdeModule.setNull();
|
---|
77 | a_pExtPackDesc->cPlugIns = 0;
|
---|
78 | a_pExtPackDesc->paPlugIns = NULL;
|
---|
79 | a_pExtPackDesc->fShowLicense = false;
|
---|
80 | }
|
---|
81 |
|
---|
82 | /**
|
---|
83 | * Initializes an extension pack descriptor so that it's safe to call free on
|
---|
84 | * it whatever happens later on.
|
---|
85 | *
|
---|
86 | * @param a_pExtPackDesc The descirptor to initialize.
|
---|
87 | */
|
---|
88 | void VBoxExtPackInitDesc(PVBOXEXTPACKDESC a_pExtPackDesc)
|
---|
89 | {
|
---|
90 | vboxExtPackClearDesc(a_pExtPackDesc);
|
---|
91 | }
|
---|
92 |
|
---|
93 |
|
---|
94 | /**
|
---|
95 | * Load the extension pack descriptor from an XML document.
|
---|
96 | *
|
---|
97 | * @returns NULL on success, pointer to an error message on failure (caller
|
---|
98 | * deletes it).
|
---|
99 | * @param a_pDoc Pointer to the XML document.
|
---|
100 | * @param a_pExtPackDesc Where to store the extension pack descriptor.
|
---|
101 | */
|
---|
102 | static RTCString *vboxExtPackLoadDescFromDoc(xml::Document *a_pDoc, PVBOXEXTPACKDESC a_pExtPackDesc)
|
---|
103 | {
|
---|
104 | /*
|
---|
105 | * Get the main element and check its version.
|
---|
106 | */
|
---|
107 | const xml::ElementNode *pVBoxExtPackElm = a_pDoc->getRootElement();
|
---|
108 | if ( !pVBoxExtPackElm
|
---|
109 | || strcmp(pVBoxExtPackElm->getName(), "VirtualBoxExtensionPack") != 0)
|
---|
110 | return new RTCString("No VirtualBoxExtensionPack element");
|
---|
111 |
|
---|
112 | RTCString strFormatVersion;
|
---|
113 | if (!pVBoxExtPackElm->getAttributeValue("version", strFormatVersion))
|
---|
114 | return new RTCString("Missing format version");
|
---|
115 | if (!strFormatVersion.equals("1.0"))
|
---|
116 | return &(new RTCString("Unsupported format version: "))->append(strFormatVersion);
|
---|
117 |
|
---|
118 | /*
|
---|
119 | * Read and validate mandatory bits.
|
---|
120 | */
|
---|
121 | const xml::ElementNode *pNameElm = pVBoxExtPackElm->findChildElement("Name");
|
---|
122 | if (!pNameElm)
|
---|
123 | return new RTCString("The 'Name' element is missing");
|
---|
124 | const char *pszName = pNameElm->getValue();
|
---|
125 | if (!VBoxExtPackIsValidName(pszName))
|
---|
126 | return &(new RTCString("Invalid name: "))->append(pszName);
|
---|
127 |
|
---|
128 | const xml::ElementNode *pDescElm = pVBoxExtPackElm->findChildElement("Description");
|
---|
129 | if (!pDescElm)
|
---|
130 | return new RTCString("The 'Description' element is missing");
|
---|
131 | const char *pszDesc = pDescElm->getValue();
|
---|
132 | if (!pszDesc || *pszDesc == '\0')
|
---|
133 | return new RTCString("The 'Description' element is empty");
|
---|
134 | if (strpbrk(pszDesc, "\n\r\t\v\b") != NULL)
|
---|
135 | return new RTCString("The 'Description' must not contain control characters");
|
---|
136 |
|
---|
137 | const xml::ElementNode *pVersionElm = pVBoxExtPackElm->findChildElement("Version");
|
---|
138 | if (!pVersionElm)
|
---|
139 | return new RTCString("The 'Version' element is missing");
|
---|
140 | const char *pszVersion = pVersionElm->getValue();
|
---|
141 | if (!pszVersion || *pszVersion == '\0')
|
---|
142 | return new RTCString("The 'Version' element is empty");
|
---|
143 | if (!VBoxExtPackIsValidVersionString(pszVersion))
|
---|
144 | return &(new RTCString("Invalid version string: "))->append(pszVersion);
|
---|
145 |
|
---|
146 | uint32_t uRevision;
|
---|
147 | if (!pVersionElm->getAttributeValue("revision", uRevision))
|
---|
148 | uRevision = 0;
|
---|
149 |
|
---|
150 | const char *pszEdition;
|
---|
151 | if (!pVersionElm->getAttributeValue("edition", pszEdition))
|
---|
152 | pszEdition = "";
|
---|
153 | if (!VBoxExtPackIsValidEditionString(pszEdition))
|
---|
154 | return &(new RTCString("Invalid edition string: "))->append(pszEdition);
|
---|
155 |
|
---|
156 | const xml::ElementNode *pMainModuleElm = pVBoxExtPackElm->findChildElement("MainModule");
|
---|
157 | if (!pMainModuleElm)
|
---|
158 | return new RTCString("The 'MainModule' element is missing");
|
---|
159 | const char *pszMainModule = pMainModuleElm->getValue();
|
---|
160 | if (!pszMainModule || *pszMainModule == '\0')
|
---|
161 | return new RTCString("The 'MainModule' element is empty");
|
---|
162 | if (!VBoxExtPackIsValidModuleString(pszMainModule))
|
---|
163 | return &(new RTCString("Invalid main module string: "))->append(pszMainModule);
|
---|
164 |
|
---|
165 | /*
|
---|
166 | * The VRDE module, optional.
|
---|
167 | * Accept both none and empty as tokens of no VRDE module.
|
---|
168 | */
|
---|
169 | const char *pszVrdeModule = NULL;
|
---|
170 | const xml::ElementNode *pVrdeModuleElm = pVBoxExtPackElm->findChildElement("VRDEModule");
|
---|
171 | if (pVrdeModuleElm)
|
---|
172 | {
|
---|
173 | pszVrdeModule = pVrdeModuleElm->getValue();
|
---|
174 | if (!pszVrdeModule || *pszVrdeModule == '\0')
|
---|
175 | pszVrdeModule = NULL;
|
---|
176 | else if (!VBoxExtPackIsValidModuleString(pszVrdeModule))
|
---|
177 | return &(new RTCString("Invalid VRDE module string: "))->append(pszVrdeModule);
|
---|
178 | }
|
---|
179 |
|
---|
180 | /*
|
---|
181 | * Whether to show the license, optional. (presense is enough here)
|
---|
182 | */
|
---|
183 | const xml::ElementNode *pShowLicenseElm = pVBoxExtPackElm->findChildElement("ShowLicense");
|
---|
184 | bool fShowLicense = pShowLicenseElm != NULL;
|
---|
185 |
|
---|
186 | /*
|
---|
187 | * Parse plug-in descriptions (last because of the manual memory management).
|
---|
188 | */
|
---|
189 | uint32_t cPlugIns = 0;
|
---|
190 | PVBOXEXTPACKPLUGINDESC paPlugIns = NULL;
|
---|
191 | RTCString *pstrRet = vboxExtPackLoadPlugInDescs(pVBoxExtPackElm, &cPlugIns, &paPlugIns);
|
---|
192 | if (pstrRet)
|
---|
193 | {
|
---|
194 | RTMemFree(paPlugIns);
|
---|
195 | return pstrRet;
|
---|
196 | }
|
---|
197 |
|
---|
198 | /*
|
---|
199 | * Everything seems fine, fill in the return values and return successfully.
|
---|
200 | */
|
---|
201 | a_pExtPackDesc->strName = pszName;
|
---|
202 | a_pExtPackDesc->strDescription = pszDesc;
|
---|
203 | a_pExtPackDesc->strVersion = pszVersion;
|
---|
204 | a_pExtPackDesc->strEdition = pszEdition;
|
---|
205 | a_pExtPackDesc->uRevision = uRevision;
|
---|
206 | a_pExtPackDesc->strMainModule = pszMainModule;
|
---|
207 | a_pExtPackDesc->strVrdeModule = pszVrdeModule;
|
---|
208 | a_pExtPackDesc->cPlugIns = cPlugIns;
|
---|
209 | a_pExtPackDesc->paPlugIns = paPlugIns;
|
---|
210 | a_pExtPackDesc->fShowLicense = fShowLicense;
|
---|
211 |
|
---|
212 | return NULL;
|
---|
213 | }
|
---|
214 |
|
---|
215 | /**
|
---|
216 | * Reads the extension pack descriptor.
|
---|
217 | *
|
---|
218 | * @returns NULL on success, pointer to an error message on failure (caller
|
---|
219 | * deletes it).
|
---|
220 | * @param a_pszDir The directory containing the description file.
|
---|
221 | * @param a_pExtPackDesc Where to store the extension pack descriptor.
|
---|
222 | * @param a_pObjInfo Where to store the object info for the file (unix
|
---|
223 | * attribs). Optional.
|
---|
224 | */
|
---|
225 | RTCString *VBoxExtPackLoadDesc(const char *a_pszDir, PVBOXEXTPACKDESC a_pExtPackDesc, PRTFSOBJINFO a_pObjInfo)
|
---|
226 | {
|
---|
227 | vboxExtPackClearDesc(a_pExtPackDesc);
|
---|
228 |
|
---|
229 | /*
|
---|
230 | * Validate, open and parse the XML file.
|
---|
231 | */
|
---|
232 | char szFilePath[RTPATH_MAX];
|
---|
233 | int vrc = RTPathJoin(szFilePath, sizeof(szFilePath), a_pszDir, VBOX_EXTPACK_DESCRIPTION_NAME);
|
---|
234 | if (RT_FAILURE(vrc))
|
---|
235 | return new RTCString("RTPathJoin failed with %Rrc", vrc);
|
---|
236 |
|
---|
237 | RTFSOBJINFO ObjInfo;
|
---|
238 | vrc = RTPathQueryInfoEx(szFilePath, &ObjInfo, RTFSOBJATTRADD_UNIX, RTPATH_F_ON_LINK);
|
---|
239 | if (RT_FAILURE(vrc))
|
---|
240 | return &(new RTCString())->printf("RTPathQueryInfoEx failed with %Rrc", vrc);
|
---|
241 | if (a_pObjInfo)
|
---|
242 | *a_pObjInfo = ObjInfo;
|
---|
243 | if (!RTFS_IS_FILE(ObjInfo.Attr.fMode))
|
---|
244 | {
|
---|
245 | if (RTFS_IS_SYMLINK(ObjInfo.Attr.fMode))
|
---|
246 | return new RTCString("The XML file is symlinked, that is not allowed");
|
---|
247 | return &(new RTCString)->printf("The XML file is not a file (fMode=%#x)", ObjInfo.Attr.fMode);
|
---|
248 | }
|
---|
249 |
|
---|
250 | xml::Document Doc;
|
---|
251 | {
|
---|
252 | xml::XmlFileParser Parser;
|
---|
253 | try
|
---|
254 | {
|
---|
255 | Parser.read(szFilePath, Doc);
|
---|
256 | }
|
---|
257 | catch (xml::XmlError Err)
|
---|
258 | {
|
---|
259 | return new RTCString(Err.what());
|
---|
260 | }
|
---|
261 | }
|
---|
262 |
|
---|
263 | /*
|
---|
264 | * Hand the xml doc over to the common code.
|
---|
265 | */
|
---|
266 | return vboxExtPackLoadDescFromDoc(&Doc, a_pExtPackDesc);
|
---|
267 | }
|
---|
268 |
|
---|
269 | /**
|
---|
270 | * Reads the extension pack descriptor.
|
---|
271 | *
|
---|
272 | * @returns NULL on success, pointer to an error message on failure (caller
|
---|
273 | * deletes it).
|
---|
274 | * @param a_pszDir The directory containing the description file.
|
---|
275 | * @param a_pExtPackDesc Where to store the extension pack descriptor.
|
---|
276 | * @param a_pObjInfo Where to store the object info for the file (unix
|
---|
277 | * attribs). Optional.
|
---|
278 | */
|
---|
279 | RTCString *VBoxExtPackLoadDescFromVfsFile(RTVFSFILE hVfsFile, PVBOXEXTPACKDESC a_pExtPackDesc, PRTFSOBJINFO a_pObjInfo)
|
---|
280 | {
|
---|
281 | vboxExtPackClearDesc(a_pExtPackDesc);
|
---|
282 |
|
---|
283 | /*
|
---|
284 | * Query the object info.
|
---|
285 | */
|
---|
286 | RTFSOBJINFO ObjInfo;
|
---|
287 | int rc = RTVfsFileQueryInfo(hVfsFile, &ObjInfo, RTFSOBJATTRADD_UNIX);
|
---|
288 | if (RT_FAILURE(rc))
|
---|
289 | return &(new RTCString)->printf("RTVfsFileQueryInfo failed: %Rrc", rc);
|
---|
290 | if (a_pObjInfo)
|
---|
291 | *a_pObjInfo = ObjInfo;
|
---|
292 |
|
---|
293 | /*
|
---|
294 | * The simple approach, read the whole thing into memory and pass this to
|
---|
295 | * the XML parser.
|
---|
296 | */
|
---|
297 |
|
---|
298 | /* Check the file size. */
|
---|
299 | if (ObjInfo.cbObject > _1M || ObjInfo.cbObject < 0)
|
---|
300 | return &(new RTCString)->printf("The XML file is too large (%'RU64 bytes)", ObjInfo.cbObject);
|
---|
301 | size_t const cbFile = (size_t)ObjInfo.cbObject;
|
---|
302 |
|
---|
303 | /* Rewind to the start of the file. */
|
---|
304 | rc = RTVfsFileSeek(hVfsFile, 0, RTFILE_SEEK_BEGIN, NULL);
|
---|
305 | if (RT_FAILURE(rc))
|
---|
306 | return &(new RTCString)->printf("RTVfsFileSeek(,0,BEGIN) failed: %Rrc", rc);
|
---|
307 |
|
---|
308 | /* Allocate memory and read the file content into it. */
|
---|
309 | void *pvFile = RTMemTmpAlloc(cbFile);
|
---|
310 | if (!pvFile)
|
---|
311 | return &(new RTCString)->printf("RTMemTmpAlloc(%zu) failed", cbFile);
|
---|
312 |
|
---|
313 | RTCString *pstrErr = NULL;
|
---|
314 | rc = RTVfsFileRead(hVfsFile, pvFile, cbFile, NULL);
|
---|
315 | if (RT_FAILURE(rc))
|
---|
316 | pstrErr = &(new RTCString)->printf("RTVfsFileRead failed: %Rrc", rc);
|
---|
317 |
|
---|
318 | /*
|
---|
319 | * Parse the file.
|
---|
320 | */
|
---|
321 | xml::Document Doc;
|
---|
322 | if (RT_SUCCESS(rc))
|
---|
323 | {
|
---|
324 | xml::XmlMemParser Parser;
|
---|
325 | RTCString strFileName = VBOX_EXTPACK_DESCRIPTION_NAME;
|
---|
326 | try
|
---|
327 | {
|
---|
328 | Parser.read(pvFile, cbFile, strFileName, Doc);
|
---|
329 | }
|
---|
330 | catch (xml::XmlError Err)
|
---|
331 | {
|
---|
332 | pstrErr = new RTCString(Err.what());
|
---|
333 | rc = VERR_PARSE_ERROR;
|
---|
334 | }
|
---|
335 | }
|
---|
336 | RTMemTmpFree(pvFile);
|
---|
337 |
|
---|
338 | /*
|
---|
339 | * Hand the xml doc over to the common code.
|
---|
340 | */
|
---|
341 | if (RT_SUCCESS(rc))
|
---|
342 | pstrErr = vboxExtPackLoadDescFromDoc(&Doc, a_pExtPackDesc);
|
---|
343 |
|
---|
344 | return pstrErr;
|
---|
345 | }
|
---|
346 |
|
---|
347 | /**
|
---|
348 | * Frees all resources associated with a extension pack descriptor.
|
---|
349 | *
|
---|
350 | * @param a_pExtPackDesc The extension pack descriptor which members
|
---|
351 | * should be freed.
|
---|
352 | */
|
---|
353 | void VBoxExtPackFreeDesc(PVBOXEXTPACKDESC a_pExtPackDesc)
|
---|
354 | {
|
---|
355 | if (!a_pExtPackDesc)
|
---|
356 | return;
|
---|
357 |
|
---|
358 | a_pExtPackDesc->strName.setNull();
|
---|
359 | a_pExtPackDesc->strDescription.setNull();
|
---|
360 | a_pExtPackDesc->strVersion.setNull();
|
---|
361 | a_pExtPackDesc->strEdition.setNull();
|
---|
362 | a_pExtPackDesc->uRevision = 0;
|
---|
363 | a_pExtPackDesc->strMainModule.setNull();
|
---|
364 | a_pExtPackDesc->strVrdeModule.setNull();
|
---|
365 | a_pExtPackDesc->cPlugIns = 0;
|
---|
366 | RTMemFree(a_pExtPackDesc->paPlugIns);
|
---|
367 | a_pExtPackDesc->paPlugIns = NULL;
|
---|
368 | a_pExtPackDesc->fShowLicense = false;
|
---|
369 | }
|
---|
370 |
|
---|
371 | /**
|
---|
372 | * Extract the extension pack name from the tarball path.
|
---|
373 | *
|
---|
374 | * @returns String containing the name on success, the caller must delete it.
|
---|
375 | * NULL if no valid name was found or if we ran out of memory.
|
---|
376 | * @param pszTarball The path to the tarball.
|
---|
377 | */
|
---|
378 | RTCString *VBoxExtPackExtractNameFromTarballPath(const char *pszTarball)
|
---|
379 | {
|
---|
380 | /*
|
---|
381 | * Skip ahead to the filename part and count the number of characters
|
---|
382 | * that matches the criteria for a mangled extension pack name.
|
---|
383 | */
|
---|
384 | const char *pszSrc = RTPathFilename(pszTarball);
|
---|
385 | if (!pszSrc)
|
---|
386 | return NULL;
|
---|
387 |
|
---|
388 | size_t off = 0;
|
---|
389 | while (RT_C_IS_ALNUM(pszSrc[off]) || pszSrc[off] == '_')
|
---|
390 | off++;
|
---|
391 |
|
---|
392 | /*
|
---|
393 | * Check min and max name limits.
|
---|
394 | */
|
---|
395 | if ( off > VBOX_EXTPACK_NAME_MAX_LEN
|
---|
396 | || off < VBOX_EXTPACK_NAME_MIN_LEN)
|
---|
397 | return NULL;
|
---|
398 |
|
---|
399 | /*
|
---|
400 | * Return the unmangled name.
|
---|
401 | */
|
---|
402 | return VBoxExtPackUnmangleName(pszSrc, off);
|
---|
403 | }
|
---|
404 |
|
---|
405 | /**
|
---|
406 | * Validates the extension pack name.
|
---|
407 | *
|
---|
408 | * @returns true if valid, false if not.
|
---|
409 | * @param pszName The name to validate.
|
---|
410 | * @sa VBoxExtPackExtractNameFromTarballPath
|
---|
411 | */
|
---|
412 | bool VBoxExtPackIsValidName(const char *pszName)
|
---|
413 | {
|
---|
414 | if (!pszName)
|
---|
415 | return false;
|
---|
416 |
|
---|
417 | /*
|
---|
418 | * Check the characters making up the name, only english alphabet
|
---|
419 | * characters, decimal digits and spaces are allowed.
|
---|
420 | */
|
---|
421 | size_t off = 0;
|
---|
422 | while (pszName[off])
|
---|
423 | {
|
---|
424 | if (!RT_C_IS_ALNUM(pszName[off]) && pszName[off] != ' ')
|
---|
425 | return false;
|
---|
426 | off++;
|
---|
427 | }
|
---|
428 |
|
---|
429 | /*
|
---|
430 | * Check min and max name limits.
|
---|
431 | */
|
---|
432 | if ( off > VBOX_EXTPACK_NAME_MAX_LEN
|
---|
433 | || off < VBOX_EXTPACK_NAME_MIN_LEN)
|
---|
434 | return false;
|
---|
435 |
|
---|
436 | return true;
|
---|
437 | }
|
---|
438 |
|
---|
439 | /**
|
---|
440 | * Checks if an alledged manged extension pack name.
|
---|
441 | *
|
---|
442 | * @returns true if valid, false if not.
|
---|
443 | * @param pszMangledName The mangled name to validate.
|
---|
444 | * @param cchMax The max number of chars to test.
|
---|
445 | * @sa VBoxExtPackMangleName
|
---|
446 | */
|
---|
447 | bool VBoxExtPackIsValidMangledName(const char *pszMangledName, size_t cchMax /*= RTSTR_MAX*/)
|
---|
448 | {
|
---|
449 | if (!pszMangledName)
|
---|
450 | return false;
|
---|
451 |
|
---|
452 | /*
|
---|
453 | * Check the characters making up the name, only english alphabet
|
---|
454 | * characters, decimal digits and underscores (=space) are allowed.
|
---|
455 | */
|
---|
456 | size_t off = 0;
|
---|
457 | while (off < cchMax && pszMangledName[off])
|
---|
458 | {
|
---|
459 | if (!RT_C_IS_ALNUM(pszMangledName[off]) && pszMangledName[off] != '_')
|
---|
460 | return false;
|
---|
461 | off++;
|
---|
462 | }
|
---|
463 |
|
---|
464 | /*
|
---|
465 | * Check min and max name limits.
|
---|
466 | */
|
---|
467 | if ( off > VBOX_EXTPACK_NAME_MAX_LEN
|
---|
468 | || off < VBOX_EXTPACK_NAME_MIN_LEN)
|
---|
469 | return false;
|
---|
470 |
|
---|
471 | return true;
|
---|
472 | }
|
---|
473 |
|
---|
474 | /**
|
---|
475 | * Mangle an extension pack name so it can be used by a directory or file name.
|
---|
476 | *
|
---|
477 | * @returns String containing the mangled name on success, the caller must
|
---|
478 | * delete it. NULL on failure.
|
---|
479 | * @param pszName The unmangled name.
|
---|
480 | * @sa VBoxExtPackUnmangleName, VBoxExtPackIsValidMangledName
|
---|
481 | */
|
---|
482 | RTCString *VBoxExtPackMangleName(const char *pszName)
|
---|
483 | {
|
---|
484 | AssertReturn(VBoxExtPackIsValidName(pszName), NULL);
|
---|
485 |
|
---|
486 | char szTmp[VBOX_EXTPACK_NAME_MAX_LEN + 1];
|
---|
487 | size_t off = 0;
|
---|
488 | char ch;
|
---|
489 | while ((ch = pszName[off]) != '\0')
|
---|
490 | {
|
---|
491 | if (ch == ' ')
|
---|
492 | ch = '_';
|
---|
493 | szTmp[off++] = ch;
|
---|
494 | }
|
---|
495 | szTmp[off] = '\0';
|
---|
496 | Assert(VBoxExtPackIsValidMangledName(szTmp));
|
---|
497 |
|
---|
498 | return new RTCString(szTmp, off);
|
---|
499 | }
|
---|
500 |
|
---|
501 | /**
|
---|
502 | * Unmangle an extension pack name (reverses VBoxExtPackMangleName).
|
---|
503 | *
|
---|
504 | * @returns String containing the mangled name on success, the caller must
|
---|
505 | * delete it. NULL on failure.
|
---|
506 | * @param pszMangledName The mangled name.
|
---|
507 | * @param cchMax The max name length. RTSTR_MAX is fine.
|
---|
508 | * @sa VBoxExtPackMangleName, VBoxExtPackIsValidMangledName
|
---|
509 | */
|
---|
510 | RTCString *VBoxExtPackUnmangleName(const char *pszMangledName, size_t cchMax)
|
---|
511 | {
|
---|
512 | AssertReturn(VBoxExtPackIsValidMangledName(pszMangledName, cchMax), NULL);
|
---|
513 |
|
---|
514 | char szTmp[VBOX_EXTPACK_NAME_MAX_LEN + 1];
|
---|
515 | size_t off = 0;
|
---|
516 | char ch;
|
---|
517 | while ( off < cchMax
|
---|
518 | && (ch = pszMangledName[off]) != '\0')
|
---|
519 | {
|
---|
520 | if (ch == '_')
|
---|
521 | ch = ' ';
|
---|
522 | else
|
---|
523 | AssertReturn(RT_C_IS_ALNUM(ch) || ch == ' ', NULL);
|
---|
524 | szTmp[off++] = ch;
|
---|
525 | }
|
---|
526 | szTmp[off] = '\0';
|
---|
527 | AssertReturn(VBoxExtPackIsValidName(szTmp), NULL);
|
---|
528 |
|
---|
529 | return new RTCString(szTmp, off);
|
---|
530 | }
|
---|
531 |
|
---|
532 | /**
|
---|
533 | * Constructs the extension pack directory path.
|
---|
534 | *
|
---|
535 | * A combination of RTPathJoin and VBoxExtPackMangleName.
|
---|
536 | *
|
---|
537 | * @returns IPRT status code like RTPathJoin.
|
---|
538 | * @param pszExtPackDir Where to return the directory path.
|
---|
539 | * @param cbExtPackDir The size of the return buffer.
|
---|
540 | * @param pszParentDir The parent directory (".../Extensions").
|
---|
541 | * @param pszName The extension pack name, unmangled.
|
---|
542 | */
|
---|
543 | int VBoxExtPackCalcDir(char *pszExtPackDir, size_t cbExtPackDir, const char *pszParentDir, const char *pszName)
|
---|
544 | {
|
---|
545 | AssertReturn(VBoxExtPackIsValidName(pszName), VERR_INTERNAL_ERROR_5);
|
---|
546 |
|
---|
547 | RTCString *pstrMangledName = VBoxExtPackMangleName(pszName);
|
---|
548 | if (!pstrMangledName)
|
---|
549 | return VERR_INTERNAL_ERROR_4;
|
---|
550 |
|
---|
551 | int vrc = RTPathJoin(pszExtPackDir, cbExtPackDir, pszParentDir, pstrMangledName->c_str());
|
---|
552 | delete pstrMangledName;
|
---|
553 |
|
---|
554 | return vrc;
|
---|
555 | }
|
---|
556 |
|
---|
557 |
|
---|
558 | /**
|
---|
559 | * Validates the extension pack version string.
|
---|
560 | *
|
---|
561 | * @returns true if valid, false if not.
|
---|
562 | * @param pszVersion The version string to validate.
|
---|
563 | */
|
---|
564 | bool VBoxExtPackIsValidVersionString(const char *pszVersion)
|
---|
565 | {
|
---|
566 | if (!pszVersion || *pszVersion == '\0')
|
---|
567 | return false;
|
---|
568 |
|
---|
569 | /* 1.x.y.z... */
|
---|
570 | for (;;)
|
---|
571 | {
|
---|
572 | if (!RT_C_IS_DIGIT(*pszVersion))
|
---|
573 | return false;
|
---|
574 | do
|
---|
575 | pszVersion++;
|
---|
576 | while (RT_C_IS_DIGIT(*pszVersion));
|
---|
577 | if (*pszVersion != '.')
|
---|
578 | break;
|
---|
579 | pszVersion++;
|
---|
580 | }
|
---|
581 |
|
---|
582 | /* upper case string + numbers indicating the build type */
|
---|
583 | if (*pszVersion == '-' || *pszVersion == '_')
|
---|
584 | {
|
---|
585 | /** @todo Should probably restrict this to known build types (alpha,
|
---|
586 | * beta, rc, ++). */
|
---|
587 | do
|
---|
588 | pszVersion++;
|
---|
589 | while ( RT_C_IS_DIGIT(*pszVersion)
|
---|
590 | || RT_C_IS_UPPER(*pszVersion)
|
---|
591 | || *pszVersion == '-'
|
---|
592 | || *pszVersion == '_');
|
---|
593 | }
|
---|
594 |
|
---|
595 | return *pszVersion == '\0';
|
---|
596 | }
|
---|
597 |
|
---|
598 | /**
|
---|
599 | * Validates the extension pack edition string.
|
---|
600 | *
|
---|
601 | * @returns true if valid, false if not.
|
---|
602 | * @param pszEdition The edition string to validate.
|
---|
603 | */
|
---|
604 | bool VBoxExtPackIsValidEditionString(const char *pszEdition)
|
---|
605 | {
|
---|
606 | if (*pszEdition)
|
---|
607 | {
|
---|
608 | if (!RT_C_IS_UPPER(*pszEdition))
|
---|
609 | return false;
|
---|
610 |
|
---|
611 | do
|
---|
612 | pszEdition++;
|
---|
613 | while ( RT_C_IS_UPPER(*pszEdition)
|
---|
614 | || RT_C_IS_DIGIT(*pszEdition)
|
---|
615 | || *pszEdition == '-'
|
---|
616 | || *pszEdition == '_');
|
---|
617 | }
|
---|
618 | return *pszEdition == '\0';
|
---|
619 | }
|
---|
620 |
|
---|
621 | /**
|
---|
622 | * Validates an extension pack module string.
|
---|
623 | *
|
---|
624 | * @returns true if valid, false if not.
|
---|
625 | * @param pszModule The module string to validate.
|
---|
626 | */
|
---|
627 | bool VBoxExtPackIsValidModuleString(const char *pszModule)
|
---|
628 | {
|
---|
629 | if (!pszModule || *pszModule == '\0')
|
---|
630 | return false;
|
---|
631 |
|
---|
632 | /* Restricted charset, no extensions (dots). */
|
---|
633 | while ( RT_C_IS_ALNUM(*pszModule)
|
---|
634 | || *pszModule == '-'
|
---|
635 | || *pszModule == '_')
|
---|
636 | pszModule++;
|
---|
637 |
|
---|
638 | return *pszModule == '\0';
|
---|
639 | }
|
---|
640 |
|
---|
641 | /**
|
---|
642 | * RTStrPrintfv wrapper.
|
---|
643 | *
|
---|
644 | * @returns @a rc
|
---|
645 | * @param rc The status code to return.
|
---|
646 | * @param pszError The error buffer.
|
---|
647 | * @param cbError The size of the buffer.
|
---|
648 | * @param pszFormat The error message format string.
|
---|
649 | * @param ... Format arguments.
|
---|
650 | */
|
---|
651 | static int vboxExtPackReturnError(int rc, char *pszError, size_t cbError, const char *pszFormat, ...)
|
---|
652 | {
|
---|
653 | va_list va;
|
---|
654 | va_start(va, pszFormat);
|
---|
655 | RTStrPrintfV(pszError, cbError, pszFormat, va);
|
---|
656 | va_end(va);
|
---|
657 | return rc;
|
---|
658 | }
|
---|
659 |
|
---|
660 | /**
|
---|
661 | * RTStrPrintfv wrapper.
|
---|
662 | *
|
---|
663 | * @param pszError The error buffer.
|
---|
664 | * @param cbError The size of the buffer.
|
---|
665 | * @param pszFormat The error message format string.
|
---|
666 | * @param ... Format arguments.
|
---|
667 | */
|
---|
668 | static void vboxExtPackSetError(char *pszError, size_t cbError, const char *pszFormat, ...)
|
---|
669 | {
|
---|
670 | va_list va;
|
---|
671 | va_start(va, pszFormat);
|
---|
672 | RTStrPrintfV(pszError, cbError, pszFormat, va);
|
---|
673 | va_end(va);
|
---|
674 | }
|
---|
675 |
|
---|
676 | /**
|
---|
677 | * Verifies the manifest and its signature.
|
---|
678 | *
|
---|
679 | * @returns VBox status code, failures with message.
|
---|
680 | * @param hManifestFile The xml from the extension pack.
|
---|
681 | * @param pszExtPackName The expected extension pack name. This can be
|
---|
682 | * NULL, in which we don't have any expectations.
|
---|
683 | * @param pszError Where to store an error message on failure.
|
---|
684 | * @param cbError The size of the buffer @a pszError points to.
|
---|
685 | */
|
---|
686 | static int vboxExtPackVerifyXml(RTVFSFILE hXmlFile, const char *pszExtPackName, char *pszError, size_t cbError)
|
---|
687 | {
|
---|
688 | /*
|
---|
689 | * Load the XML.
|
---|
690 | */
|
---|
691 | VBOXEXTPACKDESC ExtPackDesc;
|
---|
692 | RTCString *pstrErr = VBoxExtPackLoadDescFromVfsFile(hXmlFile, &ExtPackDesc, NULL);
|
---|
693 | if (pstrErr)
|
---|
694 | {
|
---|
695 | RTStrCopy(pszError, cbError, pstrErr->c_str());
|
---|
696 | delete pstrErr;
|
---|
697 | return VERR_PARSE_ERROR;
|
---|
698 | }
|
---|
699 |
|
---|
700 | /*
|
---|
701 | * Check the name.
|
---|
702 | */
|
---|
703 | /** @todo drop this restriction after the old install interface is
|
---|
704 | * dropped. */
|
---|
705 | int rc = VINF_SUCCESS;
|
---|
706 | if ( pszExtPackName
|
---|
707 | && !ExtPackDesc.strName.equalsIgnoreCase(pszExtPackName))
|
---|
708 | rc = vboxExtPackReturnError(VERR_NOT_EQUAL, pszError, cbError,
|
---|
709 | "The name of the downloaded file and the name stored inside the extension pack does not match"
|
---|
710 | " (xml='%s' file='%s')", ExtPackDesc.strName.c_str(), pszExtPackName);
|
---|
711 | return rc;
|
---|
712 | }
|
---|
713 |
|
---|
714 | /**
|
---|
715 | * Verifies the manifest and its signature.
|
---|
716 | *
|
---|
717 | * @returns VBox status code, failures with message.
|
---|
718 | * @param hOurManifest The manifest we compiled.
|
---|
719 | * @param hManifestFile The manifest file in the extension pack.
|
---|
720 | * @param hSignatureFile The manifest signature file.
|
---|
721 | * @param pszError Where to store an error message on failure.
|
---|
722 | * @param cbError The size of the buffer @a pszError points to.
|
---|
723 | */
|
---|
724 | static int vboxExtPackVerifyManifestAndSignature(RTMANIFEST hOurManifest, RTVFSFILE hManifestFile, RTVFSFILE hSignatureFile,
|
---|
725 | char *pszError, size_t cbError)
|
---|
726 | {
|
---|
727 | /*
|
---|
728 | * Read the manifest from the extension pack.
|
---|
729 | */
|
---|
730 | int rc = RTVfsFileSeek(hManifestFile, 0, RTFILE_SEEK_BEGIN, NULL);
|
---|
731 | if (RT_FAILURE(rc))
|
---|
732 | return vboxExtPackReturnError(rc, pszError, cbError, "RTVfsFileSeek failed: %Rrc", rc);
|
---|
733 |
|
---|
734 | RTMANIFEST hTheirManifest;
|
---|
735 | rc = RTManifestCreate(0 /*fFlags*/, &hTheirManifest);
|
---|
736 | if (RT_FAILURE(rc))
|
---|
737 | return vboxExtPackReturnError(rc, pszError, cbError, "RTManifestCreate failed: %Rrc", rc);
|
---|
738 |
|
---|
739 | RTVFSIOSTREAM hVfsIos = RTVfsFileToIoStream(hManifestFile);
|
---|
740 | rc = RTManifestReadStandard(hTheirManifest, hVfsIos);
|
---|
741 | RTVfsIoStrmRelease(hVfsIos);
|
---|
742 | if (RT_SUCCESS(rc))
|
---|
743 | {
|
---|
744 | /*
|
---|
745 | * Compare the manifests.
|
---|
746 | */
|
---|
747 | static const char *s_apszIgnoreEntries[] =
|
---|
748 | {
|
---|
749 | VBOX_EXTPACK_MANIFEST_NAME,
|
---|
750 | VBOX_EXTPACK_SIGNATURE_NAME,
|
---|
751 | "./" VBOX_EXTPACK_MANIFEST_NAME,
|
---|
752 | "./" VBOX_EXTPACK_SIGNATURE_NAME,
|
---|
753 | NULL
|
---|
754 | };
|
---|
755 | char szError[RTPATH_MAX];
|
---|
756 | rc = RTManifestEqualsEx(hOurManifest, hTheirManifest, &s_apszIgnoreEntries[0], NULL,
|
---|
757 | RTMANIFEST_EQUALS_IGN_MISSING_ATTRS /*fFlags*/,
|
---|
758 | szError, sizeof(szError));
|
---|
759 | if (RT_SUCCESS(rc))
|
---|
760 | {
|
---|
761 | /*
|
---|
762 | * Validate the manifest file signature.
|
---|
763 | */
|
---|
764 | /** @todo implement signature stuff */
|
---|
765 | NOREF(hSignatureFile);
|
---|
766 |
|
---|
767 | }
|
---|
768 | else if (rc == VERR_NOT_EQUAL && szError[0])
|
---|
769 | vboxExtPackSetError(pszError, cbError, "Manifest mismatch: %s", szError);
|
---|
770 | else
|
---|
771 | vboxExtPackSetError(pszError, cbError, "RTManifestEqualsEx failed: %Rrc", rc);
|
---|
772 | #if 0
|
---|
773 | RTVFSIOSTREAM hVfsIosStdOut = NIL_RTVFSIOSTREAM;
|
---|
774 | RTVfsIoStrmFromStdHandle(RTHANDLESTD_OUTPUT, RTFILE_O_WRITE, true, &hVfsIosStdOut);
|
---|
775 | RTVfsIoStrmWrite(hVfsIosStdOut, "Our:\n", sizeof("Our:\n") - 1, true, NULL);
|
---|
776 | RTManifestWriteStandard(hOurManifest, hVfsIosStdOut);
|
---|
777 | RTVfsIoStrmWrite(hVfsIosStdOut, "Their:\n", sizeof("Their:\n") - 1, true, NULL);
|
---|
778 | RTManifestWriteStandard(hTheirManifest, hVfsIosStdOut);
|
---|
779 | #endif
|
---|
780 | }
|
---|
781 | else
|
---|
782 | vboxExtPackSetError(pszError, cbError, "Error parsing '%s': %Rrc", VBOX_EXTPACK_MANIFEST_NAME, rc);
|
---|
783 |
|
---|
784 | RTManifestRelease(hTheirManifest);
|
---|
785 | return rc;
|
---|
786 | }
|
---|
787 |
|
---|
788 |
|
---|
789 | /**
|
---|
790 | * Verifies the file digest (if specified) and returns the SHA-256 of the file.
|
---|
791 | *
|
---|
792 | * @returns
|
---|
793 | * @param hFileManifest Manifest containing a SHA-256 digest of the file
|
---|
794 | * that was calculated as the file was processed.
|
---|
795 | * @param pszFileDigest SHA-256 digest of the file.
|
---|
796 | * @param pStrDigest Where to return the SHA-256 digest. Optional.
|
---|
797 | * @param pszError Where to write an error message on failure.
|
---|
798 | * @param cbError The size of the @a pszError buffer.
|
---|
799 | */
|
---|
800 | static int vboxExtPackVerifyFileDigest(RTMANIFEST hFileManifest, const char *pszFileDigest,
|
---|
801 | RTCString *pStrDigest, char *pszError, size_t cbError)
|
---|
802 | {
|
---|
803 | /*
|
---|
804 | * Extract the SHA-256 entry for the extpack file.
|
---|
805 | */
|
---|
806 | char szCalculatedDigest[RTSHA256_DIGEST_LEN + 1];
|
---|
807 | int rc = RTManifestEntryQueryAttr(hFileManifest, "extpack", NULL /*no name*/, RTMANIFEST_ATTR_SHA256,
|
---|
808 | szCalculatedDigest, sizeof(szCalculatedDigest), NULL);
|
---|
809 | if (RT_SUCCESS(rc))
|
---|
810 | {
|
---|
811 | /*
|
---|
812 | * Convert the two strings to binary form before comparing.
|
---|
813 | * We convert the calculated hash even if we don't have anything to
|
---|
814 | * compare with, just to validate it.
|
---|
815 | */
|
---|
816 | uint8_t abCalculatedHash[RTSHA256_HASH_SIZE];
|
---|
817 | rc = RTSha256FromString(szCalculatedDigest, abCalculatedHash);
|
---|
818 | if (RT_SUCCESS(rc))
|
---|
819 | {
|
---|
820 | if ( pszFileDigest
|
---|
821 | && *pszFileDigest != '\0')
|
---|
822 | {
|
---|
823 | uint8_t abFileHash[RTSHA256_HASH_SIZE];
|
---|
824 | rc = RTSha256FromString(pszFileDigest, abFileHash);
|
---|
825 | if (RT_SUCCESS(rc))
|
---|
826 | {
|
---|
827 | if (memcmp(abFileHash, abCalculatedHash, sizeof(abFileHash)))
|
---|
828 | {
|
---|
829 | vboxExtPackSetError(pszError, cbError, "The extension pack file has changed (SHA-256 mismatch)");
|
---|
830 | rc = VERR_NOT_EQUAL;
|
---|
831 | }
|
---|
832 | }
|
---|
833 | else
|
---|
834 | vboxExtPackSetError(pszError, cbError, "Bad SHA-256 '%s': %Rrc", szCalculatedDigest, rc);
|
---|
835 | }
|
---|
836 |
|
---|
837 | /*
|
---|
838 | * Set the output hash on success.
|
---|
839 | */
|
---|
840 | if (pStrDigest && RT_SUCCESS(rc))
|
---|
841 | {
|
---|
842 | try
|
---|
843 | {
|
---|
844 | *pStrDigest = szCalculatedDigest;
|
---|
845 | }
|
---|
846 | catch (std::bad_alloc)
|
---|
847 | {
|
---|
848 | rc = VERR_NO_MEMORY;
|
---|
849 | }
|
---|
850 | }
|
---|
851 | }
|
---|
852 | else
|
---|
853 | vboxExtPackSetError(pszError, cbError, "Bad SHA-256 '%s': %Rrc", szCalculatedDigest, rc);
|
---|
854 | }
|
---|
855 | else
|
---|
856 | vboxExtPackSetError(pszError, cbError, "RTManifestEntryGetAttr: %Rrc", rc);
|
---|
857 | return rc;
|
---|
858 | }
|
---|
859 |
|
---|
860 |
|
---|
861 |
|
---|
862 | /**
|
---|
863 | * Validates a standard file.
|
---|
864 | *
|
---|
865 | * Generally all files are
|
---|
866 | *
|
---|
867 | * @returns VBox status code, failure message in @a pszError.
|
---|
868 | * @param pszAdjName The adjusted member name.
|
---|
869 | * @param enmType The VFS object type.
|
---|
870 | * @param phVfsObj The pointer to the VFS object handle variable.
|
---|
871 | * This is both input and output.
|
---|
872 | * @param phVfsFile Where to store the handle to the memorized
|
---|
873 | * file. This is NULL for license files.
|
---|
874 | * @param pszError Where to write an error message on failure.
|
---|
875 | * @param cbError The size of the @a pszError buffer.
|
---|
876 | */
|
---|
877 | static int VBoxExtPackValidateStandardFile(const char *pszAdjName, RTVFSOBJTYPE enmType,
|
---|
878 | PRTVFSOBJ phVfsObj, PRTVFSFILE phVfsFile, char *pszError, size_t cbError)
|
---|
879 | {
|
---|
880 | int rc;
|
---|
881 |
|
---|
882 | /*
|
---|
883 | * Make sure it's a file and that it isn't too large.
|
---|
884 | */
|
---|
885 | if (phVfsFile && *phVfsFile != NIL_RTVFSFILE)
|
---|
886 | rc = vboxExtPackReturnError(VERR_DUPLICATE, pszError, cbError,
|
---|
887 | "There can only be one '%s'", pszAdjName);
|
---|
888 | else if (enmType != RTVFSOBJTYPE_IO_STREAM && enmType != RTVFSOBJTYPE_FILE)
|
---|
889 | rc = vboxExtPackReturnError(VERR_NOT_A_FILE, pszError, cbError,
|
---|
890 | "Standard member '%s' is not a file", pszAdjName);
|
---|
891 | else
|
---|
892 | {
|
---|
893 | RTFSOBJINFO ObjInfo;
|
---|
894 | rc = RTVfsObjQueryInfo(*phVfsObj, &ObjInfo, RTFSOBJATTRADD_NOTHING);
|
---|
895 | if (RT_SUCCESS(rc))
|
---|
896 | {
|
---|
897 | if (!RTFS_IS_FILE(ObjInfo.Attr.fMode))
|
---|
898 | rc = vboxExtPackReturnError(VERR_NOT_A_FILE, pszError, cbError,
|
---|
899 | "Standard member '%s' is not a file", pszAdjName);
|
---|
900 | else if (ObjInfo.cbObject >= _1M)
|
---|
901 | rc = vboxExtPackReturnError(VERR_OUT_OF_RANGE, pszError, cbError,
|
---|
902 | "Standard member '%s' is too large: %'RU64 bytes (max 1 MB)",
|
---|
903 | pszAdjName, (uint64_t)ObjInfo.cbObject);
|
---|
904 | else
|
---|
905 | {
|
---|
906 | /*
|
---|
907 | * Make an in memory copy of the stream and check that the file
|
---|
908 | * is UTF-8 clean.
|
---|
909 | */
|
---|
910 | RTVFSIOSTREAM hVfsIos = RTVfsObjToIoStream(*phVfsObj);
|
---|
911 | RTVFSFILE hVfsFile;
|
---|
912 | rc = RTVfsMemorizeIoStreamAsFile(hVfsIos, RTFILE_O_READ, &hVfsFile);
|
---|
913 | if (RT_SUCCESS(rc))
|
---|
914 | {
|
---|
915 | rc = RTVfsIoStrmValidateUtf8Encoding(hVfsIos,
|
---|
916 | RTVFS_VALIDATE_UTF8_BY_RTC_3629 | RTVFS_VALIDATE_UTF8_NO_NULL,
|
---|
917 | NULL);
|
---|
918 | if (RT_SUCCESS(rc))
|
---|
919 | {
|
---|
920 | /*
|
---|
921 | * Replace *phVfsObj with the memorized file.
|
---|
922 | */
|
---|
923 | rc = RTVfsFileSeek(hVfsFile, 0, RTFILE_SEEK_BEGIN, NULL);
|
---|
924 | if (RT_SUCCESS(rc))
|
---|
925 | {
|
---|
926 | RTVfsObjRelease(*phVfsObj);
|
---|
927 | *phVfsObj = RTVfsObjFromFile(hVfsFile);
|
---|
928 | }
|
---|
929 | else
|
---|
930 | vboxExtPackSetError(pszError, cbError, "RTVfsFileSeek failed on '%s': %Rrc", pszAdjName, rc);
|
---|
931 | }
|
---|
932 |
|
---|
933 | if (phVfsFile && RT_SUCCESS(rc))
|
---|
934 | *phVfsFile = hVfsFile;
|
---|
935 | else
|
---|
936 | RTVfsFileRelease(hVfsFile);
|
---|
937 | }
|
---|
938 | else
|
---|
939 | vboxExtPackSetError(pszError, cbError, "RTVfsMemorizeIoStreamAsFile failed on '%s': %Rrc", pszAdjName, rc);
|
---|
940 | RTVfsIoStrmRelease(hVfsIos);
|
---|
941 | }
|
---|
942 | }
|
---|
943 | else
|
---|
944 | vboxExtPackSetError(pszError, cbError, "RTVfsObjQueryInfo failed on '%s': %Rrc", pszAdjName, rc);
|
---|
945 | }
|
---|
946 | return rc;
|
---|
947 | }
|
---|
948 |
|
---|
949 |
|
---|
950 | /**
|
---|
951 | * Validates a name in an extension pack.
|
---|
952 | *
|
---|
953 | * We restrict the charset to try make sure the extension pack can be unpacked
|
---|
954 | * on all file systems.
|
---|
955 | *
|
---|
956 | * @returns VBox status code, failures with message.
|
---|
957 | * @param pszName The name to validate.
|
---|
958 | * @param pszError Where to store an error message on failure.
|
---|
959 | * @param cbError The size of the buffer @a pszError points to.
|
---|
960 | */
|
---|
961 | static int vboxExtPackValidateMemberName(const char *pszName, char *pszError, size_t cbError)
|
---|
962 | {
|
---|
963 | if (RTPathStartsWithRoot(pszName))
|
---|
964 | return vboxExtPackReturnError(VERR_PATH_IS_NOT_RELATIVE, pszError, cbError, "'%s': starts with root spec", pszName);
|
---|
965 |
|
---|
966 | const char *pszErr = NULL;
|
---|
967 | const char *psz = pszName;
|
---|
968 | int ch;
|
---|
969 | while ((ch = *psz) != '\0')
|
---|
970 | {
|
---|
971 | /* Character set restrictions. */
|
---|
972 | if (ch < 0 || ch >= 128)
|
---|
973 | {
|
---|
974 | pszErr = "Only 7-bit ASCII allowed";
|
---|
975 | break;
|
---|
976 | }
|
---|
977 | if (ch <= 31 || ch == 127)
|
---|
978 | {
|
---|
979 | pszErr = "No control characters are not allowed";
|
---|
980 | break;
|
---|
981 | }
|
---|
982 | if (ch == '\\')
|
---|
983 | {
|
---|
984 | pszErr = "Only backward slashes are not allowed";
|
---|
985 | break;
|
---|
986 | }
|
---|
987 | if (strchr("'\":;*?|[]<>(){}", ch))
|
---|
988 | {
|
---|
989 | pszErr = "The characters ', \", :, ;, *, ?, |, [, ], <, >, (, ), { and } are not allowed";
|
---|
990 | break;
|
---|
991 | }
|
---|
992 |
|
---|
993 | /* Take the simple way out and ban all ".." sequences. */
|
---|
994 | if ( ch == '.'
|
---|
995 | && psz[1] == '.')
|
---|
996 | {
|
---|
997 | pszErr = "Double dot sequence are not allowed";
|
---|
998 | break;
|
---|
999 | }
|
---|
1000 |
|
---|
1001 | /* Keep the tree shallow or the hardening checks will fail. */
|
---|
1002 | if (psz - pszName > VBOX_EXTPACK_MAX_MEMBER_NAME_LENGTH)
|
---|
1003 | {
|
---|
1004 | pszErr = "Too long";
|
---|
1005 | break;
|
---|
1006 | }
|
---|
1007 |
|
---|
1008 | /* advance */
|
---|
1009 | psz++;
|
---|
1010 | }
|
---|
1011 |
|
---|
1012 | if (pszErr)
|
---|
1013 | return vboxExtPackReturnError(VERR_INVALID_NAME, pszError, cbError,
|
---|
1014 | "Bad member name '%s' (pos %zu): %s", pszName, (size_t)(psz - pszName), pszErr);
|
---|
1015 | return RTEXITCODE_SUCCESS;
|
---|
1016 | }
|
---|
1017 |
|
---|
1018 |
|
---|
1019 | /**
|
---|
1020 | * Validates a file in an extension pack.
|
---|
1021 | *
|
---|
1022 | * @returns VBox status code, failures with message.
|
---|
1023 | * @param pszName The name of the file.
|
---|
1024 | * @param hVfsObj The VFS object.
|
---|
1025 | * @param pszError Where to store an error message on failure.
|
---|
1026 | * @param cbError The size of the buffer @a pszError points to.
|
---|
1027 | */
|
---|
1028 | static int vboxExtPackValidateMemberFile(const char *pszName, RTVFSOBJ hVfsObj, char *pszError, size_t cbError)
|
---|
1029 | {
|
---|
1030 | int rc = vboxExtPackValidateMemberName(pszName, pszError, cbError);
|
---|
1031 | if (RT_SUCCESS(rc))
|
---|
1032 | {
|
---|
1033 | RTFSOBJINFO ObjInfo;
|
---|
1034 | rc = RTVfsObjQueryInfo(hVfsObj, &ObjInfo, RTFSOBJATTRADD_NOTHING);
|
---|
1035 | if (RT_SUCCESS(rc))
|
---|
1036 | {
|
---|
1037 | if (ObjInfo.cbObject >= 9*_1G64)
|
---|
1038 | rc = vboxExtPackReturnError(VERR_OUT_OF_RANGE, pszError, cbError,
|
---|
1039 | "'%s': too large (%'RU64 bytes)",
|
---|
1040 | pszName, (uint64_t)ObjInfo.cbObject);
|
---|
1041 | if (!RTFS_IS_FILE(ObjInfo.Attr.fMode))
|
---|
1042 | rc = vboxExtPackReturnError(VERR_NOT_A_FILE, pszError, cbError,
|
---|
1043 | "The alleged file '%s' has a mode mask stating otherwise (%RTfmode)",
|
---|
1044 | pszName, ObjInfo.Attr.fMode);
|
---|
1045 | }
|
---|
1046 | else
|
---|
1047 | vboxExtPackSetError(pszError, cbError, "RTVfsObjQueryInfo failed on '%s': %Rrc", pszName, rc);
|
---|
1048 | }
|
---|
1049 | return rc;
|
---|
1050 | }
|
---|
1051 |
|
---|
1052 |
|
---|
1053 | /**
|
---|
1054 | * Validates a directory in an extension pack.
|
---|
1055 | *
|
---|
1056 | * @returns VBox status code, failures with message.
|
---|
1057 | * @param pszName The name of the directory.
|
---|
1058 | * @param hVfsObj The VFS object.
|
---|
1059 | * @param pszError Where to store an error message on failure.
|
---|
1060 | * @param cbError The size of the buffer @a pszError points to.
|
---|
1061 | */
|
---|
1062 | static int vboxExtPackValidateMemberDir(const char *pszName, RTVFSOBJ hVfsObj, char *pszError, size_t cbError)
|
---|
1063 | {
|
---|
1064 | int rc = vboxExtPackValidateMemberName(pszName, pszError, cbError);
|
---|
1065 | if (RT_SUCCESS(rc))
|
---|
1066 | {
|
---|
1067 | RTFSOBJINFO ObjInfo;
|
---|
1068 | rc = RTVfsObjQueryInfo(hVfsObj, &ObjInfo, RTFSOBJATTRADD_NOTHING);
|
---|
1069 | if (RT_SUCCESS(rc))
|
---|
1070 | {
|
---|
1071 | if (!RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode))
|
---|
1072 | rc = vboxExtPackReturnError(VERR_NOT_A_DIRECTORY, pszError, cbError,
|
---|
1073 | "The alleged directory '%s' has a mode mask saying differently (%RTfmode)",
|
---|
1074 | pszName, ObjInfo.Attr.fMode);
|
---|
1075 | }
|
---|
1076 | else
|
---|
1077 | vboxExtPackSetError(pszError, cbError, "RTVfsObjQueryInfo failed on '%s': %Rrc", pszName, rc);
|
---|
1078 | }
|
---|
1079 | return rc;
|
---|
1080 | }
|
---|
1081 |
|
---|
1082 | /**
|
---|
1083 | * Validates a member of an extension pack.
|
---|
1084 | *
|
---|
1085 | * @returns VBox status code, failures with message.
|
---|
1086 | * @param pszName The name of the directory.
|
---|
1087 | * @param enmType The object type.
|
---|
1088 | * @param hVfsObj The VFS object.
|
---|
1089 | * @param pszError Where to store an error message on failure.
|
---|
1090 | * @param cbError The size of the buffer @a pszError points to.
|
---|
1091 | */
|
---|
1092 | int VBoxExtPackValidateMember(const char *pszName, RTVFSOBJTYPE enmType, RTVFSOBJ hVfsObj, char *pszError, size_t cbError)
|
---|
1093 | {
|
---|
1094 | Assert(cbError > 0);
|
---|
1095 | *pszError = '\0';
|
---|
1096 |
|
---|
1097 | int rc;
|
---|
1098 | if ( enmType == RTVFSOBJTYPE_FILE
|
---|
1099 | || enmType == RTVFSOBJTYPE_IO_STREAM)
|
---|
1100 | rc = vboxExtPackValidateMemberFile(pszName, hVfsObj, pszError, cbError);
|
---|
1101 | else if ( enmType == RTVFSOBJTYPE_DIR
|
---|
1102 | || enmType == RTVFSOBJTYPE_BASE)
|
---|
1103 | rc = vboxExtPackValidateMemberDir(pszName, hVfsObj, pszError, cbError);
|
---|
1104 | else
|
---|
1105 | rc = vboxExtPackReturnError(VERR_UNEXPECTED_FS_OBJ_TYPE, pszError, cbError,
|
---|
1106 | "'%s' is not a file or directory (enmType=%d)", pszName, enmType);
|
---|
1107 | return rc;
|
---|
1108 | }
|
---|
1109 |
|
---|
1110 |
|
---|
1111 | /**
|
---|
1112 | * Rewinds the tarball file handle and creates a gunzip | tar chain that
|
---|
1113 | * results in a filesystem stream.
|
---|
1114 | *
|
---|
1115 | * @returns VBox status code, failures with message.
|
---|
1116 | * @param hTarballFile The handle to the tarball file.
|
---|
1117 | * @param pszError Where to store an error message on failure.
|
---|
1118 | * @param cbError The size of the buffer @a pszError points to.
|
---|
1119 | * @param phTarFss Where to return the filesystem stream handle.
|
---|
1120 | * @param phFileManifest Where to return a manifest where the tarball is
|
---|
1121 | * gettting hashed. The entry will be called
|
---|
1122 | * "extpack" and be ready when the file system
|
---|
1123 | * stream is at an end. Optional.
|
---|
1124 | */
|
---|
1125 | int VBoxExtPackOpenTarFss(RTFILE hTarballFile, char *pszError, size_t cbError, PRTVFSFSSTREAM phTarFss,
|
---|
1126 | PRTMANIFEST phFileManifest)
|
---|
1127 | {
|
---|
1128 | Assert(cbError > 0);
|
---|
1129 | *pszError = '\0';
|
---|
1130 | *phTarFss = NIL_RTVFSFSSTREAM;
|
---|
1131 |
|
---|
1132 | /*
|
---|
1133 | * Rewind the file and set up a VFS chain for it.
|
---|
1134 | */
|
---|
1135 | int rc = RTFileSeek(hTarballFile, 0, RTFILE_SEEK_BEGIN, NULL);
|
---|
1136 | if (RT_FAILURE(rc))
|
---|
1137 | return vboxExtPackReturnError(rc, pszError, cbError, "Failed seeking to the start of the tarball: %Rrc", rc);
|
---|
1138 |
|
---|
1139 | RTVFSIOSTREAM hTarballIos;
|
---|
1140 | rc = RTVfsIoStrmFromRTFile(hTarballFile, RTFILE_O_READ | RTFILE_O_DENY_WRITE | RTFILE_O_OPEN, true /*fLeaveOpen*/,
|
---|
1141 | &hTarballIos);
|
---|
1142 | if (RT_FAILURE(rc))
|
---|
1143 | return vboxExtPackReturnError(rc, pszError, cbError, "RTVfsIoStrmFromRTFile failed: %Rrc", rc);
|
---|
1144 |
|
---|
1145 | RTMANIFEST hFileManifest = NIL_RTMANIFEST;
|
---|
1146 | rc = RTManifestCreate(0 /*fFlags*/, &hFileManifest);
|
---|
1147 | if (RT_SUCCESS(rc))
|
---|
1148 | {
|
---|
1149 | RTVFSIOSTREAM hPtIos;
|
---|
1150 | rc = RTManifestEntryAddPassthruIoStream(hFileManifest, hTarballIos, "extpack", RTMANIFEST_ATTR_SHA256,
|
---|
1151 | true /*read*/, &hPtIos);
|
---|
1152 | if (RT_SUCCESS(rc))
|
---|
1153 | {
|
---|
1154 | RTVFSIOSTREAM hGunzipIos;
|
---|
1155 | rc = RTZipGzipDecompressIoStream(hPtIos, 0 /*fFlags*/, &hGunzipIos);
|
---|
1156 | if (RT_SUCCESS(rc))
|
---|
1157 | {
|
---|
1158 | RTVFSFSSTREAM hTarFss;
|
---|
1159 | rc = RTZipTarFsStreamFromIoStream(hGunzipIos, 0 /*fFlags*/, &hTarFss);
|
---|
1160 | if (RT_SUCCESS(rc))
|
---|
1161 | {
|
---|
1162 | RTVfsIoStrmRelease(hPtIos);
|
---|
1163 | RTVfsIoStrmRelease(hGunzipIos);
|
---|
1164 | RTVfsIoStrmRelease(hTarballIos);
|
---|
1165 | *phTarFss = hTarFss;
|
---|
1166 | if (phFileManifest)
|
---|
1167 | *phFileManifest = hFileManifest;
|
---|
1168 | else
|
---|
1169 | RTManifestRelease(hFileManifest);
|
---|
1170 | return VINF_SUCCESS;
|
---|
1171 | }
|
---|
1172 |
|
---|
1173 | vboxExtPackSetError(pszError, cbError, "RTZipTarFsStreamFromIoStream failed: %Rrc", rc);
|
---|
1174 | RTVfsIoStrmRelease(hGunzipIos);
|
---|
1175 | }
|
---|
1176 | else
|
---|
1177 | vboxExtPackSetError(pszError, cbError, "RTZipGzipDecompressIoStream failed: %Rrc", rc);
|
---|
1178 | RTVfsIoStrmRelease(hPtIos);
|
---|
1179 | }
|
---|
1180 | else
|
---|
1181 | vboxExtPackSetError(pszError, cbError, "RTManifestEntryAddPassthruIoStream failed: %Rrc", rc);
|
---|
1182 | RTManifestRelease(hFileManifest);
|
---|
1183 | }
|
---|
1184 | else
|
---|
1185 | vboxExtPackSetError(pszError, cbError, "RTManifestCreate failed: %Rrc", rc);
|
---|
1186 |
|
---|
1187 | RTVfsIoStrmRelease(hTarballIos);
|
---|
1188 | return rc;
|
---|
1189 | }
|
---|
1190 |
|
---|
1191 |
|
---|
1192 | /**
|
---|
1193 | * Validates the extension pack tarball prior to unpacking.
|
---|
1194 | *
|
---|
1195 | * Operations performed:
|
---|
1196 | * - Mandatory files.
|
---|
1197 | * - Manifest check.
|
---|
1198 | * - Manifest seal check.
|
---|
1199 | * - XML check, match name.
|
---|
1200 | *
|
---|
1201 | * @returns VBox status code, failures with message.
|
---|
1202 | * @param hTarballFile The handle to open the @a pszTarball file.
|
---|
1203 | * @param pszExtPackName The name of the extension pack name. NULL if
|
---|
1204 | * the name is not fixed.
|
---|
1205 | * @param pszTarball The name of the tarball in case we have to
|
---|
1206 | * complain about something.
|
---|
1207 | * @param pszTarballDigest The SHA-256 digest of the tarball. Empty string
|
---|
1208 | * if no digest available.
|
---|
1209 | * @param pszError Where to store an error message on failure.
|
---|
1210 | * @param cbError The size of the buffer @a pszError points to.
|
---|
1211 | * @param phValidManifest Where to optionally return the handle to fully
|
---|
1212 | * validated the manifest for the extension pack.
|
---|
1213 | * This includes all files.
|
---|
1214 | * @param phXmlFile Where to optionally return the memorized XML
|
---|
1215 | * file.
|
---|
1216 | * @param pStrDigest Where to return the digest of the file.
|
---|
1217 | * Optional.
|
---|
1218 | */
|
---|
1219 | int VBoxExtPackValidateTarball(RTFILE hTarballFile, const char *pszExtPackName,
|
---|
1220 | const char *pszTarball, const char *pszTarballDigest,
|
---|
1221 | char *pszError, size_t cbError,
|
---|
1222 | PRTMANIFEST phValidManifest, PRTVFSFILE phXmlFile, RTCString *pStrDigest)
|
---|
1223 | {
|
---|
1224 | /*
|
---|
1225 | * Clear return values.
|
---|
1226 | */
|
---|
1227 | if (phValidManifest)
|
---|
1228 | *phValidManifest = NIL_RTMANIFEST;
|
---|
1229 | if (phXmlFile)
|
---|
1230 | *phXmlFile = NIL_RTVFSFILE;
|
---|
1231 | Assert(cbError > 1);
|
---|
1232 | *pszError = '\0';
|
---|
1233 | NOREF(pszTarball);
|
---|
1234 |
|
---|
1235 | /*
|
---|
1236 | * Open the tar.gz filesystem stream and set up an manifest in-memory file.
|
---|
1237 | */
|
---|
1238 | RTMANIFEST hFileManifest;
|
---|
1239 | RTVFSFSSTREAM hTarFss;
|
---|
1240 | int rc = VBoxExtPackOpenTarFss(hTarballFile, pszError, cbError, &hTarFss, &hFileManifest);
|
---|
1241 | if (RT_FAILURE(rc))
|
---|
1242 | return rc;
|
---|
1243 |
|
---|
1244 | RTMANIFEST hOurManifest;
|
---|
1245 | rc = RTManifestCreate(0 /*fFlags*/, &hOurManifest);
|
---|
1246 | if (RT_SUCCESS(rc))
|
---|
1247 | {
|
---|
1248 | /*
|
---|
1249 | * Process the tarball (would be nice to move this to a function).
|
---|
1250 | */
|
---|
1251 | RTVFSFILE hXmlFile = NIL_RTVFSFILE;
|
---|
1252 | RTVFSFILE hManifestFile = NIL_RTVFSFILE;
|
---|
1253 | RTVFSFILE hSignatureFile = NIL_RTVFSFILE;
|
---|
1254 | for (;;)
|
---|
1255 | {
|
---|
1256 | /*
|
---|
1257 | * Get the next stream object.
|
---|
1258 | */
|
---|
1259 | char *pszName;
|
---|
1260 | RTVFSOBJ hVfsObj;
|
---|
1261 | RTVFSOBJTYPE enmType;
|
---|
1262 | rc = RTVfsFsStrmNext(hTarFss, &pszName, &enmType, &hVfsObj);
|
---|
1263 | if (RT_FAILURE(rc))
|
---|
1264 | {
|
---|
1265 | if (rc != VERR_EOF)
|
---|
1266 | vboxExtPackSetError(pszError, cbError, "RTVfsFsStrmNext failed: %Rrc", rc);
|
---|
1267 | else
|
---|
1268 | rc = VINF_SUCCESS;
|
---|
1269 | break;
|
---|
1270 | }
|
---|
1271 | const char *pszAdjName = pszName[0] == '.' && pszName[1] == '/' ? &pszName[2] : pszName;
|
---|
1272 |
|
---|
1273 | /*
|
---|
1274 | * Check the type & name validity, performing special tests on
|
---|
1275 | * standard extension pack member files.
|
---|
1276 | *
|
---|
1277 | * N.B. We will always reach the end of the loop before breaking on
|
---|
1278 | * failure - cleanup reasons.
|
---|
1279 | */
|
---|
1280 | rc = VBoxExtPackValidateMember(pszName, enmType, hVfsObj, pszError, cbError);
|
---|
1281 | if (RT_SUCCESS(rc))
|
---|
1282 | {
|
---|
1283 | PRTVFSFILE phVfsFile = NULL;
|
---|
1284 | if (!strcmp(pszAdjName, VBOX_EXTPACK_DESCRIPTION_NAME))
|
---|
1285 | phVfsFile = &hXmlFile;
|
---|
1286 | else if (!strcmp(pszAdjName, VBOX_EXTPACK_MANIFEST_NAME))
|
---|
1287 | phVfsFile = &hManifestFile;
|
---|
1288 | else if (!strcmp(pszAdjName, VBOX_EXTPACK_SIGNATURE_NAME))
|
---|
1289 | phVfsFile = &hSignatureFile;
|
---|
1290 | else if (!strncmp(pszAdjName, VBOX_EXTPACK_LICENSE_NAME_PREFIX, sizeof(VBOX_EXTPACK_LICENSE_NAME_PREFIX) - 1))
|
---|
1291 | rc = VBoxExtPackValidateStandardFile(pszAdjName, enmType, &hVfsObj, NULL, pszError, cbError);
|
---|
1292 | if (phVfsFile)
|
---|
1293 | rc = VBoxExtPackValidateStandardFile(pszAdjName, enmType, &hVfsObj, phVfsFile, pszError, cbError);
|
---|
1294 | }
|
---|
1295 |
|
---|
1296 | /*
|
---|
1297 | * Add any I/O stream to the manifest
|
---|
1298 | */
|
---|
1299 | if ( RT_SUCCESS(rc)
|
---|
1300 | && ( enmType == RTVFSOBJTYPE_FILE
|
---|
1301 | || enmType == RTVFSOBJTYPE_IO_STREAM))
|
---|
1302 | {
|
---|
1303 | RTVFSIOSTREAM hVfsIos = RTVfsObjToIoStream(hVfsObj);
|
---|
1304 | rc = RTManifestEntryAddIoStream(hOurManifest, hVfsIos, pszAdjName, RTMANIFEST_ATTR_SIZE | RTMANIFEST_ATTR_SHA256);
|
---|
1305 | if (RT_FAILURE(rc))
|
---|
1306 | vboxExtPackSetError(pszError, cbError, "RTManifestEntryAddIoStream failed on '%s': %Rrc", pszAdjName, rc);
|
---|
1307 | RTVfsIoStrmRelease(hVfsIos);
|
---|
1308 | }
|
---|
1309 |
|
---|
1310 | /*
|
---|
1311 | * Clean up and break out on failure.
|
---|
1312 | */
|
---|
1313 | RTVfsObjRelease(hVfsObj);
|
---|
1314 | RTStrFree(pszName);
|
---|
1315 | if (RT_FAILURE(rc))
|
---|
1316 | break;
|
---|
1317 | }
|
---|
1318 |
|
---|
1319 | /*
|
---|
1320 | * Check the integrity of the tarball file.
|
---|
1321 | */
|
---|
1322 | if (RT_SUCCESS(rc))
|
---|
1323 | {
|
---|
1324 | RTVfsFsStrmRelease(hTarFss);
|
---|
1325 | hTarFss = NIL_RTVFSFSSTREAM;
|
---|
1326 | rc = vboxExtPackVerifyFileDigest(hFileManifest, pszTarballDigest, pStrDigest, pszError, cbError);
|
---|
1327 | }
|
---|
1328 |
|
---|
1329 | /*
|
---|
1330 | * If we've successfully processed the tarball, verify that the
|
---|
1331 | * mandatory files are present.
|
---|
1332 | */
|
---|
1333 | if (RT_SUCCESS(rc))
|
---|
1334 | {
|
---|
1335 | if (hXmlFile == NIL_RTVFSFILE)
|
---|
1336 | rc = vboxExtPackReturnError(VERR_MISSING, pszError, cbError, "Mandator file '%s' is missing",
|
---|
1337 | VBOX_EXTPACK_DESCRIPTION_NAME);
|
---|
1338 | if (hManifestFile == NIL_RTVFSFILE)
|
---|
1339 | rc = vboxExtPackReturnError(VERR_MISSING, pszError, cbError, "Mandator file '%s' is missing",
|
---|
1340 | VBOX_EXTPACK_MANIFEST_NAME);
|
---|
1341 | if (hSignatureFile == NIL_RTVFSFILE)
|
---|
1342 | rc = vboxExtPackReturnError(VERR_MISSING, pszError, cbError, "Mandator file '%s' is missing",
|
---|
1343 | VBOX_EXTPACK_SIGNATURE_NAME);
|
---|
1344 | }
|
---|
1345 |
|
---|
1346 | /*
|
---|
1347 | * Check the manifest and it's signature.
|
---|
1348 | */
|
---|
1349 | if (RT_SUCCESS(rc))
|
---|
1350 | rc = vboxExtPackVerifyManifestAndSignature(hOurManifest, hManifestFile, hSignatureFile, pszError, cbError);
|
---|
1351 |
|
---|
1352 | /*
|
---|
1353 | * Check the XML.
|
---|
1354 | */
|
---|
1355 | if (RT_SUCCESS(rc))
|
---|
1356 | rc = vboxExtPackVerifyXml(hXmlFile, pszExtPackName, pszError, cbError);
|
---|
1357 |
|
---|
1358 | /*
|
---|
1359 | * Returns objects.
|
---|
1360 | */
|
---|
1361 | if (RT_SUCCESS(rc))
|
---|
1362 | {
|
---|
1363 | if (phValidManifest)
|
---|
1364 | {
|
---|
1365 | RTManifestRetain(hOurManifest);
|
---|
1366 | *phValidManifest = hOurManifest;
|
---|
1367 | }
|
---|
1368 | if (phXmlFile)
|
---|
1369 | {
|
---|
1370 | RTVfsFileRetain(hXmlFile);
|
---|
1371 | *phXmlFile = hXmlFile;
|
---|
1372 | }
|
---|
1373 | }
|
---|
1374 |
|
---|
1375 | /*
|
---|
1376 | * Release our object references.
|
---|
1377 | */
|
---|
1378 | RTManifestRelease(hOurManifest);
|
---|
1379 | RTVfsFileRelease(hXmlFile);
|
---|
1380 | RTVfsFileRelease(hManifestFile);
|
---|
1381 | RTVfsFileRelease(hSignatureFile);
|
---|
1382 | }
|
---|
1383 | else
|
---|
1384 | vboxExtPackSetError(pszError, cbError, "RTManifestCreate failed: %Rrc", rc);
|
---|
1385 | RTVfsFsStrmRelease(hTarFss);
|
---|
1386 | RTManifestRelease(hFileManifest);
|
---|
1387 |
|
---|
1388 | return rc;
|
---|
1389 | }
|
---|
1390 |
|
---|