ExtPackUtil.cpp@ 59083

Last change on this file since 59083 was 57358, checked in by vboxsync, 9 years ago
*: scm cleanup run.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 48.8 KB

Line
1	/* $Id: ExtPackUtil.cpp 57358 2015-08-14 15:16:38Z 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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/src-all/ExtPackUtil.cpp@ 59083

Download in other formats: