ExtPackManagerImpl.cpp@ 104507

Last change on this file since 104507 was 103311, checked in by vboxsync, 10 months ago
Fixed some (potential) va_args leaks (found by Parfait). bugref:3409
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 133.4 KB

Line
1	/* $Id: ExtPackManagerImpl.cpp 103311 2024-02-12 12:33:46Z vboxsync $ */
2	/** @file
3	* VirtualBox Main - interface for Extension Packs, VBoxSVC & VBoxC.
4	*/
5
6	/*
7	* Copyright (C) 2010-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#include "ExtPackManagerImpl.h"
33	#include "CloudProviderManagerImpl.h"
34	#include "ExtPackUtil.h"
35	#include "ThreadTask.h"
36
37	#include <iprt/buildconfig.h>
38	#include <iprt/ctype.h>
39	#include <iprt/dir.h>
40	#include <iprt/env.h>
41	#include <iprt/file.h>
42	#include <iprt/ldr.h>
43	#include <iprt/locale.h>
44	#include <iprt/manifest.h>
45	#include <iprt/param.h>
46	#include <iprt/path.h>
47	#include <iprt/pipe.h>
48	#include <iprt/process.h>
49	#include <iprt/string.h>
50
51	#include <VBox/com/array.h>
52	#include <VBox/com/ErrorInfo.h>
53	#include <VBox/err.h>
54	#include <VBox/log.h>
55	#include <VBox/sup.h>
56	#include <VBox/version.h>
57
58	#include <algorithm>
59
60	#include "AutoCaller.h"
61	#include "Global.h"
62	#include "ProgressImpl.h"
63	#ifdef VBOX_COM_INPROC
64	# include "ConsoleImpl.h"
65	#else
66	# include "VirtualBoxImpl.h"
67	#endif
68
69
70	/*********************************************************************************************************************************
71	* Defined Constants And Macros *
72	*********************************************************************************************************************************/
73	/** @def VBOX_EXTPACK_HELPER_NAME
74	* The name of the utility application we employ to install and uninstall the
75	* extension packs. This is a set-uid-to-root binary on unixy platforms, which
76	* is why it has to be a separate application.
77	*/
78	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
79	# define VBOX_EXTPACK_HELPER_NAME "VBoxExtPackHelperApp.exe"
80	#else
81	# define VBOX_EXTPACK_HELPER_NAME "VBoxExtPackHelperApp"
82	#endif
83
84
85	/*********************************************************************************************************************************
86	* Structures and Typedefs *
87	*********************************************************************************************************************************/
88	struct ExtPackBaseData
89	{
90	public:
91	/** The extension pack descriptor (loaded from the XML, mostly). */
92	VBOXEXTPACKDESC Desc;
93	/** The file system object info of the XML file.
94	* This is for detecting changes and save time in refresh(). */
95	RTFSOBJINFO ObjInfoDesc;
96	/** Whether it's usable or not. */
97	bool fUsable;
98	/** Why it is unusable. */
99	Utf8Str strWhyUnusable;
100	};
101
102	#ifndef VBOX_COM_INPROC
103	/**
104	* Private extension pack data.
105	*/
106	struct ExtPackFile::Data : public ExtPackBaseData
107	{
108	public:
109	/** The path to the tarball. */
110	Utf8Str strExtPackFile;
111	/** The SHA-256 hash of the file (as string). */
112	Utf8Str strDigest;
113	/** The file handle of the extension pack file. */
114	RTFILE hExtPackFile;
115	/** Our manifest for the tarball. */
116	RTMANIFEST hOurManifest;
117	/** Pointer to the extension pack manager. */
118	ComObjPtr<ExtPackManager> ptrExtPackMgr;
119	/** Pointer to the VirtualBox object so we can create a progress object. */
120	VirtualBox *pVirtualBox;
121
122	RTMEMEF_NEW_AND_DELETE_OPERATORS();
123	};
124	#endif
125
126	/**
127	* Private extension pack data.
128	*/
129	struct ExtPack::Data : public ExtPackBaseData
130	{
131	public:
132	/** Where the extension pack is located. */
133	Utf8Str strExtPackPath;
134	/** The file system object info of the extension pack directory.
135	* This is for detecting changes and save time in refresh(). */
136	RTFSOBJINFO ObjInfoExtPack;
137	/** The full path to the main module. */
138	Utf8Str strMainModPath;
139	/** The file system object info of the main module.
140	* This is used to determin whether to bother try reload it. */
141	RTFSOBJINFO ObjInfoMainMod;
142	/** The module handle of the main extension pack module. */
143	RTLDRMOD hMainMod;
144
145	/** The helper callbacks for the extension pack. */
146	VBOXEXTPACKHLP Hlp;
147	/** Pointer back to the extension pack object (for Hlp methods). */
148	ExtPack *pThis;
149	#ifndef VBOX_COM_INPROC
150	/** The extension pack main registration structure. */
151	PCVBOXEXTPACKREG pReg;
152	#else
153	/** The extension pack main VM registration structure. */
154	PCVBOXEXTPACKVMREG pReg;
155	#endif
156	/** The current context. */
157	VBOXEXTPACKCTX enmContext;
158	/** Set if we've made the pfnVirtualBoxReady or pfnConsoleReady call. */
159	bool fMadeReadyCall;
160	#ifndef VBOX_COM_INPROC
161	/** Pointer to the VirtualBox object so we can create a progress object. */
162	VirtualBox *pVirtualBox;
163	#endif
164	#ifdef VBOX_WITH_MAIN_NLS
165	PTRCOMPONENT pTrComponent;
166	#endif
167
168	RTMEMEF_NEW_AND_DELETE_OPERATORS();
169	};
170
171	/** List of extension packs. */
172	typedef std::list< ComObjPtr<ExtPack> > ExtPackList;
173
174	/**
175	* Private extension pack manager data.
176	*/
177	struct ExtPackManager::Data
178	{
179	Data()
180	: cUpdate(0)
181	{}
182
183	/** The directory where the extension packs are installed. */
184	Utf8Str strBaseDir;
185	/** The directory where the certificates this installation recognizes are
186	* stored. */
187	Utf8Str strCertificatDirPath;
188	/** The list of installed extension packs. */
189	ExtPackList llInstalledExtPacks;
190	#ifndef VBOX_COM_INPROC
191	/** Pointer to the VirtualBox object, our parent. */
192	VirtualBox *pVirtualBox;
193	#endif
194	/** The current context. */
195	VBOXEXTPACKCTX enmContext;
196	/** Update counter for the installed extension packs, increased in every list update. */
197	uint64_t cUpdate;
198
199	RTMEMEF_NEW_AND_DELETE_OPERATORS();
200	};
201
202	#ifndef VBOX_COM_INPROC
203
204	/**
205	* Extension pack installation job.
206	*/
207	class ExtPackInstallTask : public ThreadTask
208	{
209	public:
210	explicit ExtPackInstallTask() : ThreadTask("ExtPackInst") { }
211	~ExtPackInstallTask() { }
212
213	DECLARE_TRANSLATE_METHODS(ExtPackInstallTask)
214
215	void handler()
216	{
217	HRESULT hrc = ptrExtPackMgr->i_doInstall(ptrExtPackFile, fReplace, &strDisplayInfo);
218	ptrProgress->i_notifyComplete(hrc);
219	}
220
221	HRESULT Init(const ComPtr<ExtPackFile> &a_strExtPackFile, bool a_fReplace,
222	const Utf8Str &strDispInfo, const ComPtr<ExtPackManager> &a_ptrExtPackMgr)
223	{
224	ptrExtPackFile = a_strExtPackFile;
225	fReplace = a_fReplace;
226	strDisplayInfo = strDispInfo;
227	ptrExtPackMgr = a_ptrExtPackMgr;
228
229	HRESULT hrc = ptrProgress.createObject();
230	if (SUCCEEDED(hrc))
231	{
232	Bstr bstrDescription(tr("Installing extension pack"));
233	hrc = ptrProgress->init(ptrExtPackFile->m->pVirtualBox,
234	static_cast<IExtPackFile *>(ptrExtPackFile),
235	bstrDescription.raw(),
236	FALSE /aCancelable/);
237	}
238
239	return hrc;
240	}
241
242	/** Smart pointer to the progress object for this job. */
243	ComObjPtr<Progress> ptrProgress;
244	private:
245	/** Smart pointer to the extension pack file. */
246	ComPtr<ExtPackFile> ptrExtPackFile;
247	/** The replace argument. */
248	bool fReplace;
249	/** The display info argument. */
250	Utf8Str strDisplayInfo;
251	/** Smart pointer to the extension manager. */
252	ComPtr<ExtPackManager> ptrExtPackMgr;
253	};
254
255	/**
256	* Extension pack uninstallation job.
257	*/
258	class ExtPackUninstallTask : public ThreadTask
259	{
260	public:
261	explicit ExtPackUninstallTask() : ThreadTask("ExtPackUninst") { }
262	~ExtPackUninstallTask() { }
263	DECLARE_TRANSLATE_METHODS(ExtPackUninstallTask)
264
265	void handler()
266	{
267	HRESULT hrc = ptrExtPackMgr->i_doUninstall(&strName, fForcedRemoval, &strDisplayInfo);
268	ptrProgress->i_notifyComplete(hrc);
269	}
270
271	HRESULT Init(const ComPtr<ExtPackManager> &a_ptrExtPackMgr, const Utf8Str &a_strName,
272	bool a_fForcedRemoval, const Utf8Str &a_strDisplayInfo)
273	{
274	ptrExtPackMgr = a_ptrExtPackMgr;
275	strName = a_strName;
276	fForcedRemoval = a_fForcedRemoval;
277	strDisplayInfo = a_strDisplayInfo;
278
279	HRESULT hrc = ptrProgress.createObject();
280	if (SUCCEEDED(hrc))
281	{
282	Bstr bstrDescription(tr("Uninstalling extension pack"));
283	hrc = ptrProgress->init(ptrExtPackMgr->m->pVirtualBox,
284	static_cast<IExtPackManager *>(ptrExtPackMgr),
285	bstrDescription.raw(),
286	FALSE /aCancelable/);
287	}
288
289	return hrc;
290	}
291
292	/** Smart pointer to the progress object for this job. */
293	ComObjPtr<Progress> ptrProgress;
294	private:
295	/** Smart pointer to the extension manager. */
296	ComPtr<ExtPackManager> ptrExtPackMgr;
297	/** The name of the extension pack. */
298	Utf8Str strName;
299	/** The replace argument. */
300	bool fForcedRemoval;
301	/** The display info argument. */
302	Utf8Str strDisplayInfo;
303	};
304
305	DEFINE_EMPTY_CTOR_DTOR(ExtPackFile)
306
307	/**
308	* Called by ComObjPtr::createObject when creating the object.
309	*
310	* Just initialize the basic object state, do the rest in initWithDir().
311	*
312	* @returns S_OK.
313	*/
314	HRESULT ExtPackFile::FinalConstruct()
315	{
316	m = NULL;
317	return BaseFinalConstruct();
318	}
319
320	/**
321	* Initializes the extension pack by reading its file.
322	*
323	* @returns COM status code.
324	* @param a_pszFile The path to the extension pack file.
325	* @param a_pszDigest The SHA-256 digest of the file. Or an empty string.
326	* @param a_pExtPackMgr Pointer to the extension pack manager.
327	* @param a_pVirtualBox Pointer to the VirtualBox object.
328	*/
329	HRESULT ExtPackFile::initWithFile(const char a_pszFile, const char a_pszDigest, ExtPackManager *a_pExtPackMgr,
330	VirtualBox *a_pVirtualBox)
331	{
332	AutoInitSpan autoInitSpan(this);
333	AssertReturn(autoInitSpan.isOk(), E_FAIL);
334
335	/*
336	* Allocate + initialize our private data.
337	*/
338	m = new ExtPackFile::Data;
339	VBoxExtPackInitDesc(&m->Desc);
340	RT_ZERO(m->ObjInfoDesc);
341	m->fUsable = false;
342	m->strWhyUnusable = tr("ExtPack::init failed");
343	m->strExtPackFile = a_pszFile;
344	m->strDigest = a_pszDigest;
345	m->hExtPackFile = NIL_RTFILE;
346	m->hOurManifest = NIL_RTMANIFEST;
347	m->ptrExtPackMgr = a_pExtPackMgr;
348	m->pVirtualBox = a_pVirtualBox;
349
350	RTCString *pstrTarName = VBoxExtPackExtractNameFromTarballPath(a_pszFile);
351	if (pstrTarName)
352	{
353	m->Desc.strName = *pstrTarName;
354	delete pstrTarName;
355	pstrTarName = NULL;
356	}
357
358	autoInitSpan.setSucceeded();
359
360	/*
361	* Try open the extension pack and check that it is a regular file.
362	*/
363	int vrc = RTFileOpen(&m->hExtPackFile, a_pszFile,
364	RTFILE_O_READ \| RTFILE_O_DENY_WRITE \| RTFILE_O_OPEN);
365	if (RT_FAILURE(vrc))
366	{
367	if (vrc == VERR_FILE_NOT_FOUND \|\| vrc == VERR_PATH_NOT_FOUND)
368	return initFailed(tr("'%s' file not found"), a_pszFile);
369	return initFailed(tr("RTFileOpen('%s',,) failed with %Rrc"), a_pszFile, vrc);
370	}
371
372	RTFSOBJINFO ObjInfo;
373	vrc = RTFileQueryInfo(m->hExtPackFile, &ObjInfo, RTFSOBJATTRADD_UNIX);
374	if (RT_FAILURE(vrc))
375	return initFailed(tr("RTFileQueryInfo failed with %Rrc on '%s'"), vrc, a_pszFile);
376	if (!RTFS_IS_FILE(ObjInfo.Attr.fMode))
377	return initFailed(tr("Not a regular file: %s"), a_pszFile);
378
379	/*
380	* Validate the tarball and extract the XML file.
381	*/
382	char szError[8192];
383	RTVFSFILE hXmlFile;
384	vrc = VBoxExtPackValidateTarball(m->hExtPackFile, NULL /pszExtPackName/, a_pszFile, a_pszDigest,
385	szError, sizeof(szError), &m->hOurManifest, &hXmlFile, &m->strDigest);
386	if (RT_FAILURE(vrc))
387	return initFailed("%s", szError);
388
389	/*
390	* Parse the XML.
391	*/
392	RTCString strSavedName(m->Desc.strName);
393	RTCString *pStrLoadErr = VBoxExtPackLoadDescFromVfsFile(hXmlFile, &m->Desc, &m->ObjInfoDesc);
394	RTVfsFileRelease(hXmlFile);
395	if (pStrLoadErr != NULL)
396	{
397	m->strWhyUnusable.printf(tr("Failed to the xml file: %s"), pStrLoadErr->c_str());
398	m->Desc.strName = strSavedName;
399	delete pStrLoadErr;
400	return S_OK;
401	}
402
403	/*
404	* Match the tarball name with the name from the XML.
405	*/
406	/** @todo drop this restriction after the old install interface is
407	* dropped. */
408	if (!strSavedName.equalsIgnoreCase(m->Desc.strName))
409	return initFailed(tr("Extension pack name mismatch between the downloaded file and the XML inside it (xml='%s' file='%s')"),
410	m->Desc.strName.c_str(), strSavedName.c_str());
411
412
413	m->fUsable = true;
414	m->strWhyUnusable.setNull();
415	return S_OK;
416	}
417
418	/**
419	* Protected helper that formats the strWhyUnusable value.
420	*
421	* @returns S_OK
422	* @param a_pszWhyFmt Why it failed, format string.
423	* @param ... The format arguments.
424	*/
425	HRESULT ExtPackFile::initFailed(const char *a_pszWhyFmt, ...)
426	{
427	va_list va;
428	va_start(va, a_pszWhyFmt);
429	m->strWhyUnusable.printfV(a_pszWhyFmt, va);
430	va_end(va);
431	return S_OK;
432	}
433
434	/**
435	* COM cruft.
436	*/
437	void ExtPackFile::FinalRelease()
438	{
439	uninit();
440	BaseFinalRelease();
441	}
442
443	/**
444	* Do the actual cleanup.
445	*/
446	void ExtPackFile::uninit()
447	{
448	/* Enclose the state transition Ready->InUninit->NotReady */
449	AutoUninitSpan autoUninitSpan(this);
450	if (!autoUninitSpan.uninitDone() && m != NULL)
451	{
452	VBoxExtPackFreeDesc(&m->Desc);
453	RTFileClose(m->hExtPackFile);
454	m->hExtPackFile = NIL_RTFILE;
455	RTManifestRelease(m->hOurManifest);
456	m->hOurManifest = NIL_RTMANIFEST;
457
458	delete m;
459	m = NULL;
460	}
461	}
462
463	HRESULT ExtPackFile::getName(com::Utf8Str &aName)
464	{
465	aName = m->Desc.strName;
466	return S_OK;
467	}
468
469	HRESULT ExtPackFile::getDescription(com::Utf8Str &aDescription)
470	{
471	aDescription = m->Desc.strDescription;
472	return S_OK;
473	}
474
475	HRESULT ExtPackFile::getVersion(com::Utf8Str &aVersion)
476	{
477	aVersion = m->Desc.strVersion;
478	return S_OK;
479	}
480
481	HRESULT ExtPackFile::getEdition(com::Utf8Str &aEdition)
482	{
483	aEdition = m->Desc.strEdition;
484	return S_OK;
485	}
486
487	HRESULT ExtPackFile::getRevision(ULONG *aRevision)
488	{
489	*aRevision = m->Desc.uRevision;
490	return S_OK;
491	}
492
493	HRESULT ExtPackFile::getVRDEModule(com::Utf8Str &aVRDEModule)
494	{
495	aVRDEModule = m->Desc.strVrdeModule;
496	return S_OK;
497	}
498
499	HRESULT ExtPackFile::getCryptoModule(com::Utf8Str &aCryptoModule)
500	{
501	aCryptoModule = m->Desc.strCryptoModule;
502	return S_OK;
503	}
504
505	HRESULT ExtPackFile::getPlugIns(std::vector<ComPtr<IExtPackPlugIn> > &aPlugIns)
506	{
507	/** @todo implement plug-ins. */
508	#ifdef VBOX_WITH_XPCOM
509	NOREF(aPlugIns);
510	#endif
511	NOREF(aPlugIns);
512	ReturnComNotImplemented();
513	}
514
515	HRESULT ExtPackFile::getUsable(BOOL *aUsable)
516	{
517	*aUsable = m->fUsable;
518	return S_OK;
519	}
520
521	HRESULT ExtPackFile::getWhyUnusable(com::Utf8Str &aWhyUnusable)
522	{
523	aWhyUnusable = m->strWhyUnusable;
524	return S_OK;
525	}
526
527	HRESULT ExtPackFile::getShowLicense(BOOL *aShowLicense)
528	{
529	*aShowLicense = m->Desc.fShowLicense;
530	return S_OK;
531	}
532
533	HRESULT ExtPackFile::getLicense(com::Utf8Str &aLicense)
534	{
535	Utf8Str strHtml("html");
536	Utf8Str str("");
537	return queryLicense(str, str, strHtml, aLicense);
538	}
539
540	/* Same as ExtPack::QueryLicense, should really explore the subject of base classes here... */
541	HRESULT ExtPackFile::queryLicense(const com::Utf8Str &aPreferredLocale, const com::Utf8Str &aPreferredLanguage,
542	const com::Utf8Str &aFormat, com::Utf8Str &aLicenseText)
543	{
544	HRESULT hrc = S_OK;
545
546	/*
547	* Validate input.
548	*/
549
550	if (aPreferredLocale.length() != 2 && aPreferredLocale.length() != 0)
551	return setError(E_FAIL, tr("The preferred locale is a two character string or empty."));
552
553	if (aPreferredLanguage.length() != 2 && aPreferredLanguage.length() != 0)
554	return setError(E_FAIL, tr("The preferred language is a two character string or empty."));
555
556	if ( !aFormat.equals("html")
557	&& !aFormat.equals("rtf")
558	&& !aFormat.equals("txt"))
559	return setError(E_FAIL, tr("The license format can only have the values 'html', 'rtf' and 'txt'."));
560
561	/*
562	* Combine the options to form a file name before locking down anything.
563	*/
564	char szName[sizeof(VBOX_EXTPACK_LICENSE_NAME_PREFIX "-de_DE.html") + 2];
565	if (aPreferredLocale.isNotEmpty() && aPreferredLanguage.isNotEmpty())
566	RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX "-%s_%s.%s",
567	aPreferredLocale.c_str(), aPreferredLanguage.c_str(), aFormat.c_str());
568	else if (aPreferredLocale.isNotEmpty())
569	RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX "-%s.%s",
570	aPreferredLocale.c_str(), aFormat.c_str());
571	else if (aPreferredLanguage.isNotEmpty())
572	RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX "-_%s.%s",
573	aPreferredLocale.c_str(), aFormat.c_str());
574	else
575	RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX ".%s",
576	aFormat.c_str());
577	/*
578	* Lock the extension pack. We need a write lock here as there must not be
579	* concurrent accesses to the tar file handle.
580	*/
581	AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS);
582
583	/*
584	* Do not permit this query on a pack that isn't considered usable (could
585	* be marked so because of bad license files).
586	*/
587	if (!m->fUsable)
588	hrc = setError(E_FAIL, "%s", m->strWhyUnusable.c_str());
589	else
590	{
591	/*
592	* Look it up in the manifest before scanning the tarball for it
593	*/
594	if (RTManifestEntryExists(m->hOurManifest, szName))
595	{
596	RTVFSFSSTREAM hTarFss;
597	char szError[8192];
598	int vrc = VBoxExtPackOpenTarFss(m->hExtPackFile, szError, sizeof(szError), &hTarFss, NULL);
599	if (RT_SUCCESS(vrc))
600	{
601	for (;;)
602	{
603	/* Get the first/next. */
604	char *pszName;
605	RTVFSOBJ hVfsObj;
606	RTVFSOBJTYPE enmType;
607	vrc = RTVfsFsStrmNext(hTarFss, &pszName, &enmType, &hVfsObj);
608	if (RT_FAILURE(vrc))
609	{
610	if (vrc != VERR_EOF)
611	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("RTVfsFsStrmNext failed: %Rrc"), vrc);
612	else
613	hrc = setErrorBoth(E_UNEXPECTED, vrc, tr("'%s' was found in the manifest but not in the tarball"), szName);
614	break;
615	}
616
617	/* Is this it? */
618	const char *pszAdjName = pszName[0] == '.' && pszName[1] == '/' ? &pszName[2] : pszName;
619	if ( !strcmp(pszAdjName, szName)
620	&& ( enmType == RTVFSOBJTYPE_IO_STREAM
621	\|\| enmType == RTVFSOBJTYPE_FILE))
622	{
623	RTVFSIOSTREAM hVfsIos = RTVfsObjToIoStream(hVfsObj);
624	RTVfsObjRelease(hVfsObj);
625	RTStrFree(pszName);
626
627	/* Load the file into memory. */
628	RTFSOBJINFO ObjInfo;
629	vrc = RTVfsIoStrmQueryInfo(hVfsIos, &ObjInfo, RTFSOBJATTRADD_NOTHING);
630	if (RT_SUCCESS(vrc))
631	{
632	size_t cbFile = (size_t)ObjInfo.cbObject;
633	void *pvFile = RTMemAllocZ(cbFile + 1);
634	if (pvFile)
635	{
636	vrc = RTVfsIoStrmRead(hVfsIos, pvFile, cbFile, true /fBlocking/, NULL);
637	if (RT_SUCCESS(vrc))
638	{
639	/* try translate it into a string we can return. */
640	Bstr bstrLicense((const char *)pvFile, cbFile);
641	if (bstrLicense.isNotEmpty())
642	{
643	aLicenseText = Utf8Str(bstrLicense);
644	hrc = S_OK;
645	}
646	else
647	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
648	tr("The license file '%s' is empty or contains invalid UTF-8 encoding"),
649	szName);
650	}
651	else
652	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Failed to read '%s': %Rrc"), szName, vrc);
653	RTMemFree(pvFile);
654	}
655	else
656	hrc = setError(E_OUTOFMEMORY, tr("Failed to allocate %zu bytes for '%s'", "", cbFile),
657	cbFile, szName);
658	}
659	else
660	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("RTVfsIoStrmQueryInfo on '%s': %Rrc"), szName, vrc);
661	RTVfsIoStrmRelease(hVfsIos);
662	break;
663	}
664
665	/* Release current. */
666	RTVfsObjRelease(hVfsObj);
667	RTStrFree(pszName);
668	}
669	RTVfsFsStrmRelease(hTarFss);
670	}
671	else
672	hrc = setError(VBOX_E_OBJECT_NOT_FOUND, "%s", szError);
673	}
674	else
675	hrc = setError(VBOX_E_OBJECT_NOT_FOUND, tr("The license file '%s' was not found in '%s'"),
676	szName, m->strExtPackFile.c_str());
677	}
678	return hrc;
679	}
680
681	HRESULT ExtPackFile::getFilePath(com::Utf8Str &aFilePath)
682	{
683
684	aFilePath = m->strExtPackFile;
685	return S_OK;
686	}
687
688	HRESULT ExtPackFile::install(BOOL aReplace, const com::Utf8Str &aDisplayInfo, ComPtr<IProgress> &aProgress)
689	{
690	HRESULT hrc;
691	if (m->fUsable)
692	{
693	ExtPackInstallTask *pTask = NULL;
694	try
695	{
696	pTask = new ExtPackInstallTask();
697	hrc = pTask->Init(this, aReplace != FALSE, aDisplayInfo, m->ptrExtPackMgr);
698	if (SUCCEEDED(hrc))
699	{
700	ComPtr<Progress> ptrProgress = pTask->ptrProgress;
701	hrc = pTask->createThreadWithType(RTTHREADTYPE_DEFAULT);
702	pTask = NULL; /* The _completely_ _undocumented_ createThread method always consumes pTask. */
703	if (SUCCEEDED(hrc))
704	hrc = ptrProgress.queryInterfaceTo(aProgress.asOutParam());
705	else
706	hrc = setError(VBOX_E_IPRT_ERROR,
707	tr("Starting thread for an extension pack installation failed with %Rrc"), hrc);
708	}
709	else
710	hrc = setError(VBOX_E_IPRT_ERROR,
711	tr("Looks like creating a progress object for ExtraPackInstallTask object failed"));
712	}
713	catch (std::bad_alloc &)
714	{
715	hrc = E_OUTOFMEMORY;
716	}
717	catch (HRESULT hrcXcpt)
718	{
719	LogFlowThisFunc(("Exception was caught in the function ExtPackFile::install() \n"));
720	hrc = hrcXcpt;
721	}
722	if (pTask)
723	delete pTask;
724	}
725	else
726	hrc = setError(E_FAIL, "%s", m->strWhyUnusable.c_str());
727	return hrc;
728	}
729
730	#endif /* !VBOX_COM_INPROC */
731
732
733
734
735	DEFINE_EMPTY_CTOR_DTOR(ExtPack)
736
737	/**
738	* Called by ComObjPtr::createObject when creating the object.
739	*
740	* Just initialize the basic object state, do the rest in initWithDir().
741	*
742	* @returns S_OK.
743	*/
744	HRESULT ExtPack::FinalConstruct()
745	{
746	m = NULL;
747	return BaseFinalConstruct();
748	}
749
750	/**
751	* Initializes the extension pack by reading its file.
752	*
753	* @returns COM status code.
754	* @param a_pVirtualBox The VirtualBox object.
755	* @param a_enmContext The context we're in.
756	* @param a_pszName The name of the extension pack. This is also the
757	* name of the subdirector under @a a_pszParentDir
758	* where the extension pack is installed.
759	* @param a_pszDir The extension pack directory name.
760	*/
761	HRESULT ExtPack::initWithDir(VirtualBox a_pVirtualBox, VBOXEXTPACKCTX a_enmContext, const char a_pszName, const char *a_pszDir)
762	{
763	AutoInitSpan autoInitSpan(this);
764	AssertReturn(autoInitSpan.isOk(), E_FAIL);
765
766	static const VBOXEXTPACKHLP s_HlpTmpl =
767	{
768	/* u32Version = */ VBOXEXTPACKHLP_VERSION,
769	/* uVBoxFullVersion = */ VBOX_FULL_VERSION,
770	/* uVBoxVersionRevision = */ 0,
771	/* u32Padding = */ 0,
772	/* pszVBoxVersion = */ "",
773	/* pfnFindModule = */ ExtPack::i_hlpFindModule,
774	/* pfnGetFilePath = */ ExtPack::i_hlpGetFilePath,
775	/* pfnGetContext = */ ExtPack::i_hlpGetContext,
776	/* pfnLoadHGCMService = */ ExtPack::i_hlpLoadHGCMService,
777	/* pfnLoadVDPlugin = */ ExtPack::i_hlpLoadVDPlugin,
778	/* pfnUnloadVDPlugin = */ ExtPack::i_hlpUnloadVDPlugin,
779	/* pfnCreateProgress = */ ExtPack::i_hlpCreateProgress,
780	/* pfnGetCanceledProgress = */ ExtPack::i_hlpGetCanceledProgress,
781	/* pfnUpdateProgress = */ ExtPack::i_hlpUpdateProgress,
782	/* pfnNextOperationProgress = */ ExtPack::i_hlpNextOperationProgress,
783	/* pfnWaitOtherProgress = */ ExtPack::i_hlpWaitOtherProgress,
784	/* pfnCompleteProgress = */ ExtPack::i_hlpCompleteProgress,
785	/* pfnCreateEvent = */ ExtPack::i_hlpCreateEvent,
786	/* pfnCreateVetoEvent = */ ExtPack::i_hlpCreateVetoEvent,
787	/* pfnTranslate = */ ExtPack::i_hlpTranslate,
788	/* pfnReserved1 = */ ExtPack::i_hlpReservedN,
789	/* pfnReserved2 = */ ExtPack::i_hlpReservedN,
790	/* pfnReserved3 = */ ExtPack::i_hlpReservedN,
791	/* pfnReserved4 = */ ExtPack::i_hlpReservedN,
792	/* pfnReserved5 = */ ExtPack::i_hlpReservedN,
793	/* pfnReserved6 = */ ExtPack::i_hlpReservedN,
794	/* uReserved7 = */ 0,
795	/* u32EndMarker = */ VBOXEXTPACKHLP_VERSION
796	};
797
798	/*
799	* Allocate + initialize our private data.
800	*/
801	m = new Data;
802	VBoxExtPackInitDesc(&m->Desc);
803	m->Desc.strName = a_pszName;
804	RT_ZERO(m->ObjInfoDesc);
805	m->fUsable = false;
806	m->strWhyUnusable = tr("ExtPack::init failed");
807	m->strExtPackPath = a_pszDir;
808	RT_ZERO(m->ObjInfoExtPack);
809	m->strMainModPath.setNull();
810	RT_ZERO(m->ObjInfoMainMod);
811	m->hMainMod = NIL_RTLDRMOD;
812	m->Hlp = s_HlpTmpl;
813	m->Hlp.pszVBoxVersion = RTBldCfgVersion();
814	m->Hlp.uVBoxInternalRevision = RTBldCfgRevision();
815	m->pThis = this;
816	m->pReg = NULL;
817	m->enmContext = a_enmContext;
818	m->fMadeReadyCall = false;
819	#ifndef VBOX_COM_INPROC
820	m->pVirtualBox = a_pVirtualBox;
821	#else
822	RT_NOREF(a_pVirtualBox);
823	#endif
824	#ifdef VBOX_WITH_MAIN_NLS
825	m->pTrComponent = NULL;
826	#endif
827	/*
828	* Make sure the SUPR3Hardened API works (ignoring errors for now).
829	*/
830	int vrc = SUPR3HardenedVerifyInit();
831	if (RT_FAILURE(vrc))
832	LogRel(("SUPR3HardenedVerifyInit failed: %Rrc\n", vrc));
833
834	/*
835	* Probe the extension pack (this code is shared with refresh()).
836	*/
837	i_probeAndLoad();
838
839	#ifdef VBOX_WITH_MAIN_NLS
840	/* register language files if exist */
841	if (m->pReg != NULL && m->pReg->pszNlsBaseName != NULL)
842	{
843	char szPath[RTPATH_MAX];
844	vrc = RTPathJoin(szPath, sizeof(szPath), a_pszDir, "nls");
845	if (RT_SUCCESS(vrc))
846	{
847	vrc = RTPathAppend(szPath, sizeof(szPath), m->pReg->pszNlsBaseName);
848	if (RT_SUCCESS(vrc))
849	{
850	vrc = VirtualBoxTranslator::registerTranslation(szPath, false, &m->pTrComponent);
851	if (RT_FAILURE(vrc))
852	m->pTrComponent = NULL;
853	}
854	}
855	}
856	#endif
857
858	autoInitSpan.setSucceeded();
859	return S_OK;
860	}
861
862	/**
863	* COM cruft.
864	*/
865	void ExtPack::FinalRelease()
866	{
867	uninit();
868	BaseFinalRelease();
869	}
870
871	/**
872	* Do the actual cleanup.
873	*/
874	void ExtPack::uninit()
875	{
876	/* Enclose the state transition Ready->InUninit->NotReady */
877	AutoUninitSpan autoUninitSpan(this);
878	if (!autoUninitSpan.uninitDone() && m != NULL)
879	{
880	if (m->hMainMod != NIL_RTLDRMOD)
881	{
882	AssertPtr(m->pReg);
883	if (m->pReg->pfnUnload != NULL)
884	m->pReg->pfnUnload(m->pReg);
885
886	RTLdrClose(m->hMainMod);
887	m->hMainMod = NIL_RTLDRMOD;
888	m->pReg = NULL;
889	}
890
891	VBoxExtPackFreeDesc(&m->Desc);
892
893	#ifdef VBOX_WITH_MAIN_NLS
894	if (m->pTrComponent != NULL)
895	VirtualBoxTranslator::unregisterTranslation(m->pTrComponent);
896	#endif
897	delete m;
898	m = NULL;
899	}
900	}
901
902
903	#ifndef VBOX_COM_INPROC
904	/**
905	* Calls the installed hook.
906	*
907	* @returns true if we left the lock, false if we didn't.
908	* @param a_pVirtualBox The VirtualBox interface.
909	* @param a_pLock The write lock held by the caller.
910	* @param pErrInfo Where to return error information.
911	*/
912	bool ExtPack::i_callInstalledHook(IVirtualBox a_pVirtualBox, AutoWriteLock a_pLock, PRTERRINFO pErrInfo)
913	{
914	if ( m != NULL
915	&& m->hMainMod != NIL_RTLDRMOD)
916	{
917	if (m->pReg->pfnInstalled)
918	{
919	ComPtr<ExtPack> ptrSelfRef = this;
920	a_pLock->release();
921	pErrInfo->rc = m->pReg->pfnInstalled(m->pReg, a_pVirtualBox, pErrInfo);
922	a_pLock->acquire();
923	return true;
924	}
925	}
926	pErrInfo->rc = VINF_SUCCESS;
927	return false;
928	}
929
930	/**
931	* Calls the uninstall hook and closes the module.
932	*
933	* @returns S_OK or COM error status with error information.
934	* @param a_pVirtualBox The VirtualBox interface.
935	* @param a_fForcedRemoval When set, we'll ignore complaints from the
936	* uninstall hook.
937	* @remarks The caller holds the manager's write lock, not released.
938	*/
939	HRESULT ExtPack::i_callUninstallHookAndClose(IVirtualBox *a_pVirtualBox, bool a_fForcedRemoval)
940	{
941	HRESULT hrc = S_OK;
942
943	if ( m != NULL
944	&& m->hMainMod != NIL_RTLDRMOD)
945	{
946	if (m->pReg->pfnUninstall && !a_fForcedRemoval)
947	{
948	int vrc = m->pReg->pfnUninstall(m->pReg, a_pVirtualBox);
949	if (RT_FAILURE(vrc))
950	{
951	LogRel(("ExtPack pfnUninstall returned %Rrc for %s\n", vrc, m->Desc.strName.c_str()));
952	if (!a_fForcedRemoval)
953	hrc = setErrorBoth(E_FAIL, vrc, tr("pfnUninstall returned %Rrc"), vrc);
954	}
955	}
956	if (SUCCEEDED(hrc))
957	{
958	RTLdrClose(m->hMainMod);
959	m->hMainMod = NIL_RTLDRMOD;
960	m->pReg = NULL;
961	}
962	}
963
964	return hrc;
965	}
966
967	/**
968	* Calls the pfnVirtualBoxReady hook.
969	*
970	* @returns true if we left the lock, false if we didn't.
971	* @param a_pVirtualBox The VirtualBox interface.
972	* @param a_pLock The write lock held by the caller.
973	*/
974	bool ExtPack::i_callVirtualBoxReadyHook(IVirtualBox a_pVirtualBox, AutoWriteLock a_pLock)
975	{
976	if ( m != NULL
977	&& m->fUsable
978	&& m->hMainMod != NIL_RTLDRMOD
979	&& !m->fMadeReadyCall)
980	{
981	m->fMadeReadyCall = true;
982	if (m->pReg->pfnVirtualBoxReady)
983	{
984	ComPtr<ExtPack> ptrSelfRef = this;
985	a_pLock->release();
986	m->pReg->pfnVirtualBoxReady(m->pReg, a_pVirtualBox);
987	i_notifyCloudProviderManager();
988	a_pLock->acquire();
989	return true;
990	}
991	}
992	return false;
993	}
994	#endif /* !VBOX_COM_INPROC */
995
996	#ifdef VBOX_COM_INPROC
997	/**
998	* Calls the pfnConsoleReady hook.
999	*
1000	* @returns true if we left the lock, false if we didn't.
1001	* @param a_pConsole The Console interface.
1002	* @param a_pLock The write lock held by the caller.
1003	*/
1004	bool ExtPack::i_callConsoleReadyHook(IConsole a_pConsole, AutoWriteLock a_pLock)
1005	{
1006	if ( m != NULL
1007	&& m->fUsable
1008	&& m->hMainMod != NIL_RTLDRMOD
1009	&& !m->fMadeReadyCall)
1010	{
1011	m->fMadeReadyCall = true;
1012	if (m->pReg->pfnConsoleReady)
1013	{
1014	ComPtr<ExtPack> ptrSelfRef = this;
1015	a_pLock->release();
1016	m->pReg->pfnConsoleReady(m->pReg, a_pConsole);
1017	a_pLock->acquire();
1018	return true;
1019	}
1020	}
1021	return false;
1022	}
1023	#endif /* VBOX_COM_INPROC */
1024
1025	#ifndef VBOX_COM_INPROC
1026	/**
1027	* Calls the pfnVMCreate hook.
1028	*
1029	* @returns true if we left the lock, false if we didn't.
1030	* @param a_pVirtualBox The VirtualBox interface.
1031	* @param a_pMachine The machine interface of the new VM.
1032	* @param a_pLock The write lock held by the caller.
1033	*/
1034	bool ExtPack::i_callVmCreatedHook(IVirtualBox a_pVirtualBox, IMachine a_pMachine, AutoWriteLock *a_pLock)
1035	{
1036	if ( m != NULL
1037	&& m->hMainMod != NIL_RTLDRMOD
1038	&& m->fUsable)
1039	{
1040	if (m->pReg->pfnVMCreated)
1041	{
1042	ComPtr<ExtPack> ptrSelfRef = this;
1043	a_pLock->release();
1044	m->pReg->pfnVMCreated(m->pReg, a_pVirtualBox, a_pMachine);
1045	a_pLock->acquire();
1046	return true;
1047	}
1048	}
1049	return false;
1050	}
1051	#endif /* !VBOX_COM_INPROC */
1052
1053	#ifdef VBOX_COM_INPROC
1054
1055	/**
1056	* Calls the pfnVMConfigureVMM hook.
1057	*
1058	* @returns true if we left the lock, false if we didn't.
1059	* @param a_pConsole The console interface.
1060	* @param a_pVM The VM handle.
1061	* @param a_pVMM The VMM function table.
1062	* @param a_pLock The write lock held by the caller.
1063	* @param a_pvrc Where to return the status code of the callback. This
1064	* is always set. LogRel is called on if a failure status
1065	* is returned.
1066	*/
1067	bool ExtPack::i_callVmConfigureVmmHook(IConsole a_pConsole, PVM a_pVM, PCVMMR3VTABLE a_pVMM, AutoWriteLock a_pLock, int *a_pvrc)
1068	{
1069	*a_pvrc = VINF_SUCCESS;
1070	if ( m != NULL
1071	&& m->hMainMod != NIL_RTLDRMOD
1072	&& m->fUsable)
1073	{
1074	if (m->pReg->pfnVMConfigureVMM)
1075	{
1076	ComPtr<ExtPack> ptrSelfRef = this;
1077	a_pLock->release();
1078	int vrc = m->pReg->pfnVMConfigureVMM(m->pReg, a_pConsole, a_pVM, a_pVMM);
1079	*a_pvrc = vrc;
1080	a_pLock->acquire();
1081	if (RT_FAILURE(vrc))
1082	LogRel(("ExtPack pfnVMConfigureVMM returned %Rrc for %s\n", vrc, m->Desc.strName.c_str()));
1083	return true;
1084	}
1085	}
1086	return false;
1087	}
1088
1089	/**
1090	* Calls the pfnVMPowerOn hook.
1091	*
1092	* @returns true if we left the lock, false if we didn't.
1093	* @param a_pConsole The console interface.
1094	* @param a_pVM The VM handle.
1095	* @param a_pVMM The VMM function table.
1096	* @param a_pLock The write lock held by the caller.
1097	* @param a_pvrc Where to return the status code of the callback. This
1098	* is always set. LogRel is called on if a failure status
1099	* is returned.
1100	*/
1101	bool ExtPack::i_callVmPowerOnHook(IConsole a_pConsole, PVM a_pVM, PCVMMR3VTABLE a_pVMM, AutoWriteLock a_pLock, int *a_pvrc)
1102	{
1103	*a_pvrc = VINF_SUCCESS;
1104	if ( m != NULL
1105	&& m->hMainMod != NIL_RTLDRMOD
1106	&& m->fUsable)
1107	{
1108	if (m->pReg->pfnVMPowerOn)
1109	{
1110	ComPtr<ExtPack> ptrSelfRef = this;
1111	a_pLock->release();
1112	int vrc = m->pReg->pfnVMPowerOn(m->pReg, a_pConsole, a_pVM, a_pVMM);
1113	*a_pvrc = vrc;
1114	a_pLock->acquire();
1115	if (RT_FAILURE(vrc))
1116	LogRel(("ExtPack pfnVMPowerOn returned %Rrc for %s\n", vrc, m->Desc.strName.c_str()));
1117	return true;
1118	}
1119	}
1120	return false;
1121	}
1122
1123	/**
1124	* Calls the pfnVMPowerOff hook.
1125	*
1126	* @returns true if we left the lock, false if we didn't.
1127	* @param a_pConsole The console interface.
1128	* @param a_pVM The VM handle.
1129	* @param a_pVMM The VMM function table.
1130	* @param a_pLock The write lock held by the caller.
1131	*/
1132	bool ExtPack::i_callVmPowerOffHook(IConsole a_pConsole, PVM a_pVM, PCVMMR3VTABLE a_pVMM, AutoWriteLock a_pLock)
1133	{
1134	if ( m != NULL
1135	&& m->hMainMod != NIL_RTLDRMOD
1136	&& m->fUsable)
1137	{
1138	if (m->pReg->pfnVMPowerOff)
1139	{
1140	ComPtr<ExtPack> ptrSelfRef = this;
1141	a_pLock->release();
1142	m->pReg->pfnVMPowerOff(m->pReg, a_pConsole, a_pVM, a_pVMM);
1143	a_pLock->acquire();
1144	return true;
1145	}
1146	}
1147	return false;
1148	}
1149
1150	#endif /* VBOX_COM_INPROC */
1151
1152	/**
1153	* Check if the extension pack is usable and has an VRDE module.
1154	*
1155	* @returns S_OK or COM error status with error information.
1156	*
1157	* @remarks Caller holds the extension manager lock for reading, no locking
1158	* necessary.
1159	*/
1160	HRESULT ExtPack::i_checkVrde(void)
1161	{
1162	HRESULT hrc;
1163	if ( m != NULL
1164	&& m->fUsable)
1165	{
1166	if (m->Desc.strVrdeModule.isNotEmpty())
1167	hrc = S_OK;
1168	else
1169	hrc = setError(E_FAIL, tr("The extension pack '%s' does not include a VRDE module"), m->Desc.strName.c_str());
1170	}
1171	else
1172	hrc = setError(E_FAIL, "%s", m->strWhyUnusable.c_str());
1173	return hrc;
1174	}
1175
1176	/**
1177	* Check if the extension pack is usable and has a cryptographic module.
1178	*
1179	* @returns S_OK or COM error status with error information.
1180	*
1181	* @remarks Caller holds the extension manager lock for reading, no locking
1182	* necessary.
1183	*/
1184	HRESULT ExtPack::i_checkCrypto(void)
1185	{
1186	HRESULT hrc;
1187	if ( m != NULL
1188	&& m->fUsable)
1189	{
1190	if (m->Desc.strCryptoModule.isNotEmpty())
1191	hrc = S_OK;
1192	else
1193	hrc = setError(E_FAIL, tr("The extension pack '%s' does not include a cryptographic module"), m->Desc.strName.c_str());
1194	}
1195	else
1196	hrc = setError(E_FAIL, "%s", m->strWhyUnusable.c_str());
1197	return hrc;
1198	}
1199
1200	/**
1201	* Same as checkVrde(), except that it also resolves the path to the module.
1202	*
1203	* @returns S_OK or COM error status with error information.
1204	* @param a_pstrVrdeLibrary Where to return the path on success.
1205	*
1206	* @remarks Caller holds the extension manager lock for reading, no locking
1207	* necessary.
1208	*/
1209	HRESULT ExtPack::i_getVrdpLibraryName(Utf8Str *a_pstrVrdeLibrary)
1210	{
1211	HRESULT hrc = i_checkVrde();
1212	if (SUCCEEDED(hrc))
1213	{
1214	if (i_findModule(m->Desc.strVrdeModule.c_str(), NULL, VBOXEXTPACKMODKIND_R3,
1215	a_pstrVrdeLibrary, NULL /a_pfNative/, NULL /a_pObjInfo/))
1216	hrc = S_OK;
1217	else
1218	hrc = setError(E_FAIL, tr("Failed to locate the VRDE module '%s' in extension pack '%s'"),
1219	m->Desc.strVrdeModule.c_str(), m->Desc.strName.c_str());
1220	}
1221	return hrc;
1222	}
1223
1224	/**
1225	* Same as i_checkCrypto(), except that it also resolves the path to the module.
1226	*
1227	* @returns S_OK or COM error status with error information.
1228	* @param a_pstrCryptoLibrary Where to return the path on success.
1229	*
1230	* @remarks Caller holds the extension manager lock for reading, no locking
1231	* necessary.
1232	*/
1233	HRESULT ExtPack::i_getCryptoLibraryName(Utf8Str *a_pstrCryptoLibrary)
1234	{
1235	HRESULT hrc = i_checkCrypto();
1236	if (SUCCEEDED(hrc))
1237	{
1238	if (i_findModule(m->Desc.strCryptoModule.c_str(), NULL, VBOXEXTPACKMODKIND_R3,
1239	a_pstrCryptoLibrary, NULL /a_pfNative/, NULL /a_pObjInfo/))
1240	hrc = S_OK;
1241	else
1242	hrc = setError(E_FAIL, tr("Failed to locate the cryptographic module '%s' in extension pack '%s'"),
1243	m->Desc.strCryptoModule.c_str(), m->Desc.strName.c_str());
1244	}
1245	return hrc;
1246	}
1247
1248	/**
1249	* Resolves the path to the module.
1250	*
1251	* @returns S_OK or COM error status with error information.
1252	* @param a_pszModuleName The library.
1253	* @param a_pstrLibrary Where to return the path on success.
1254	*
1255	* @remarks Caller holds the extension manager lock for reading, no locking
1256	* necessary.
1257	*/
1258	HRESULT ExtPack::i_getLibraryName(const char a_pszModuleName, Utf8Str a_pstrLibrary)
1259	{
1260	HRESULT hrc;
1261	if (i_findModule(a_pszModuleName, NULL, VBOXEXTPACKMODKIND_R3,
1262	a_pstrLibrary, NULL /a_pfNative/, NULL /a_pObjInfo/))
1263	hrc = S_OK;
1264	else
1265	hrc = setError(E_FAIL, tr("Failed to locate the module '%s' in extension pack '%s'"),
1266	a_pszModuleName, m->Desc.strName.c_str());
1267	return hrc;
1268	}
1269
1270	/**
1271	* Check if this extension pack wishes to be the default VRDE provider.
1272	*
1273	* @returns @c true if it wants to and it is in a usable state, otherwise
1274	* @c false.
1275	*
1276	* @remarks Caller holds the extension manager lock for reading, no locking
1277	* necessary.
1278	*/
1279	bool ExtPack::i_wantsToBeDefaultVrde(void) const
1280	{
1281	return m->fUsable
1282	&& m->Desc.strVrdeModule.isNotEmpty();
1283	}
1284
1285	/**
1286	* Check if this extension pack wishes to be the default cryptographic provider.
1287	*
1288	* @returns @c true if it wants to and it is in a usable state, otherwise
1289	* @c false.
1290	*
1291	* @remarks Caller holds the extension manager lock for reading, no locking
1292	* necessary.
1293	*/
1294	bool ExtPack::i_wantsToBeDefaultCrypto(void) const
1295	{
1296	return m->fUsable
1297	&& m->Desc.strCryptoModule.isNotEmpty();
1298	}
1299
1300	/**
1301	* Refreshes the extension pack state.
1302	*
1303	* This is called by the manager so that the on disk changes are picked up.
1304	*
1305	* @returns S_OK or COM error status with error information.
1306	*
1307	* @param a_pfCanDelete Optional can-delete-this-object output indicator.
1308	*
1309	* @remarks Caller holds the extension manager lock for writing.
1310	* @remarks Only called in VBoxSVC.
1311	*/
1312	HRESULT ExtPack::i_refresh(bool *a_pfCanDelete)
1313	{
1314	if (a_pfCanDelete)
1315	*a_pfCanDelete = false;
1316
1317	AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS); /* for the COMGETTERs */
1318
1319	/*
1320	* Has the module been deleted?
1321	*/
1322	RTFSOBJINFO ObjInfoExtPack;
1323	int vrc = RTPathQueryInfoEx(m->strExtPackPath.c_str(), &ObjInfoExtPack, RTFSOBJATTRADD_UNIX, RTPATH_F_ON_LINK);
1324	if ( RT_FAILURE(vrc)
1325	\|\| !RTFS_IS_DIRECTORY(ObjInfoExtPack.Attr.fMode))
1326	{
1327	if (a_pfCanDelete)
1328	*a_pfCanDelete = true;
1329	return S_OK;
1330	}
1331
1332	/*
1333	* We've got a directory, so try query file system object info for the
1334	* files we are interested in as well.
1335	*/
1336	RTFSOBJINFO ObjInfoDesc;
1337	char szDescFilePath[RTPATH_MAX];
1338	vrc = RTPathJoin(szDescFilePath, sizeof(szDescFilePath), m->strExtPackPath.c_str(), VBOX_EXTPACK_DESCRIPTION_NAME);
1339	if (RT_SUCCESS(vrc))
1340	vrc = RTPathQueryInfoEx(szDescFilePath, &ObjInfoDesc, RTFSOBJATTRADD_UNIX, RTPATH_F_ON_LINK);
1341	if (RT_FAILURE(vrc))
1342	RT_ZERO(ObjInfoDesc);
1343
1344	RTFSOBJINFO ObjInfoMainMod;
1345	if (m->strMainModPath.isNotEmpty())
1346	vrc = RTPathQueryInfoEx(m->strMainModPath.c_str(), &ObjInfoMainMod, RTFSOBJATTRADD_UNIX, RTPATH_F_ON_LINK);
1347	if (m->strMainModPath.isEmpty() \|\| RT_FAILURE(vrc))
1348	RT_ZERO(ObjInfoMainMod);
1349
1350	/*
1351	* If we have a usable module already, just verify that things haven't
1352	* changed since we loaded it.
1353	*/
1354	if (m->fUsable)
1355	{
1356	if (m->hMainMod == NIL_RTLDRMOD)
1357	i_probeAndLoad();
1358	else if ( !i_objinfoIsEqual(&ObjInfoDesc, &m->ObjInfoDesc)
1359	\|\| !i_objinfoIsEqual(&ObjInfoMainMod, &m->ObjInfoMainMod)
1360	\|\| !i_objinfoIsEqual(&ObjInfoExtPack, &m->ObjInfoExtPack) )
1361	{
1362	/** @todo not important, so it can wait. */
1363	}
1364	}
1365	/*
1366	* Ok, it is currently not usable. If anything has changed since last time
1367	* reprobe the extension pack.
1368	*/
1369	else if ( !i_objinfoIsEqual(&ObjInfoDesc, &m->ObjInfoDesc)
1370	\|\| !i_objinfoIsEqual(&ObjInfoMainMod, &m->ObjInfoMainMod)
1371	\|\| !i_objinfoIsEqual(&ObjInfoExtPack, &m->ObjInfoExtPack) )
1372	i_probeAndLoad();
1373
1374	return S_OK;
1375	}
1376
1377	#ifndef VBOX_COM_INPROC
1378	/**
1379	* Checks if there are cloud providers vetoing extension pack uninstall.
1380	*
1381	* This needs going through the cloud provider singleton in VirtualBox,
1382	* the job cannot be done purely by using the code in the extension pack).
1383	* It cannot be integrated into i_callUninstallHookAndClose, because it
1384	* can only do its job when the extpack lock is not held, whereas the
1385	* actual uninstall must be done with the lock held all the time for
1386	* consistency reasons.
1387	*
1388	* This is called when uninstalling or replacing an extension pack.
1389	*
1390	* @returns true / false
1391	*/
1392	bool ExtPack::i_areThereCloudProviderUninstallVetos()
1393	{
1394	Assert(m->pVirtualBox != NULL); /* Only called from VBoxSVC. */
1395
1396	ComObjPtr<CloudProviderManager> cpm(m->pVirtualBox->i_getCloudProviderManager());
1397	AssertReturn(!cpm.isNull(), false);
1398
1399	return !cpm->i_canRemoveExtPack(static_cast<IExtPack *>(this));
1400	}
1401
1402	/**
1403	* Notifies the Cloud Provider Manager that there is a new extension pack.
1404	*
1405	* This is called when installing an extension pack.
1406	*/
1407	void ExtPack::i_notifyCloudProviderManager()
1408	{
1409	Assert(m->pVirtualBox != NULL); /* Only called from VBoxSVC. */
1410
1411	ComObjPtr<CloudProviderManager> cpm(m->pVirtualBox->i_getCloudProviderManager());
1412	AssertReturnVoid(!cpm.isNull());
1413
1414	cpm->i_addExtPack(static_cast<IExtPack *>(this));
1415	}
1416
1417	#endif /* !VBOX_COM_INPROC */
1418
1419	/**
1420	* Probes the extension pack, loading the main dll and calling its registration
1421	* entry point.
1422	*
1423	* This updates the state accordingly, the strWhyUnusable and fUnusable members
1424	* being the most important ones.
1425	*/
1426	void ExtPack::i_probeAndLoad(void)
1427	{
1428	m->fUsable = false;
1429	m->fMadeReadyCall = false;
1430
1431	/*
1432	* Query the file system info for the extension pack directory. This and
1433	* all other file system info we save is for the benefit of refresh().
1434	*/
1435	int vrc = RTPathQueryInfoEx(m->strExtPackPath.c_str(), &m->ObjInfoExtPack, RTFSOBJATTRADD_UNIX, RTPATH_F_ON_LINK);
1436	if (RT_FAILURE(vrc))
1437	{
1438	m->strWhyUnusable.printf(tr("RTPathQueryInfoEx on '%s' failed: %Rrc"), m->strExtPackPath.c_str(), vrc);
1439	return;
1440	}
1441	if (!RTFS_IS_DIRECTORY(m->ObjInfoExtPack.Attr.fMode))
1442	{
1443	if (RTFS_IS_SYMLINK(m->ObjInfoExtPack.Attr.fMode))
1444	m->strWhyUnusable.printf(tr("'%s' is a symbolic link, this is not allowed"),
1445	m->strExtPackPath.c_str(), vrc);
1446	else if (RTFS_IS_FILE(m->ObjInfoExtPack.Attr.fMode))
1447	m->strWhyUnusable.printf(tr("'%s' is a symbolic file, not a directory"),
1448	m->strExtPackPath.c_str(), vrc);
1449	else
1450	m->strWhyUnusable.printf(tr("'%s' is not a directory (fMode=%#x)"),
1451	m->strExtPackPath.c_str(), m->ObjInfoExtPack.Attr.fMode);
1452	return;
1453	}
1454
1455	RTERRINFOSTATIC ErrInfo;
1456	RTErrInfoInitStatic(&ErrInfo);
1457	vrc = SUPR3HardenedVerifyDir(m->strExtPackPath.c_str(), true /fRecursive/, true /fCheckFiles/, &ErrInfo.Core);
1458	if (RT_FAILURE(vrc))
1459	{
1460	m->strWhyUnusable.printf("%s (rc=%Rrc)", ErrInfo.Core.pszMsg, vrc);
1461	return;
1462	}
1463
1464	/*
1465	* Read the description file.
1466	*/
1467	RTCString strSavedName(m->Desc.strName);
1468	RTCString *pStrLoadErr = VBoxExtPackLoadDesc(m->strExtPackPath.c_str(), &m->Desc, &m->ObjInfoDesc);
1469	if (pStrLoadErr != NULL)
1470	{
1471	m->strWhyUnusable.printf(tr("Failed to load '%s/%s': %s"),
1472	m->strExtPackPath.c_str(), VBOX_EXTPACK_DESCRIPTION_NAME, pStrLoadErr->c_str());
1473	m->Desc.strName = strSavedName;
1474	delete pStrLoadErr;
1475	return;
1476	}
1477
1478	/*
1479	* Make sure the XML name and directory matches.
1480	*/
1481	if (!m->Desc.strName.equalsIgnoreCase(strSavedName))
1482	{
1483	m->strWhyUnusable.printf(tr("The description name ('%s') and directory name ('%s') does not match"),
1484	m->Desc.strName.c_str(), strSavedName.c_str());
1485	m->Desc.strName = strSavedName;
1486	return;
1487	}
1488
1489	/*
1490	* Load the main DLL and call the predefined entry point.
1491	*/
1492	#ifndef VBOX_COM_INPROC
1493	const char *pszMainModule = m->Desc.strMainModule.c_str();
1494	#else
1495	const char *pszMainModule = m->Desc.strMainVMModule.c_str();
1496	if (m->Desc.strMainVMModule.isEmpty())
1497	{
1498	/*
1499	* We're good! The main module for VM processes is optional.
1500	*/
1501	m->fUsable = true;
1502	m->strWhyUnusable.setNull();
1503	return;
1504	}
1505	#endif
1506	bool fIsNative;
1507	if (!i_findModule(pszMainModule, NULL /* default extension */, VBOXEXTPACKMODKIND_R3,
1508	&m->strMainModPath, &fIsNative, &m->ObjInfoMainMod))
1509	{
1510	m->strWhyUnusable.printf(tr("Failed to locate the main module ('%s')"), pszMainModule);
1511	return;
1512	}
1513
1514	vrc = SUPR3HardenedVerifyPlugIn(m->strMainModPath.c_str(), &ErrInfo.Core);
1515	if (RT_FAILURE(vrc))
1516	{
1517	m->strWhyUnusable.printf("%s", ErrInfo.Core.pszMsg);
1518	return;
1519	}
1520
1521	if (fIsNative)
1522	{
1523	vrc = SUPR3HardenedLdrLoadPlugIn(m->strMainModPath.c_str(), &m->hMainMod, &ErrInfo.Core);
1524	if (RT_FAILURE(vrc))
1525	{
1526	m->hMainMod = NIL_RTLDRMOD;
1527	m->strWhyUnusable.printf(tr("Failed to load the main module ('%s'): %Rrc - %s"),
1528	m->strMainModPath.c_str(), vrc, ErrInfo.Core.pszMsg);
1529	return;
1530	}
1531	}
1532	else
1533	{
1534	m->strWhyUnusable.printf(tr("Only native main modules are currently supported"));
1535	return;
1536	}
1537
1538	/*
1539	* Resolve the predefined entry point.
1540	*/
1541	#ifndef VBOX_COM_INPROC
1542	const char *pszMainEntryPoint = VBOX_EXTPACK_MAIN_MOD_ENTRY_POINT;
1543	PFNVBOXEXTPACKREGISTER pfnRegistration;
1544	uint32_t uVersion = VBOXEXTPACKREG_VERSION;
1545	#else
1546	const char *pszMainEntryPoint = VBOX_EXTPACK_MAIN_VM_MOD_ENTRY_POINT;
1547	PFNVBOXEXTPACKVMREGISTER pfnRegistration;
1548	uint32_t uVersion = VBOXEXTPACKVMREG_VERSION;
1549	#endif
1550	vrc = RTLdrGetSymbol(m->hMainMod, pszMainEntryPoint, (void **)&pfnRegistration);
1551	if (RT_SUCCESS(vrc))
1552	{
1553	RTErrInfoClear(&ErrInfo.Core);
1554	vrc = pfnRegistration(&m->Hlp, &m->pReg, &ErrInfo.Core);
1555	if ( RT_SUCCESS(vrc)
1556	&& !RTErrInfoIsSet(&ErrInfo.Core)
1557	&& RT_VALID_PTR(m->pReg))
1558	{
1559	if ( VBOXEXTPACK_IS_MAJOR_VER_EQUAL(m->pReg->u32Version, uVersion)
1560	&& m->pReg->u32EndMarker == m->pReg->u32Version)
1561	{
1562	#ifndef VBOX_COM_INPROC
1563	if ( (!m->pReg->pfnInstalled \|\| RT_VALID_PTR(m->pReg->pfnInstalled))
1564	&& (!m->pReg->pfnUninstall \|\| RT_VALID_PTR(m->pReg->pfnUninstall))
1565	&& (!m->pReg->pfnVirtualBoxReady \|\| RT_VALID_PTR(m->pReg->pfnVirtualBoxReady))
1566	&& (!m->pReg->pfnUnload \|\| RT_VALID_PTR(m->pReg->pfnUnload))
1567	&& (!m->pReg->pfnVMCreated \|\| RT_VALID_PTR(m->pReg->pfnVMCreated))
1568	&& (!m->pReg->pfnQueryObject \|\| RT_VALID_PTR(m->pReg->pfnQueryObject))
1569	)
1570	{
1571	/*
1572	* We're good!
1573	*/
1574	m->fUsable = true;
1575	m->strWhyUnusable.setNull();
1576	return;
1577	}
1578	#else
1579	if ( (!m->pReg->pfnConsoleReady \|\| RT_VALID_PTR(m->pReg->pfnConsoleReady))
1580	&& (!m->pReg->pfnUnload \|\| RT_VALID_PTR(m->pReg->pfnUnload))
1581	&& (!m->pReg->pfnVMConfigureVMM \|\| RT_VALID_PTR(m->pReg->pfnVMConfigureVMM))
1582	&& (!m->pReg->pfnVMPowerOn \|\| RT_VALID_PTR(m->pReg->pfnVMPowerOn))
1583	&& (!m->pReg->pfnVMPowerOff \|\| RT_VALID_PTR(m->pReg->pfnVMPowerOff))
1584	&& (!m->pReg->pfnQueryObject \|\| RT_VALID_PTR(m->pReg->pfnQueryObject))
1585	)
1586	{
1587	/*
1588	* We're good!
1589	*/
1590	m->fUsable = true;
1591	m->strWhyUnusable.setNull();
1592	return;
1593	}
1594	#endif
1595
1596	m->strWhyUnusable = tr("The registration structure contains one or more invalid function pointers");
1597	}
1598	else
1599	m->strWhyUnusable.printf(tr("Unsupported registration structure version %u.%u"),
1600	RT_HIWORD(m->pReg->u32Version), RT_LOWORD(m->pReg->u32Version));
1601	}
1602	else
1603	m->strWhyUnusable.printf(tr("%s returned %Rrc, pReg=%p ErrInfo='%s'"),
1604	pszMainEntryPoint, vrc, m->pReg, ErrInfo.Core.pszMsg);
1605	m->pReg = NULL;
1606	}
1607	else
1608	m->strWhyUnusable.printf(tr("Failed to resolve exported symbol '%s' in the main module: %Rrc"),
1609	pszMainEntryPoint, vrc);
1610
1611	RTLdrClose(m->hMainMod);
1612	m->hMainMod = NIL_RTLDRMOD;
1613	}
1614
1615	/**
1616	* Finds a module.
1617	*
1618	* @returns true if found, false if not.
1619	* @param a_pszName The module base name (no extension).
1620	* @param a_pszExt The extension. If NULL we use default
1621	* extensions.
1622	* @param a_enmKind The kind of module to locate.
1623	* @param a_pStrFound Where to return the path to the module we've
1624	* found.
1625	* @param a_pfNative Where to return whether this is a native module
1626	* or an agnostic one. Optional.
1627	* @param a_pObjInfo Where to return the file system object info for
1628	* the module. Optional.
1629	*/
1630	bool ExtPack::i_findModule(const char a_pszName, const char a_pszExt, VBOXEXTPACKMODKIND a_enmKind,
1631	Utf8Str a_pStrFound, bool a_pfNative, PRTFSOBJINFO a_pObjInfo) const
1632	{
1633	/*
1634	* Try the native path first.
1635	*/
1636	char szPath[RTPATH_MAX];
1637	int vrc = RTPathJoin(szPath, sizeof(szPath), m->strExtPackPath.c_str(), RTBldCfgTargetDotArch());
1638	AssertLogRelRCReturn(vrc, false);
1639	vrc = RTPathAppend(szPath, sizeof(szPath), a_pszName);
1640	AssertLogRelRCReturn(vrc, false);
1641	if (!a_pszExt)
1642	{
1643	const char *pszDefExt;
1644	switch (a_enmKind)
1645	{
1646	case VBOXEXTPACKMODKIND_RC: pszDefExt = ".rc"; break;
1647	case VBOXEXTPACKMODKIND_R0: pszDefExt = ".r0"; break;
1648	case VBOXEXTPACKMODKIND_R3: pszDefExt = RTLdrGetSuff(); break;
1649	default:
1650	AssertFailedReturn(false);
1651	}
1652	vrc = RTStrCat(szPath, sizeof(szPath), pszDefExt);
1653	AssertLogRelRCReturn(vrc, false);
1654	}
1655
1656	RTFSOBJINFO ObjInfo;
1657	if (!a_pObjInfo)
1658	a_pObjInfo = &ObjInfo;
1659	vrc = RTPathQueryInfo(szPath, a_pObjInfo, RTFSOBJATTRADD_UNIX);
1660	if (RT_SUCCESS(vrc) && RTFS_IS_FILE(a_pObjInfo->Attr.fMode))
1661	{
1662	if (a_pfNative)
1663	*a_pfNative = true;
1664	*a_pStrFound = szPath;
1665	return true;
1666	}
1667
1668	/*
1669	* Try the platform agnostic modules.
1670	*/
1671	/* gcc.x86/module.rel */
1672	char szSubDir[32];
1673	RTStrPrintf(szSubDir, sizeof(szSubDir), "%s.%s", RTBldCfgCompiler(), RTBldCfgTargetArch());
1674	vrc = RTPathJoin(szPath, sizeof(szPath), m->strExtPackPath.c_str(), szSubDir);
1675	AssertLogRelRCReturn(vrc, false);
1676	vrc = RTPathAppend(szPath, sizeof(szPath), a_pszName);
1677	AssertLogRelRCReturn(vrc, false);
1678	if (!a_pszExt)
1679	{
1680	vrc = RTStrCat(szPath, sizeof(szPath), ".rel");
1681	AssertLogRelRCReturn(vrc, false);
1682	}
1683	vrc = RTPathQueryInfo(szPath, a_pObjInfo, RTFSOBJATTRADD_UNIX);
1684	if (RT_SUCCESS(vrc) && RTFS_IS_FILE(a_pObjInfo->Attr.fMode))
1685	{
1686	if (a_pfNative)
1687	*a_pfNative = false;
1688	*a_pStrFound = szPath;
1689	return true;
1690	}
1691
1692	/* x86/module.rel */
1693	vrc = RTPathJoin(szPath, sizeof(szPath), m->strExtPackPath.c_str(), RTBldCfgTargetArch());
1694	AssertLogRelRCReturn(vrc, false);
1695	vrc = RTPathAppend(szPath, sizeof(szPath), a_pszName);
1696	AssertLogRelRCReturn(vrc, false);
1697	if (!a_pszExt)
1698	{
1699	vrc = RTStrCat(szPath, sizeof(szPath), ".rel");
1700	AssertLogRelRCReturn(vrc, false);
1701	}
1702	vrc = RTPathQueryInfo(szPath, a_pObjInfo, RTFSOBJATTRADD_UNIX);
1703	if (RT_SUCCESS(vrc) && RTFS_IS_FILE(a_pObjInfo->Attr.fMode))
1704	{
1705	if (a_pfNative)
1706	*a_pfNative = false;
1707	*a_pStrFound = szPath;
1708	return true;
1709	}
1710
1711	return false;
1712	}
1713
1714	/**
1715	* Compares two file system object info structures.
1716	*
1717	* @returns true if equal, false if not.
1718	* @param pObjInfo1 The first.
1719	* @param pObjInfo2 The second.
1720	* @todo IPRT should do this, really.
1721	*/
1722	/* static */ bool ExtPack::i_objinfoIsEqual(PCRTFSOBJINFO pObjInfo1, PCRTFSOBJINFO pObjInfo2)
1723	{
1724	if (!RTTimeSpecIsEqual(&pObjInfo1->ModificationTime, &pObjInfo2->ModificationTime))
1725	return false;
1726	if (!RTTimeSpecIsEqual(&pObjInfo1->ChangeTime, &pObjInfo2->ChangeTime))
1727	return false;
1728	if (!RTTimeSpecIsEqual(&pObjInfo1->BirthTime, &pObjInfo2->BirthTime))
1729	return false;
1730	if (pObjInfo1->cbObject != pObjInfo2->cbObject)
1731	return false;
1732	if (pObjInfo1->Attr.fMode != pObjInfo2->Attr.fMode)
1733	return false;
1734	if (pObjInfo1->Attr.enmAdditional == pObjInfo2->Attr.enmAdditional)
1735	{
1736	switch (pObjInfo1->Attr.enmAdditional)
1737	{
1738	case RTFSOBJATTRADD_UNIX:
1739	if (pObjInfo1->Attr.u.Unix.uid != pObjInfo2->Attr.u.Unix.uid)
1740	return false;
1741	if (pObjInfo1->Attr.u.Unix.gid != pObjInfo2->Attr.u.Unix.gid)
1742	return false;
1743	if (pObjInfo1->Attr.u.Unix.INodeIdDevice != pObjInfo2->Attr.u.Unix.INodeIdDevice)
1744	return false;
1745	if (pObjInfo1->Attr.u.Unix.INodeId != pObjInfo2->Attr.u.Unix.INodeId)
1746	return false;
1747	if (pObjInfo1->Attr.u.Unix.GenerationId != pObjInfo2->Attr.u.Unix.GenerationId)
1748	return false;
1749	break;
1750	default:
1751	break;
1752	}
1753	}
1754	return true;
1755	}
1756
1757
1758	/**
1759	* @interface_method_impl{VBOXEXTPACKHLP,pfnFindModule}
1760	*/
1761	/static/ DECLCALLBACK(int)
1762	ExtPack::i_hlpFindModule(PCVBOXEXTPACKHLP pHlp, const char pszName, const char pszExt, VBOXEXTPACKMODKIND enmKind,
1763	char pszFound, size_t cbFound, bool pfNative)
1764	{
1765	/*
1766	* Validate the input and get our bearings.
1767	*/
1768	AssertPtrReturn(pszName, VERR_INVALID_POINTER);
1769	AssertPtrNullReturn(pszExt, VERR_INVALID_POINTER);
1770	AssertPtrReturn(pszFound, VERR_INVALID_POINTER);
1771	AssertPtrNullReturn(pfNative, VERR_INVALID_POINTER);
1772	AssertReturn(enmKind > VBOXEXTPACKMODKIND_INVALID && enmKind < VBOXEXTPACKMODKIND_END, VERR_INVALID_PARAMETER);
1773
1774	AssertPtrReturn(pHlp, VERR_INVALID_POINTER);
1775	AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, VERR_INVALID_POINTER);
1776	ExtPack::Data *pData = RT_FROM_CPP_MEMBER(pHlp, Data, Hlp);
1777	AssertPtrReturn(pData, VERR_INVALID_POINTER);
1778	ExtPack *pThis = pData->pThis;
1779	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1780
1781	/*
1782	* This is just a wrapper around findModule.
1783	*/
1784	Utf8Str strFound;
1785	if (pThis->i_findModule(pszName, pszExt, enmKind, &strFound, pfNative, NULL))
1786	return RTStrCopy(pszFound, cbFound, strFound.c_str());
1787	return VERR_FILE_NOT_FOUND;
1788	}
1789
1790	/**
1791	* @interface_method_impl{VBOXEXTPACKHLP,pfnGetFilePath}
1792	*/
1793	/static/ DECLCALLBACK(int)
1794	ExtPack::i_hlpGetFilePath(PCVBOXEXTPACKHLP pHlp, const char pszFilename, char pszPath, size_t cbPath)
1795	{
1796	/*
1797	* Validate the input and get our bearings.
1798	*/
1799	AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
1800	AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
1801	AssertReturn(cbPath > 0, VERR_BUFFER_OVERFLOW);
1802
1803	AssertPtrReturn(pHlp, VERR_INVALID_POINTER);
1804	AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, VERR_INVALID_POINTER);
1805	ExtPack::Data *pData = RT_FROM_CPP_MEMBER(pHlp, Data, Hlp);
1806	AssertPtrReturn(pData, VERR_INVALID_POINTER);
1807
1808	/*
1809	* This is a simple RTPathJoin, no checking if things exists or anything.
1810	*/
1811	int vrc = RTPathJoin(pszPath, cbPath, pData->strExtPackPath.c_str(), pszFilename);
1812	if (RT_FAILURE(vrc))
1813	RT_BZERO(pszPath, cbPath);
1814	return vrc;
1815	}
1816
1817	/**
1818	* @interface_method_impl{VBOXEXTPACKHLP,pfnGetContext}
1819	*/
1820	/static/ DECLCALLBACK(VBOXEXTPACKCTX)
1821	ExtPack::i_hlpGetContext(PCVBOXEXTPACKHLP pHlp)
1822	{
1823	/*
1824	* Validate the input and get our bearings.
1825	*/
1826	AssertPtrReturn(pHlp, VBOXEXTPACKCTX_INVALID);
1827	AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, VBOXEXTPACKCTX_INVALID);
1828	ExtPack::Data *pData = RT_FROM_CPP_MEMBER(pHlp, Data, Hlp);
1829	AssertPtrReturn(pData, VBOXEXTPACKCTX_INVALID);
1830
1831	return pData->enmContext;
1832	}
1833
1834	/**
1835	* @interface_method_impl{VBOXEXTPACKHLP,pfnLoadHGCMService}
1836	*/
1837	/static/ DECLCALLBACK(int)
1838	ExtPack::i_hlpLoadHGCMService(PCVBOXEXTPACKHLP pHlp, VBOXEXTPACK_IF_CS(IConsole) *pConsole,
1839	const char pszServiceLibrary, const char pszServiceName)
1840	{
1841	#ifdef VBOX_COM_INPROC
1842	/*
1843	* Validate the input and get our bearings.
1844	*/
1845	AssertPtrReturn(pszServiceLibrary, VERR_INVALID_POINTER);
1846	AssertPtrReturn(pszServiceName, VERR_INVALID_POINTER);
1847
1848	AssertPtrReturn(pHlp, VERR_INVALID_POINTER);
1849	AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, VERR_INVALID_POINTER);
1850	ExtPack::Data *pData = RT_FROM_CPP_MEMBER(pHlp, Data, Hlp);
1851	AssertPtrReturn(pData, VERR_INVALID_POINTER);
1852	ExtPack *pThis = pData->pThis;
1853	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1854	AssertPtrReturn(pConsole, VERR_INVALID_POINTER);
1855
1856	Console pCon = (Console )pConsole;
1857	return pCon->i_hgcmLoadService(pszServiceLibrary, pszServiceName);
1858	#else
1859	RT_NOREF(pHlp, pConsole, pszServiceLibrary, pszServiceName);
1860	return VERR_INVALID_STATE;
1861	#endif
1862	}
1863
1864	/**
1865	* @interface_method_impl{VBOXEXTPACKHLP,pfnLoadVDPlugin}
1866	*/
1867	/static/ DECLCALLBACK(int)
1868	ExtPack::i_hlpLoadVDPlugin(PCVBOXEXTPACKHLP pHlp, VBOXEXTPACK_IF_CS(IVirtualBox) pVirtualBox, const char pszPluginLibrary)
1869	{
1870	#ifndef VBOX_COM_INPROC
1871	/*
1872	* Validate the input and get our bearings.
1873	*/
1874	AssertPtrReturn(pszPluginLibrary, VERR_INVALID_POINTER);
1875
1876	AssertPtrReturn(pHlp, VERR_INVALID_POINTER);
1877	AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, VERR_INVALID_POINTER);
1878	ExtPack::Data *pData = RT_FROM_CPP_MEMBER(pHlp, Data, Hlp);
1879	AssertPtrReturn(pData, VERR_INVALID_POINTER);
1880	ExtPack *pThis = pData->pThis;
1881	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1882	AssertPtrReturn(pVirtualBox, VERR_INVALID_POINTER);
1883
1884	VirtualBox pVBox = (VirtualBox )pVirtualBox;
1885	return pVBox->i_loadVDPlugin(pszPluginLibrary);
1886	#else
1887	RT_NOREF(pHlp, pVirtualBox, pszPluginLibrary);
1888	return VERR_INVALID_STATE;
1889	#endif
1890	}
1891
1892	/**
1893	* @interface_method_impl{VBOXEXTPACKHLP,pfnUnloadVDPlugin}
1894	*/
1895	/static/ DECLCALLBACK(int)
1896	ExtPack::i_hlpUnloadVDPlugin(PCVBOXEXTPACKHLP pHlp, VBOXEXTPACK_IF_CS(IVirtualBox) pVirtualBox, const char pszPluginLibrary)
1897	{
1898	#ifndef VBOX_COM_INPROC
1899	/*
1900	* Validate the input and get our bearings.
1901	*/
1902	AssertPtrReturn(pszPluginLibrary, VERR_INVALID_POINTER);
1903
1904	AssertPtrReturn(pHlp, VERR_INVALID_POINTER);
1905	AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, VERR_INVALID_POINTER);
1906	ExtPack::Data *pData = RT_FROM_CPP_MEMBER(pHlp, Data, Hlp);
1907	AssertPtrReturn(pData, VERR_INVALID_POINTER);
1908	ExtPack *pThis = pData->pThis;
1909	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
1910	AssertPtrReturn(pVirtualBox, VERR_INVALID_POINTER);
1911
1912	VirtualBox pVBox = (VirtualBox )pVirtualBox;
1913	return pVBox->i_unloadVDPlugin(pszPluginLibrary);
1914	#else
1915	RT_NOREF(pHlp, pVirtualBox, pszPluginLibrary);
1916	return VERR_INVALID_STATE;
1917	#endif
1918	}
1919
1920	/**
1921	* @interface_method_impl{VBOXEXTPACKHLP,pfnCreateProgress}
1922	*/
1923	/static/ DECLCALLBACK(uint32_t)
1924	ExtPack::i_hlpCreateProgress(PCVBOXEXTPACKHLP pHlp, VBOXEXTPACK_IF_CS(IUnknown) *pInitiator,
1925	const char *pcszDescription, uint32_t cOperations,
1926	uint32_t uTotalOperationsWeight, const char *pcszFirstOperationDescription,
1927	uint32_t uFirstOperationWeight, VBOXEXTPACK_IF_CS(IProgress) **ppProgressOut)
1928	{
1929	/*
1930	* Validate the input and get our bearings.
1931	*/
1932	AssertPtrReturn(pcszDescription, (uint32_t)E_INVALIDARG);
1933	AssertReturn(cOperations >= 1, (uint32_t)E_INVALIDARG);
1934	AssertReturn(uTotalOperationsWeight >= 1, (uint32_t)E_INVALIDARG);
1935	AssertPtrReturn(pcszFirstOperationDescription, (uint32_t)E_INVALIDARG);
1936	AssertReturn(uFirstOperationWeight >= 1, (uint32_t)E_INVALIDARG);
1937	AssertPtrReturn(ppProgressOut, (uint32_t)E_INVALIDARG);
1938
1939	AssertPtrReturn(pHlp, (uint32_t)E_INVALIDARG);
1940	AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, (uint32_t)E_INVALIDARG);
1941	#ifndef VBOX_COM_INPROC
1942	ExtPack::Data *pData = RT_FROM_CPP_MEMBER(pHlp, Data, Hlp);
1943	#endif
1944
1945	ComObjPtr<Progress> pProgress;
1946	HRESULT hrc = pProgress.createObject();
1947	if (SUCCEEDED(hrc))
1948	{
1949	hrc = pProgress->init(
1950	#ifndef VBOX_COM_INPROC
1951	pData->pVirtualBox,
1952	#endif
1953	pInitiator, pcszDescription, TRUE /* aCancelable */,
1954	cOperations, uTotalOperationsWeight,
1955	pcszFirstOperationDescription, uFirstOperationWeight);
1956	if (SUCCEEDED(hrc))
1957	hrc = pProgress.queryInterfaceTo(ppProgressOut);
1958	}
1959	return hrc;
1960	}
1961
1962	/**
1963	* @interface_method_impl{VBOXEXTPACKHLP,pfnGetCanceledProgress}
1964	*/
1965	/static/ DECLCALLBACK(uint32_t)
1966	ExtPack::i_hlpGetCanceledProgress(PCVBOXEXTPACKHLP pHlp, VBOXEXTPACK_IF_CS(IProgress) *pProgress,
1967	bool *pfCanceled)
1968	{
1969	/*
1970	* Validate the input and get our bearings.
1971	*/
1972	AssertPtrReturn(pProgress, (uint32_t)E_INVALIDARG);
1973	AssertPtrReturn(pfCanceled, (uint32_t)E_INVALIDARG);
1974
1975	AssertPtrReturn(pHlp, (uint32_t)E_INVALIDARG);
1976	AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, (uint32_t)E_INVALIDARG);
1977
1978	BOOL fCanceled = FALSE;
1979	HRESULT hrc = pProgress->COMGETTER(Canceled)(&fCanceled);
1980	*pfCanceled = !!fCanceled;
1981	return hrc;
1982	}
1983
1984	/**
1985	* @interface_method_impl{VBOXEXTPACKHLP,pfnUpdateProgress}
1986	*/
1987	/static/ DECLCALLBACK(uint32_t)
1988	ExtPack::i_hlpUpdateProgress(PCVBOXEXTPACKHLP pHlp, VBOXEXTPACK_IF_CS(IProgress) *pProgress,
1989	uint32_t uPercent)
1990	{
1991	/*
1992	* Validate the input and get our bearings.
1993	*/
1994	AssertPtrReturn(pProgress, (uint32_t)E_INVALIDARG);
1995	AssertReturn(uPercent <= 100, (uint32_t)E_INVALIDARG);
1996
1997	AssertPtrReturn(pHlp, (uint32_t)E_INVALIDARG);
1998	AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, (uint32_t)E_INVALIDARG);
1999
2000	ComPtr<IInternalProgressControl> pProgressControl(pProgress);
2001	AssertReturn(!!pProgressControl, (uint32_t)E_INVALIDARG);
2002	return pProgressControl->SetCurrentOperationProgress(uPercent);
2003	}
2004
2005	/**
2006	* @interface_method_impl{VBOXEXTPACKHLP,pfnNextOperationProgress}
2007	*/
2008	/static/ DECLCALLBACK(uint32_t)
2009	ExtPack::i_hlpNextOperationProgress(PCVBOXEXTPACKHLP pHlp, VBOXEXTPACK_IF_CS(IProgress) *pProgress,
2010	const char *pcszNextOperationDescription,
2011	uint32_t uNextOperationWeight)
2012	{
2013	/*
2014	* Validate the input and get our bearings.
2015	*/
2016	AssertPtrReturn(pProgress, (uint32_t)E_INVALIDARG);
2017	AssertPtrReturn(pcszNextOperationDescription, (uint32_t)E_INVALIDARG);
2018	AssertReturn(uNextOperationWeight >= 1, (uint32_t)E_INVALIDARG);
2019
2020	AssertPtrReturn(pHlp, (uint32_t)E_INVALIDARG);
2021	AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, (uint32_t)E_INVALIDARG);
2022
2023	ComPtr<IInternalProgressControl> pProgressControl(pProgress);
2024	AssertReturn(!!pProgressControl, (uint32_t)E_INVALIDARG);
2025	return pProgressControl->SetNextOperation(Bstr(pcszNextOperationDescription).raw(), uNextOperationWeight);
2026	}
2027
2028	/**
2029	* @interface_method_impl{VBOXEXTPACKHLP,pfnWaitOtherProgress}
2030	*/
2031	/static/ DECLCALLBACK(uint32_t)
2032	ExtPack::i_hlpWaitOtherProgress(PCVBOXEXTPACKHLP pHlp, VBOXEXTPACK_IF_CS(IProgress) *pProgress,
2033	VBOXEXTPACK_IF_CS(IProgress) *pProgressOther, uint32_t cTimeoutMS)
2034	{
2035	/*
2036	* Validate the input and get our bearings.
2037	*/
2038	AssertPtrReturn(pProgress, (uint32_t)E_INVALIDARG);
2039	AssertPtrReturn(pProgressOther, (uint32_t)E_INVALIDARG);
2040
2041	AssertPtrReturn(pHlp, (uint32_t)E_INVALIDARG);
2042	AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, (uint32_t)E_INVALIDARG);
2043
2044	ComPtr<IInternalProgressControl> pProgressControl(pProgress);
2045	AssertReturn(!!pProgressControl, (uint32_t)E_INVALIDARG);
2046	return pProgressControl->WaitForOtherProgressCompletion(pProgressOther, cTimeoutMS);
2047	}
2048
2049	/**
2050	* @interface_method_impl{VBOXEXTPACKHLP,pfnCompleteProgress}
2051	*/
2052	/static/ DECLCALLBACK(uint32_t)
2053	ExtPack::i_hlpCompleteProgress(PCVBOXEXTPACKHLP pHlp, VBOXEXTPACK_IF_CS(IProgress) *pProgress,
2054	uint32_t uResultCode)
2055	{
2056	/*
2057	* Validate the input and get our bearings.
2058	*/
2059	AssertPtrReturn(pHlp, (uint32_t)E_INVALIDARG);
2060	AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, (uint32_t)E_INVALIDARG);
2061	AssertPtrReturn(pProgress, (uint32_t)E_INVALIDARG);
2062
2063	ComPtr<IInternalProgressControl> pProgressControl(pProgress);
2064	AssertReturn(!!pProgressControl, (uint32_t)E_INVALIDARG);
2065
2066	ComPtr<IVirtualBoxErrorInfo> errorInfo;
2067	if (FAILED((HRESULT)uResultCode))
2068	{
2069	ErrorInfoKeeper eik;
2070	eik.getVirtualBoxErrorInfo(errorInfo);
2071	}
2072	return pProgressControl->NotifyComplete((LONG)uResultCode, errorInfo);
2073	}
2074
2075	/**
2076	* @interface_method_impl{VBOXEXTPACKHLP,pfnCreateEvent}
2077	*/
2078	/static/ DECLCALLBACK(uint32_t)
2079	ExtPack::i_hlpCreateEvent(PCVBOXEXTPACKHLP pHlp,
2080	VBOXEXTPACK_IF_CS(IEventSource) *aSource,
2081	/* VBoxEventType_T */ uint32_t aType, bool aWaitable,
2082	VBOXEXTPACK_IF_CS(IEvent) **ppEventOut)
2083	{
2084	/*
2085	* Validate the input and get our bearings.
2086	*/
2087	AssertPtrReturn(pHlp, (uint32_t)E_INVALIDARG);
2088	AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, (uint32_t)E_INVALIDARG);
2089	AssertPtrReturn(ppEventOut, (uint32_t)E_INVALIDARG);
2090
2091	ComObjPtr<VBoxEvent> pEvent;
2092	HRESULT hrc = pEvent.createObject();
2093	if (SUCCEEDED(hrc))
2094	{
2095	/* default aSource to pVirtualBox? */
2096	hrc = pEvent->init(aSource, static_cast<VBoxEventType_T>(aType), aWaitable);
2097	if (SUCCEEDED(hrc))
2098	hrc = pEvent.queryInterfaceTo(ppEventOut);
2099	}
2100	return hrc;
2101	}
2102
2103	/**
2104	* @interface_method_impl{VBOXEXTPACKHLP,pfnCreateVetoEvent}
2105	*/
2106	/static/ DECLCALLBACK(uint32_t)
2107	ExtPack::i_hlpCreateVetoEvent(PCVBOXEXTPACKHLP pHlp,
2108	VBOXEXTPACK_IF_CS(IEventSource) *aSource,
2109	/* VBoxEventType_T */ uint32_t aType,
2110	VBOXEXTPACK_IF_CS(IVetoEvent) **ppEventOut)
2111	{
2112	AssertPtrReturn(pHlp, (uint32_t)E_INVALIDARG);
2113	AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, (uint32_t)E_INVALIDARG);
2114	AssertPtrReturn(ppEventOut, (uint32_t)E_INVALIDARG);
2115
2116	ComObjPtr<VBoxVetoEvent> pEvent;
2117
2118	HRESULT hrc = pEvent.createObject();
2119	if (SUCCEEDED(hrc))
2120	{
2121	/* default aSource to pVirtualBox? */
2122	hrc = pEvent->init(aSource, static_cast<VBoxEventType_T>(aType));
2123	if (SUCCEEDED(hrc))
2124	hrc = pEvent.queryInterfaceTo(ppEventOut);
2125	}
2126	return hrc;
2127	}
2128
2129	/**
2130	* @interface_method_impl{VBOXEXTPACKHLP,pfnTranslate}
2131	*/
2132	/static/ DECLCALLBACK(const char *)
2133	ExtPack::i_hlpTranslate(PCVBOXEXTPACKHLP pHlp,
2134	const char *pszComponent,
2135	const char *pszSourceText,
2136	const char pszComment /=NULL*/,
2137	const size_t uNum /= ~(size_t)0/)
2138	{
2139	/*
2140	* Validate the input and get our bearings.
2141	*/
2142	AssertPtrReturn(pHlp, pszSourceText);
2143	AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, pszSourceText);
2144	ExtPack::Data *pData = RT_FROM_CPP_MEMBER(pHlp, Data, Hlp);
2145	AssertPtrReturn(pData, pszSourceText);
2146
2147	#ifdef VBOX_WITH_MAIN_NLS
2148	return VirtualBoxTranslator::translate(pData->pTrComponent, pszComponent, pszSourceText, pszComment, uNum);
2149	#else
2150	RT_NOREF(pszComponent, pszComment, uNum);
2151	return pszSourceText;
2152	#endif
2153	}
2154
2155
2156	/static/ DECLCALLBACK(int)
2157	ExtPack::i_hlpReservedN(PCVBOXEXTPACKHLP pHlp)
2158	{
2159	/*
2160	* Validate the input and get our bearings.
2161	*/
2162	AssertPtrReturn(pHlp, VERR_INVALID_POINTER);
2163	AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, VERR_INVALID_POINTER);
2164	ExtPack::Data *pData = RT_FROM_CPP_MEMBER(pHlp, Data, Hlp);
2165	AssertPtrReturn(pData, VERR_INVALID_POINTER);
2166	ExtPack *pThis = pData->pThis;
2167	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
2168
2169	return VERR_NOT_IMPLEMENTED;
2170	}
2171
2172
2173
2174
2175	HRESULT ExtPack::getName(com::Utf8Str &aName)
2176	{
2177	aName = m->Desc.strName;
2178	return S_OK;
2179	}
2180
2181	HRESULT ExtPack::getDescription(com::Utf8Str &aDescription)
2182	{
2183	aDescription = m->Desc.strDescription;
2184	return S_OK;
2185	}
2186
2187	HRESULT ExtPack::getVersion(com::Utf8Str &aVersion)
2188	{
2189	aVersion = m->Desc.strVersion;
2190	return S_OK;
2191	}
2192
2193	HRESULT ExtPack::getRevision(ULONG *aRevision)
2194	{
2195	*aRevision = m->Desc.uRevision;
2196	return S_OK;
2197	}
2198
2199	HRESULT ExtPack::getEdition(com::Utf8Str &aEdition)
2200	{
2201	aEdition = m->Desc.strEdition;
2202	return S_OK;
2203	}
2204
2205	HRESULT ExtPack::getVRDEModule(com::Utf8Str &aVRDEModule)
2206	{
2207	aVRDEModule = m->Desc.strVrdeModule;
2208	return S_OK;
2209	}
2210
2211	HRESULT ExtPack::getCryptoModule(com::Utf8Str &aCryptoModule)
2212	{
2213	aCryptoModule = m->Desc.strCryptoModule;
2214	return S_OK;
2215	}
2216
2217	HRESULT ExtPack::getPlugIns(std::vector<ComPtr<IExtPackPlugIn> > &aPlugIns)
2218	{
2219	/** @todo implement plug-ins. */
2220	NOREF(aPlugIns);
2221	ReturnComNotImplemented();
2222	}
2223
2224	HRESULT ExtPack::getUsable(BOOL *aUsable)
2225	{
2226	*aUsable = m->fUsable;
2227	return S_OK;
2228	}
2229
2230	HRESULT ExtPack::getWhyUnusable(com::Utf8Str &aWhyUnusable)
2231	{
2232	aWhyUnusable = m->strWhyUnusable;
2233	return S_OK;
2234	}
2235
2236	HRESULT ExtPack::getShowLicense(BOOL *aShowLicense)
2237	{
2238	*aShowLicense = m->Desc.fShowLicense;
2239	return S_OK;
2240	}
2241
2242	HRESULT ExtPack::getLicense(com::Utf8Str &aLicense)
2243	{
2244	Utf8Str strHtml("html");
2245	Utf8Str str("");
2246	return queryLicense(str, str, strHtml, aLicense);
2247	}
2248
2249	HRESULT ExtPack::queryLicense(const com::Utf8Str &aPreferredLocale, const com::Utf8Str &aPreferredLanguage,
2250	const com::Utf8Str &aFormat, com::Utf8Str &aLicenseText)
2251	{
2252	HRESULT hrc = S_OK;
2253
2254	/*
2255	* Validate input.
2256	*/
2257	if (aPreferredLocale.length() != 2 && aPreferredLocale.length() != 0)
2258	return setError(E_FAIL, tr("The preferred locale is a two character string or empty."));
2259
2260	if (aPreferredLanguage.length() != 2 && aPreferredLanguage.length() != 0)
2261	return setError(E_FAIL, tr("The preferred language is a two character string or empty."));
2262
2263	if ( !aFormat.equals("html")
2264	&& !aFormat.equals("rtf")
2265	&& !aFormat.equals("txt"))
2266	return setError(E_FAIL, tr("The license format can only have the values 'html', 'rtf' and 'txt'."));
2267
2268	/*
2269	* Combine the options to form a file name before locking down anything.
2270	*/
2271	char szName[sizeof(VBOX_EXTPACK_LICENSE_NAME_PREFIX "-de_DE.html") + 2];
2272	if (aPreferredLocale.isNotEmpty() && aPreferredLanguage.isNotEmpty())
2273	RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX "-%s_%s.%s",
2274	aPreferredLocale.c_str(), aPreferredLanguage.c_str(), aFormat.c_str());
2275	else if (aPreferredLocale.isNotEmpty())
2276	RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX "-%s.%s",
2277	aPreferredLocale.c_str(), aFormat.c_str());
2278	else if (aPreferredLanguage.isNotEmpty())
2279	RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX "-_%s.%s",
2280	aPreferredLocale.c_str(), aFormat.c_str());
2281	else
2282	RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX ".%s",
2283	aFormat.c_str());
2284
2285	/*
2286	* Effectuate the query.
2287	*/
2288	AutoReadLock autoLock(this COMMA_LOCKVAL_SRC_POS); /* paranoia */
2289
2290	if (!m->fUsable)
2291	hrc = setError(E_FAIL, "%s", m->strWhyUnusable.c_str());
2292	else
2293	{
2294	char szPath[RTPATH_MAX];
2295	int vrc = RTPathJoin(szPath, sizeof(szPath), m->strExtPackPath.c_str(), szName);
2296	if (RT_SUCCESS(vrc))
2297	{
2298	void *pvFile;
2299	size_t cbFile;
2300	vrc = RTFileReadAllEx(szPath, 0, RTFOFF_MAX, RTFILE_RDALL_O_DENY_READ, &pvFile, &cbFile);
2301	if (RT_SUCCESS(vrc))
2302	{
2303	Bstr bstrLicense((const char *)pvFile, cbFile);
2304	if (bstrLicense.isNotEmpty())
2305	{
2306	aLicenseText = Utf8Str(bstrLicense);
2307	hrc = S_OK;
2308	}
2309	else
2310	hrc = setError(VBOX_E_IPRT_ERROR, tr("The license file '%s' is empty or contains invalid UTF-8 encoding"),
2311	szPath);
2312	RTFileReadAllFree(pvFile, cbFile);
2313	}
2314	else if (vrc == VERR_FILE_NOT_FOUND \|\| vrc == VERR_PATH_NOT_FOUND)
2315	hrc = setErrorBoth(VBOX_E_OBJECT_NOT_FOUND, vrc, tr("The license file '%s' was not found in extension pack '%s'"),
2316	szName, m->Desc.strName.c_str());
2317	else
2318	hrc = setErrorBoth(VBOX_E_FILE_ERROR, vrc, tr("Failed to open the license file '%s': %Rrc"), szPath, vrc);
2319	}
2320	else
2321	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("RTPathJoin failed: %Rrc"), vrc);
2322	}
2323	return hrc;
2324	}
2325
2326	HRESULT ExtPack::queryObject(const com::Utf8Str &aObjUuid, ComPtr<IUnknown> &aReturnInterface)
2327	{
2328	com::Guid ObjectId;
2329	CheckComArgGuid(aObjUuid, ObjectId);
2330
2331	HRESULT hrc = S_OK;
2332
2333	if ( m->pReg
2334	&& m->pReg->pfnQueryObject)
2335	{
2336	void *pvUnknown = m->pReg->pfnQueryObject(m->pReg, ObjectId.raw());
2337	if (pvUnknown)
2338	{
2339	aReturnInterface = (IUnknown *)pvUnknown;
2340	/* The above assignment increased the refcount. Since pvUnknown
2341	* is a dumb pointer we have to do the release ourselves. */
2342	((IUnknown *)pvUnknown)->Release();
2343	}
2344	else
2345	hrc = E_NOINTERFACE;
2346	}
2347	else
2348	hrc = E_NOINTERFACE;
2349	return hrc;
2350	}
2351
2352	DEFINE_EMPTY_CTOR_DTOR(ExtPackManager)
2353
2354	/**
2355	* Called by ComObjPtr::createObject when creating the object.
2356	*
2357	* Just initialize the basic object state, do the rest in init().
2358	*
2359	* @returns S_OK.
2360	*/
2361	HRESULT ExtPackManager::FinalConstruct()
2362	{
2363	m = NULL;
2364	return BaseFinalConstruct();
2365	}
2366
2367	/**
2368	* Initializes the extension pack manager.
2369	*
2370	* @returns COM status code.
2371	* @param a_pVirtualBox Pointer to the VirtualBox object.
2372	* @param a_enmContext The context we're in.
2373	*/
2374	HRESULT ExtPackManager::initExtPackManager(VirtualBox *a_pVirtualBox, VBOXEXTPACKCTX a_enmContext)
2375	{
2376	AutoInitSpan autoInitSpan(this);
2377	AssertReturn(autoInitSpan.isOk(), E_FAIL);
2378
2379	/*
2380	* Figure some stuff out before creating the instance data.
2381	*/
2382	char szBaseDir[RTPATH_MAX];
2383	int vrc = RTPathAppPrivateArchTop(szBaseDir, sizeof(szBaseDir));
2384	AssertLogRelRCReturn(vrc, E_FAIL);
2385	vrc = RTPathAppend(szBaseDir, sizeof(szBaseDir), VBOX_EXTPACK_INSTALL_DIR);
2386	AssertLogRelRCReturn(vrc, E_FAIL);
2387
2388	char szCertificatDir[RTPATH_MAX];
2389	vrc = RTPathAppPrivateNoArch(szCertificatDir, sizeof(szCertificatDir));
2390	AssertLogRelRCReturn(vrc, E_FAIL);
2391	vrc = RTPathAppend(szCertificatDir, sizeof(szCertificatDir), VBOX_EXTPACK_CERT_DIR);
2392	AssertLogRelRCReturn(vrc, E_FAIL);
2393
2394	/*
2395	* Allocate and initialize the instance data.
2396	*/
2397	m = new Data;
2398	m->strBaseDir = szBaseDir;
2399	m->strCertificatDirPath = szCertificatDir;
2400	m->enmContext = a_enmContext;
2401	#ifndef VBOX_COM_INPROC
2402	m->pVirtualBox = a_pVirtualBox;
2403	#else
2404	RT_NOREF_PV(a_pVirtualBox);
2405	#endif
2406
2407	/*
2408	* Go looking for extensions. The RTDirOpen may fail if nothing has been
2409	* installed yet, or if root is paranoid and has revoked our access to them.
2410	*
2411	* We ASSUME that there are no files, directories or stuff in the directory
2412	* that exceed the max name length in RTDIRENTRYEX.
2413	*/
2414	HRESULT hrc = S_OK;
2415	RTDIR hDir;
2416	vrc = RTDirOpen(&hDir, szBaseDir);
2417	if (RT_SUCCESS(vrc))
2418	{
2419	for (;;)
2420	{
2421	RTDIRENTRYEX Entry;
2422	vrc = RTDirReadEx(hDir, &Entry, NULL /pcbDirEntry/, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
2423	if (RT_FAILURE(vrc))
2424	{
2425	AssertLogRelMsg(vrc == VERR_NO_MORE_FILES, ("%Rrc\n", vrc));
2426	break;
2427	}
2428	if ( RTFS_IS_DIRECTORY(Entry.Info.Attr.fMode)
2429	&& strcmp(Entry.szName, ".") != 0
2430	&& strcmp(Entry.szName, "..") != 0
2431	&& VBoxExtPackIsValidMangledName(Entry.szName) )
2432	{
2433	/*
2434	* All directories are extensions, the shall be nothing but
2435	* extensions in this subdirectory.
2436	*/
2437	char szExtPackDir[RTPATH_MAX];
2438	vrc = RTPathJoin(szExtPackDir, sizeof(szExtPackDir), m->strBaseDir.c_str(), Entry.szName);
2439	AssertLogRelRC(vrc);
2440	if (RT_SUCCESS(vrc))
2441	{
2442	RTCString *pstrName = VBoxExtPackUnmangleName(Entry.szName, RTSTR_MAX);
2443	AssertLogRel(pstrName);
2444	if (pstrName)
2445	{
2446	ComObjPtr<ExtPack> NewExtPack;
2447	HRESULT hrc2 = NewExtPack.createObject();
2448	if (SUCCEEDED(hrc2))
2449	hrc2 = NewExtPack->initWithDir(a_pVirtualBox, a_enmContext, pstrName->c_str(), szExtPackDir);
2450	delete pstrName;
2451	if (SUCCEEDED(hrc2))
2452	{
2453	m->llInstalledExtPacks.push_back(NewExtPack);
2454	/* Paranoia, there should be no API clients before this method is finished. */
2455
2456	m->cUpdate++;
2457	}
2458	else if (SUCCEEDED(hrc))
2459	hrc = hrc2;
2460	}
2461	else
2462	hrc = E_UNEXPECTED;
2463	}
2464	else
2465	hrc = E_UNEXPECTED;
2466	}
2467	}
2468	RTDirClose(hDir);
2469	}
2470	/* else: ignore, the directory probably does not exist or something. */
2471
2472	if (SUCCEEDED(hrc))
2473	autoInitSpan.setSucceeded();
2474	return hrc;
2475	}
2476
2477	/**
2478	* COM cruft.
2479	*/
2480	void ExtPackManager::FinalRelease()
2481	{
2482	uninit();
2483	BaseFinalRelease();
2484	}
2485
2486	/**
2487	* Do the actual cleanup.
2488	*/
2489	void ExtPackManager::uninit()
2490	{
2491	/* Enclose the state transition Ready->InUninit->NotReady */
2492	AutoUninitSpan autoUninitSpan(this);
2493	if (!autoUninitSpan.uninitDone() && m != NULL)
2494	{
2495	delete m;
2496	m = NULL;
2497	}
2498	}
2499
2500	HRESULT ExtPackManager::getInstalledExtPacks(std::vector<ComPtr<IExtPack> > &aInstalledExtPacks)
2501	{
2502	Assert(m->enmContext == VBOXEXTPACKCTX_PER_USER_DAEMON);
2503
2504	AutoReadLock autoLock(this COMMA_LOCKVAL_SRC_POS);
2505
2506	aInstalledExtPacks.resize(m->llInstalledExtPacks.size());
2507	std::copy(m->llInstalledExtPacks.begin(), m->llInstalledExtPacks.end(), aInstalledExtPacks.begin());
2508
2509	return S_OK;
2510	}
2511
2512	HRESULT ExtPackManager::find(const com::Utf8Str &aName, ComPtr<IExtPack> &aReturnData)
2513	{
2514	HRESULT hrc = S_OK;
2515
2516	Assert(m->enmContext == VBOXEXTPACKCTX_PER_USER_DAEMON);
2517
2518	AutoReadLock autoLock(this COMMA_LOCKVAL_SRC_POS);
2519
2520	ComPtr<ExtPack> ptrExtPack = i_findExtPack(aName.c_str());
2521	if (!ptrExtPack.isNull())
2522	ptrExtPack.queryInterfaceTo(aReturnData.asOutParam());
2523	else
2524	hrc = VBOX_E_OBJECT_NOT_FOUND;
2525
2526	return hrc;
2527	}
2528
2529	HRESULT ExtPackManager::openExtPackFile(const com::Utf8Str &aPath, ComPtr<IExtPackFile> &aFile)
2530	{
2531	AssertReturn(m->enmContext == VBOXEXTPACKCTX_PER_USER_DAEMON, E_UNEXPECTED);
2532
2533	#ifndef VBOX_COM_INPROC
2534	/* The API can optionally take a ::SHA-256=<hex-digest> attribute at the
2535	end of the file name. This is just a temporary measure for
2536	backporting, in 4.2 we'll add another parameter to the method. */
2537	Utf8Str strTarball;
2538	Utf8Str strDigest;
2539	size_t offSha256 = aPath.find("::SHA-256=");
2540	if (offSha256 == Utf8Str::npos)
2541	strTarball = aPath;
2542	else
2543	{
2544	strTarball = aPath.substr(0, offSha256);
2545	strDigest = aPath.substr(offSha256 + sizeof("::SHA-256=") - 1);
2546	}
2547
2548	ComObjPtr<ExtPackFile> NewExtPackFile;
2549	HRESULT hrc = NewExtPackFile.createObject();
2550	if (SUCCEEDED(hrc))
2551	hrc = NewExtPackFile->initWithFile(strTarball.c_str(), strDigest.c_str(), this, m->pVirtualBox);
2552	if (SUCCEEDED(hrc))
2553	NewExtPackFile.queryInterfaceTo(aFile.asOutParam());
2554
2555	return hrc;
2556	#else
2557	RT_NOREF(aPath, aFile);
2558	return E_NOTIMPL;
2559	#endif
2560	}
2561
2562	HRESULT ExtPackManager::uninstall(const com::Utf8Str &aName, BOOL aForcedRemoval,
2563	const com::Utf8Str &aDisplayInfo, ComPtr<IProgress> &aProgress)
2564	{
2565	Assert(m->enmContext == VBOXEXTPACKCTX_PER_USER_DAEMON);
2566
2567	#ifndef VBOX_COM_INPROC
2568
2569	HRESULT hrc;
2570	ExtPackUninstallTask *pTask = NULL;
2571	try
2572	{
2573	pTask = new ExtPackUninstallTask();
2574	hrc = pTask->Init(this, aName, aForcedRemoval != FALSE, aDisplayInfo);
2575	if (SUCCEEDED(hrc))
2576	{
2577	ComPtr<Progress> ptrProgress = pTask->ptrProgress;
2578	hrc = pTask->createThreadWithType(RTTHREADTYPE_DEFAULT);
2579	pTask = NULL; /* always consumed by createThread */
2580	if (SUCCEEDED(hrc))
2581	hrc = ptrProgress.queryInterfaceTo(aProgress.asOutParam());
2582	else
2583	hrc = setError(VBOX_E_IPRT_ERROR,
2584	tr("Starting thread for an extension pack uninstallation failed with %Rrc"), hrc);
2585	}
2586	else
2587	hrc = setError(hrc, tr("Looks like creating a progress object for ExtraPackUninstallTask object failed"));
2588	}
2589	catch (std::bad_alloc &)
2590	{
2591	hrc = E_OUTOFMEMORY;
2592	}
2593	catch (HRESULT hrcXcpt)
2594	{
2595	LogFlowThisFunc(("Exception was caught in the function ExtPackManager::uninstall()\n"));
2596	hrc = hrcXcpt;
2597	}
2598	if (pTask)
2599	delete pTask;
2600	return hrc;
2601	#else
2602	RT_NOREF(aName, aForcedRemoval, aDisplayInfo, aProgress);
2603	return E_NOTIMPL;
2604	#endif
2605	}
2606
2607	HRESULT ExtPackManager::cleanup(void)
2608	{
2609	Assert(m->enmContext == VBOXEXTPACKCTX_PER_USER_DAEMON);
2610
2611	AutoCaller autoCaller(this);
2612	HRESULT hrc = autoCaller.hrc();
2613	if (SUCCEEDED(hrc))
2614	{
2615	/*
2616	* Run the set-uid-to-root binary that performs the cleanup.
2617	*
2618	* Take the write lock to prevent conflicts with other calls to this
2619	* VBoxSVC instance.
2620	*/
2621	AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS);
2622	hrc = i_runSetUidToRootHelper(NULL,
2623	"cleanup",
2624	"--base-dir", m->strBaseDir.c_str(),
2625	(const char *)NULL);
2626	}
2627
2628	return hrc;
2629	}
2630
2631	HRESULT ExtPackManager::queryAllPlugInsForFrontend(const com::Utf8Str &aFrontendName, std::vector<com::Utf8Str> &aPlugInModules)
2632	{
2633	NOREF(aFrontendName);
2634	aPlugInModules.resize(0);
2635	return S_OK;
2636	}
2637
2638	HRESULT ExtPackManager::isExtPackUsable(const com::Utf8Str &aName, BOOL *aUsable)
2639	{
2640	*aUsable = i_isExtPackUsable(aName.c_str());
2641	return S_OK;
2642	}
2643
2644	/**
2645	* Finds the success indicator string in the stderr output ofr hte helper app.
2646	*
2647	* @returns Pointer to the indicator.
2648	* @param psz The stderr output string. Can be NULL.
2649	* @param cch The size of the string.
2650	*/
2651	static char findSuccessIndicator(char psz, size_t cch)
2652	{
2653	static const char s_szSuccessInd[] = "rcExit=RTEXITCODE_SUCCESS";
2654	Assert(!cch \|\| strlen(psz) == cch);
2655	if (cch < sizeof(s_szSuccessInd) - 1)
2656	return NULL;
2657	char *pszInd = &psz[cch - sizeof(s_szSuccessInd) + 1];
2658	if (strcmp(s_szSuccessInd, pszInd))
2659	return NULL;
2660	return pszInd;
2661	}
2662
2663	/**
2664	* Runs the helper application that does the privileged operations.
2665	*
2666	* @returns S_OK or a failure status with error information set.
2667	* @param a_pstrDisplayInfo Platform specific display info hacks.
2668	* @param a_pszCommand The command to execute.
2669	* @param ... The argument strings that goes along with the
2670	* command. Maximum is about 16. Terminated by a
2671	* NULL.
2672	*/
2673	HRESULT ExtPackManager::i_runSetUidToRootHelper(Utf8Str const a_pstrDisplayInfo, const char a_pszCommand, ...)
2674	{
2675	/*
2676	* Calculate the path to the helper application.
2677	*/
2678	char szExecName[RTPATH_MAX];
2679	int vrc = RTPathAppPrivateArch(szExecName, sizeof(szExecName));
2680	AssertLogRelRCReturn(vrc, E_UNEXPECTED);
2681
2682	vrc = RTPathAppend(szExecName, sizeof(szExecName), VBOX_EXTPACK_HELPER_NAME);
2683	AssertLogRelRCReturn(vrc, E_UNEXPECTED);
2684
2685	/*
2686	* Convert the variable argument list to a RTProcCreate argument vector.
2687	*/
2688	const char *apszArgs[20];
2689	unsigned cArgs = 0;
2690
2691	LogRel(("ExtPack: Executing '%s'", szExecName));
2692	apszArgs[cArgs++] = &szExecName[0];
2693
2694	if ( a_pstrDisplayInfo
2695	&& a_pstrDisplayInfo->isNotEmpty())
2696	{
2697	LogRel((" '--display-info-hack' '%s'", a_pstrDisplayInfo->c_str()));
2698	apszArgs[cArgs++] = "--display-info-hack";
2699	apszArgs[cArgs++] = a_pstrDisplayInfo->c_str();
2700	}
2701
2702	LogRel((" '%s'", a_pszCommand));
2703	apszArgs[cArgs++] = a_pszCommand;
2704
2705	HRESULT hrc = S_OK;
2706
2707	va_list va;
2708	va_start(va, a_pszCommand);
2709	const char *pszLastArg;
2710	for (;;)
2711	{
2712	AssertBreakStmt(cArgs < RT_ELEMENTS(apszArgs) - 1, hrc = E_UNEXPECTED);
2713	pszLastArg = va_arg(va, const char *);
2714	if (!pszLastArg)
2715	break;
2716	LogRel((" '%s'", pszLastArg));
2717	apszArgs[cArgs++] = pszLastArg;
2718	};
2719	va_end(va);
2720	ComAssertComRCRet(hrc, hrc);
2721
2722	LogRel(("\n"));
2723	apszArgs[cArgs] = NULL;
2724
2725	/*
2726	* Create a PIPE which we attach to stderr so that we can read the error
2727	* message on failure and report it back to the caller.
2728	*/
2729	RTPIPE hPipeR;
2730	RTHANDLE hStdErrPipe;
2731	hStdErrPipe.enmType = RTHANDLETYPE_PIPE;
2732	vrc = RTPipeCreate(&hPipeR, &hStdErrPipe.u.hPipe, RTPIPE_C_INHERIT_WRITE);
2733	AssertLogRelRCReturn(vrc, E_UNEXPECTED);
2734
2735	/*
2736	* Spawn the process.
2737	*/
2738	RTPROCESS hProcess;
2739	vrc = RTProcCreateEx(szExecName,
2740	apszArgs,
2741	RTENV_DEFAULT,
2742	0 /fFlags/,
2743	NULL /phStdIn/,
2744	NULL /phStdOut/,
2745	&hStdErrPipe,
2746	NULL /pszAsUser/,
2747	NULL /pszPassword/,
2748	NULL /pvExtraData/,
2749	&hProcess);
2750	if (RT_SUCCESS(vrc))
2751	{
2752	vrc = RTPipeClose(hStdErrPipe.u.hPipe);
2753	hStdErrPipe.u.hPipe = NIL_RTPIPE;
2754
2755	/*
2756	* Read the pipe output until the process completes.
2757	*/
2758	RTPROCSTATUS ProcStatus = { -42, RTPROCEXITREASON_ABEND };
2759	size_t cbStdErrBuf = 0;
2760	size_t offStdErrBuf = 0;
2761	char *pszStdErrBuf = NULL;
2762	do
2763	{
2764	/*
2765	* Service the pipe. Block waiting for output or the pipe breaking
2766	* when the process terminates.
2767	*/
2768	if (hPipeR != NIL_RTPIPE)
2769	{
2770	char achBuf[1024];
2771	size_t cbRead;
2772	vrc = RTPipeReadBlocking(hPipeR, achBuf, sizeof(achBuf), &cbRead);
2773	if (RT_SUCCESS(vrc))
2774	{
2775	/* grow the buffer? */
2776	size_t cbBufReq = offStdErrBuf + cbRead + 1;
2777	if ( cbBufReq > cbStdErrBuf
2778	&& cbBufReq < _256K)
2779	{
2780	size_t cbNew = RT_ALIGN_Z(cbBufReq, 16); // 1024
2781	void *pvNew = RTMemRealloc(pszStdErrBuf, cbNew);
2782	if (pvNew)
2783	{
2784	pszStdErrBuf = (char *)pvNew;
2785	cbStdErrBuf = cbNew;
2786	}
2787	}
2788
2789	/* append if we've got room. */
2790	if (cbBufReq <= cbStdErrBuf)
2791	{
2792	memcpy(&pszStdErrBuf[offStdErrBuf], achBuf, cbRead);
2793	offStdErrBuf = offStdErrBuf + cbRead;
2794	pszStdErrBuf[offStdErrBuf] = '\0';
2795	}
2796	}
2797	else
2798	{
2799	AssertLogRelMsg(vrc == VERR_BROKEN_PIPE, ("%Rrc\n", vrc));
2800	RTPipeClose(hPipeR);
2801	hPipeR = NIL_RTPIPE;
2802	}
2803	}
2804
2805	/*
2806	* Service the process. Block if we have no pipe.
2807	*/
2808	if (hProcess != NIL_RTPROCESS)
2809	{
2810	vrc = RTProcWait(hProcess,
2811	hPipeR == NIL_RTPIPE ? RTPROCWAIT_FLAGS_BLOCK : RTPROCWAIT_FLAGS_NOBLOCK,
2812	&ProcStatus);
2813	if (RT_SUCCESS(vrc))
2814	hProcess = NIL_RTPROCESS;
2815	else
2816	AssertLogRelMsgStmt(vrc == VERR_PROCESS_RUNNING, ("%Rrc\n", vrc), hProcess = NIL_RTPROCESS);
2817	}
2818	} while ( hPipeR != NIL_RTPIPE
2819	\|\| hProcess != NIL_RTPROCESS);
2820
2821	LogRel(("ExtPack: enmReason=%d iStatus=%d stderr='%s'\n",
2822	ProcStatus.enmReason, ProcStatus.iStatus, offStdErrBuf ? pszStdErrBuf : ""));
2823
2824	/*
2825	* Look for rcExit=RTEXITCODE_SUCCESS at the end of the error output,
2826	* cut it as it is only there to attest the success.
2827	*/
2828	if (offStdErrBuf > 0)
2829	{
2830	RTStrStripR(pszStdErrBuf);
2831	offStdErrBuf = strlen(pszStdErrBuf);
2832	}
2833
2834	char *pszSuccessInd = findSuccessIndicator(pszStdErrBuf, offStdErrBuf);
2835	if (pszSuccessInd)
2836	{
2837	*pszSuccessInd = '\0';
2838	offStdErrBuf = (size_t)(pszSuccessInd - pszStdErrBuf);
2839	}
2840	else if ( ProcStatus.enmReason == RTPROCEXITREASON_NORMAL
2841	&& ProcStatus.iStatus == 0)
2842	ProcStatus.iStatus = offStdErrBuf ? 667 : 666;
2843
2844	/*
2845	* Compose the status code and, on failure, error message.
2846	*/
2847	if ( ProcStatus.enmReason == RTPROCEXITREASON_NORMAL
2848	&& ProcStatus.iStatus == 0)
2849	hrc = S_OK;
2850	else if (ProcStatus.enmReason == RTPROCEXITREASON_NORMAL)
2851	{
2852	AssertMsg(ProcStatus.iStatus != 0, ("%s\n", pszStdErrBuf));
2853	hrc = setError(E_FAIL, tr("The installer failed with exit code %d: %s"),
2854	ProcStatus.iStatus, offStdErrBuf ? pszStdErrBuf : "");
2855	}
2856	else if (ProcStatus.enmReason == RTPROCEXITREASON_SIGNAL)
2857	hrc = setError(E_UNEXPECTED, tr("The installer was killed by signal #d (stderr: %s)"),
2858	ProcStatus.iStatus, offStdErrBuf ? pszStdErrBuf : "");
2859	else if (ProcStatus.enmReason == RTPROCEXITREASON_ABEND)
2860	hrc = setError(E_UNEXPECTED, tr("The installer aborted abnormally (stderr: %s)"),
2861	offStdErrBuf ? pszStdErrBuf : "");
2862	else
2863	hrc = setError(E_UNEXPECTED, tr("internal error: enmReason=%d iStatus=%d stderr='%s'"),
2864	ProcStatus.enmReason, ProcStatus.iStatus, offStdErrBuf ? pszStdErrBuf : "");
2865
2866	RTMemFree(pszStdErrBuf);
2867	}
2868	else
2869	hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Failed to launch the helper application '%s' (%Rrc)"), szExecName, vrc);
2870
2871	RTPipeClose(hPipeR);
2872	RTPipeClose(hStdErrPipe.u.hPipe);
2873
2874	return hrc;
2875	}
2876
2877	/**
2878	* Finds an installed extension pack.
2879	*
2880	* @returns Pointer to the extension pack if found, NULL if not. (No reference
2881	* counting problem here since the caller must be holding the lock.)
2882	* @param a_pszName The name of the extension pack.
2883	*/
2884	ExtPack ExtPackManager::i_findExtPack(const char a_pszName)
2885	{
2886	size_t cchName = strlen(a_pszName);
2887
2888	for (ExtPackList::iterator it = m->llInstalledExtPacks.begin();
2889	it != m->llInstalledExtPacks.end();
2890	++it)
2891	{
2892	ExtPack::Data pExtPackData = (it)->m;
2893	if ( pExtPackData
2894	&& pExtPackData->Desc.strName.length() == cchName
2895	&& pExtPackData->Desc.strName.equalsIgnoreCase(a_pszName))
2896	return (*it);
2897	}
2898	return NULL;
2899	}
2900
2901	/**
2902	* Removes an installed extension pack from the internal list.
2903	*
2904	* The package is expected to exist!
2905	*
2906	* @param a_pszName The name of the extension pack.
2907	*/
2908	void ExtPackManager::i_removeExtPack(const char *a_pszName)
2909	{
2910	size_t cchName = strlen(a_pszName);
2911
2912	for (ExtPackList::iterator it = m->llInstalledExtPacks.begin();
2913	it != m->llInstalledExtPacks.end();
2914	++it)
2915	{
2916	ExtPack::Data pExtPackData = (it)->m;
2917	if ( pExtPackData
2918	&& pExtPackData->Desc.strName.length() == cchName
2919	&& pExtPackData->Desc.strName.equalsIgnoreCase(a_pszName))
2920	{
2921	m->llInstalledExtPacks.erase(it);
2922	m->cUpdate++;
2923	return;
2924	}
2925	}
2926	AssertMsgFailed(("%s\n", a_pszName));
2927	}
2928
2929	#ifndef VBOX_COM_INPROC
2930
2931	/**
2932	* Refreshes the specified extension pack.
2933	*
2934	* This may remove the extension pack from the list, so any non-smart pointers
2935	* to the extension pack object may become invalid.
2936	*
2937	* @returns S_OK and *a_ppExtPack on success, COM status code and error
2938	* message on failure. Note that *a_ppExtPack can be NULL.
2939	*
2940	* @param a_pszName The extension to update..
2941	* @param a_fUnusableIsError If @c true, report an unusable extension pack
2942	* as an error.
2943	* @param a_ppExtPack Where to store the pointer to the extension
2944	* pack of it is still around after the refresh.
2945	* This is optional.
2946	*
2947	* @remarks Caller holds the extension manager lock.
2948	* @remarks Only called in VBoxSVC.
2949	*/
2950	HRESULT ExtPackManager::i_refreshExtPack(const char a_pszName, bool a_fUnusableIsError, ExtPack *a_ppExtPack)
2951	{
2952	Assert(m->pVirtualBox != NULL); /* Only called from VBoxSVC. */
2953
2954	HRESULT hrc;
2955	ExtPack *pExtPack = i_findExtPack(a_pszName);
2956	if (pExtPack)
2957	{
2958	/*
2959	* Refresh existing object.
2960	*/
2961	bool fCanDelete;
2962	hrc = pExtPack->i_refresh(&fCanDelete);
2963	if (SUCCEEDED(hrc))
2964	{
2965	if (fCanDelete)
2966	{
2967	i_removeExtPack(a_pszName);
2968	pExtPack = NULL;
2969	}
2970	}
2971	}
2972	else
2973	{
2974	/*
2975	* Do this check here, otherwise VBoxExtPackCalcDir() will fail with a strange
2976	* error.
2977	*/
2978	bool fValid = VBoxExtPackIsValidName(a_pszName);
2979	if (!fValid)
2980	return setError(E_FAIL, "Invalid extension pack name specified");
2981
2982	/*
2983	* Does the dir exist? Make some special effort to deal with case
2984	* sensitivie file systems (a_pszName is case insensitive and mangled).
2985	*/
2986	char szDir[RTPATH_MAX];
2987	int vrc = VBoxExtPackCalcDir(szDir, sizeof(szDir), m->strBaseDir.c_str(), a_pszName);
2988	AssertLogRelRCReturn(vrc, E_FAIL);
2989
2990	RTDIRENTRYEX Entry;
2991	RTFSOBJINFO ObjInfo;
2992	vrc = RTPathQueryInfoEx(szDir, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
2993	bool fExists = RT_SUCCESS(vrc) && RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode);
2994	if (!fExists)
2995	{
2996	RTDIR hDir;
2997	vrc = RTDirOpen(&hDir, m->strBaseDir.c_str());
2998	if (RT_SUCCESS(vrc))
2999	{
3000	const char *pszMangledName = RTPathFilename(szDir);
3001	for (;;)
3002	{
3003	vrc = RTDirReadEx(hDir, &Entry, NULL /pcbDirEntry/, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
3004	if (RT_FAILURE(vrc))
3005	{
3006	AssertLogRelMsg(vrc == VERR_NO_MORE_FILES, ("%Rrc\n", vrc));
3007	break;
3008	}
3009	if ( RTFS_IS_DIRECTORY(Entry.Info.Attr.fMode)
3010	&& !RTStrICmp(Entry.szName, pszMangledName))
3011	{
3012	/*
3013	* The installed extension pack has a uses different case.
3014	* Update the name and directory variables.
3015	*/
3016	vrc = RTPathJoin(szDir, sizeof(szDir), m->strBaseDir.c_str(), Entry.szName); /* not really necessary */
3017	AssertLogRelRCReturnStmt(vrc, RTDirClose(hDir), E_UNEXPECTED);
3018	a_pszName = Entry.szName;
3019	fExists = true;
3020	break;
3021	}
3022	}
3023	RTDirClose(hDir);
3024	}
3025	}
3026	if (fExists)
3027	{
3028	/*
3029	* We've got something, create a new extension pack object for it.
3030	*/
3031	ComObjPtr<ExtPack> ptrNewExtPack;
3032	hrc = ptrNewExtPack.createObject();
3033	if (SUCCEEDED(hrc))
3034	hrc = ptrNewExtPack->initWithDir(m->pVirtualBox, m->enmContext, a_pszName, szDir);
3035	if (SUCCEEDED(hrc))
3036	{
3037	m->llInstalledExtPacks.push_back(ptrNewExtPack);
3038	m->cUpdate++;
3039	if (ptrNewExtPack->m->fUsable)
3040	LogRel(("ExtPackManager: Found extension pack '%s'.\n", a_pszName));
3041	else
3042	LogRel(("ExtPackManager: Found bad extension pack '%s': %s\n",
3043	a_pszName, ptrNewExtPack->m->strWhyUnusable.c_str() ));
3044	pExtPack = ptrNewExtPack;
3045	}
3046	}
3047	else
3048	hrc = S_OK;
3049	}
3050
3051	/*
3052	* Report error if not usable, if that is desired.
3053	*/
3054	if ( SUCCEEDED(hrc)
3055	&& pExtPack
3056	&& a_fUnusableIsError
3057	&& !pExtPack->m->fUsable)
3058	hrc = setError(E_FAIL, "%s", pExtPack->m->strWhyUnusable.c_str());
3059
3060	if (a_ppExtPack)
3061	*a_ppExtPack = pExtPack;
3062	return hrc;
3063	}
3064
3065	/**
3066	* Checks if there are any running VMs.
3067	*
3068	* This is called when uninstalling or replacing an extension pack.
3069	*
3070	* @returns true / false
3071	*/
3072	bool ExtPackManager::i_areThereAnyRunningVMs(void) const
3073	{
3074	Assert(m->pVirtualBox != NULL); /* Only called from VBoxSVC. */
3075
3076	/*
3077	* Get list of machines and their states.
3078	*/
3079	com::SafeIfaceArray<IMachine> SaMachines;
3080	HRESULT hrc = m->pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(SaMachines));
3081	if (SUCCEEDED(hrc))
3082	{
3083	com::SafeArray<MachineState_T> SaStates;
3084	hrc = m->pVirtualBox->GetMachineStates(ComSafeArrayAsInParam(SaMachines), ComSafeArrayAsOutParam(SaStates));
3085	if (SUCCEEDED(hrc))
3086	{
3087	/*
3088	* Scan the two parallel arrays for machines in the running state.
3089	*/
3090	Assert(SaStates.size() == SaMachines.size());
3091	for (size_t i = 0; i < SaMachines.size(); ++i)
3092	if (SaMachines[i] && Global::IsOnline(SaStates[i]))
3093	return true;
3094	}
3095	}
3096	return false;
3097	}
3098
3099	/**
3100	* Worker for IExtPackFile::Install.
3101	*
3102	* Called on a worker thread via doInstallThreadProc.
3103	*
3104	* @returns COM status code.
3105	* @param a_pExtPackFile The extension pack file, caller checks that
3106	* it's usable.
3107	* @param a_fReplace Whether to replace any existing extpack or just
3108	* fail.
3109	* @param a_pstrDisplayInfo Host specific display information hacks.
3110	* be NULL.
3111	*/
3112	HRESULT ExtPackManager::i_doInstall(ExtPackFile a_pExtPackFile, bool a_fReplace, Utf8Str const a_pstrDisplayInfo)
3113	{
3114	AssertReturn(m->enmContext == VBOXEXTPACKCTX_PER_USER_DAEMON, E_UNEXPECTED);
3115	RTCString const * const pStrName = &a_pExtPackFile->m->Desc.strName;
3116	RTCString const * const pStrTarball = &a_pExtPackFile->m->strExtPackFile;
3117	RTCString const * const pStrTarballDigest = &a_pExtPackFile->m->strDigest;
3118
3119	AutoCaller autoCaller(this);
3120	HRESULT hrc = autoCaller.hrc();
3121	if (SUCCEEDED(hrc))
3122	{
3123	AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS);
3124
3125	/*
3126	* Refresh the data we have on the extension pack as it
3127	* may be made stale by direct meddling or some other user.
3128	*/
3129	ExtPack *pExtPack;
3130	hrc = i_refreshExtPack(pStrName->c_str(), false /a_fUnusableIsError/, &pExtPack);
3131	if (SUCCEEDED(hrc))
3132	{
3133	if (pExtPack && a_fReplace)
3134	{
3135	/* We must leave the lock when calling i_areThereAnyRunningVMs,
3136	which means we have to redo the refresh call afterwards. */
3137	autoLock.release();
3138	bool fRunningVMs = i_areThereAnyRunningVMs();
3139	bool fVetoingCP = pExtPack->i_areThereCloudProviderUninstallVetos();
3140	bool fUnloadedCryptoMod = m->pVirtualBox->i_unloadCryptoIfModule() == S_OK;
3141	autoLock.acquire();
3142	hrc = i_refreshExtPack(pStrName->c_str(), false /a_fUnusableIsError/, &pExtPack);
3143	if (fRunningVMs)
3144	{
3145	LogRel(("Upgrading extension pack '%s' failed because at least one VM is still running.", pStrName->c_str()));
3146	hrc = setError(E_FAIL, tr("Upgrading extension pack '%s' failed because at least one VM is still running"),
3147	pStrName->c_str());
3148	}
3149	else if (fVetoingCP)
3150	{
3151	LogRel(("Upgrading extension pack '%s' failed because at least one Cloud Provider is still busy.", pStrName->c_str()));
3152	hrc = setError(E_FAIL, tr("Upgrading extension pack '%s' failed because at least one Cloud Provider is still busy"),
3153	pStrName->c_str());
3154	}
3155	else if (!fUnloadedCryptoMod)
3156	{
3157	LogRel(("Upgrading extension pack '%s' failed because the cryptographic support module is still in use.", pStrName->c_str()));
3158	hrc = setError(E_FAIL, tr("Upgrading extension pack '%s' failed because the cryptographic support module is still in use"),
3159	pStrName->c_str());
3160	}
3161	else if (SUCCEEDED(hrc) && pExtPack)
3162	hrc = pExtPack->i_callUninstallHookAndClose(m->pVirtualBox, false /a_ForcedRemoval/);
3163	}
3164	else if (pExtPack)
3165	hrc = setError(E_FAIL,
3166	tr("Extension pack '%s' is already installed."
3167	" In case of a reinstallation, please uninstall it first"),
3168	pStrName->c_str());
3169	}
3170	if (SUCCEEDED(hrc))
3171	{
3172	/*
3173	* Run the privileged helper binary that performs the actual
3174	* installation. Then create an object for the packet (we do this
3175	* even on failure, to be on the safe side).
3176	*/
3177	hrc = i_runSetUidToRootHelper(a_pstrDisplayInfo,
3178	"install",
3179	"--base-dir", m->strBaseDir.c_str(),
3180	"--cert-dir", m->strCertificatDirPath.c_str(),
3181	"--name", pStrName->c_str(),
3182	"--tarball", pStrTarball->c_str(),
3183	"--sha-256", pStrTarballDigest->c_str(),
3184	pExtPack ? "--replace" : (const char *)NULL,
3185	(const char *)NULL);
3186	if (SUCCEEDED(hrc))
3187	{
3188	hrc = i_refreshExtPack(pStrName->c_str(), true /a_fUnusableIsError/, &pExtPack);
3189	if (SUCCEEDED(hrc) && pExtPack)
3190	{
3191	RTERRINFOSTATIC ErrInfo;
3192	RTErrInfoInitStatic(&ErrInfo);
3193	pExtPack->i_callInstalledHook(m->pVirtualBox, &autoLock, &ErrInfo.Core);
3194	if (RT_SUCCESS(ErrInfo.Core.rc))
3195	{
3196	LogRel(("ExtPackManager: Successfully installed extension pack '%s'.\n", pStrName->c_str()));
3197	m->pVirtualBox->i_onExtPackInstalled(*pStrName);
3198	}
3199	else
3200	{
3201	LogRel(("ExtPackManager: Installed hook for '%s' failed: %Rrc - %s\n",
3202	pStrName->c_str(), ErrInfo.Core.rc, ErrInfo.Core.pszMsg));
3203
3204	/*
3205	* Uninstall the extpack if the error indicates that.
3206	*/
3207	if (ErrInfo.Core.rc == VERR_EXTPACK_UNSUPPORTED_HOST_UNINSTALL)
3208	i_runSetUidToRootHelper(a_pstrDisplayInfo,
3209	"uninstall",
3210	"--base-dir", m->strBaseDir.c_str(),
3211	"--name", pStrName->c_str(),
3212	"--forced",
3213	(const char *)NULL);
3214	hrc = setErrorBoth(E_FAIL, ErrInfo.Core.rc, tr("The installation hook failed: %Rrc - %s"),
3215	ErrInfo.Core.rc, ErrInfo.Core.pszMsg);
3216	}
3217	}
3218	else if (SUCCEEDED(hrc))
3219	hrc = setError(E_FAIL, tr("Installing extension pack '%s' failed under mysterious circumstances"),
3220	pStrName->c_str());
3221	}
3222	else
3223	{
3224	ErrorInfoKeeper Eik;
3225	i_refreshExtPack(pStrName->c_str(), false /a_fUnusableIsError/, NULL);
3226	}
3227	}
3228
3229	/*
3230	* Do VirtualBoxReady callbacks now for any freshly installed
3231	* extension pack (old ones will not be called).
3232	*/
3233	if (m->enmContext == VBOXEXTPACKCTX_PER_USER_DAEMON)
3234	{
3235	autoLock.release();
3236	i_callAllVirtualBoxReadyHooks();
3237	}
3238	}
3239
3240	return hrc;
3241	}
3242
3243	/**
3244	* Worker for IExtPackManager::Uninstall.
3245	*
3246	* Called on a worker thread via doUninstallThreadProc.
3247	*
3248	* @returns COM status code.
3249	* @param a_pstrName The name of the extension pack to uninstall.
3250	* @param a_fForcedRemoval Whether to be skip and ignore certain bits of
3251	* the extpack feedback. To deal with misbehaving
3252	* extension pack hooks.
3253	* @param a_pstrDisplayInfo Host specific display information hacks.
3254	*/
3255	HRESULT ExtPackManager::i_doUninstall(Utf8Str const a_pstrName, bool a_fForcedRemoval, Utf8Str const a_pstrDisplayInfo)
3256	{
3257	Assert(m->enmContext == VBOXEXTPACKCTX_PER_USER_DAEMON);
3258
3259	AutoCaller autoCaller(this);
3260	HRESULT hrc = autoCaller.hrc();
3261	if (SUCCEEDED(hrc))
3262	{
3263	AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS);
3264
3265	/*
3266	* Refresh the data we have on the extension pack as it
3267	* may be made stale by direct meddling or some other user.
3268	*/
3269	ExtPack *pExtPack;
3270	hrc = i_refreshExtPack(a_pstrName->c_str(), false /a_fUnusableIsError/, &pExtPack);
3271	if (SUCCEEDED(hrc) && pExtPack)
3272	{
3273	/* We must leave the lock when calling i_areThereAnyRunningVMs,
3274	which means we have to redo the refresh call afterwards. */
3275	autoLock.release();
3276	bool fRunningVMs = i_areThereAnyRunningVMs();
3277	bool fVetoingCP = pExtPack->i_areThereCloudProviderUninstallVetos();
3278	bool fUnloadedCryptoMod = m->pVirtualBox->i_unloadCryptoIfModule() == S_OK;
3279	autoLock.acquire();
3280	if (a_fForcedRemoval \|\| (!fRunningVMs && !fVetoingCP && fUnloadedCryptoMod))
3281	{
3282	hrc = i_refreshExtPack(a_pstrName->c_str(), false /a_fUnusableIsError/, &pExtPack);
3283	if (SUCCEEDED(hrc))
3284	{
3285	if (!pExtPack)
3286	{
3287	LogRel(("ExtPackManager: Extension pack '%s' is not installed, so nothing to uninstall.\n", a_pstrName->c_str()));
3288	hrc = S_OK; /* nothing to uninstall */
3289	}
3290	else
3291	{
3292	/*
3293	* Call the uninstall hook and unload the main dll.
3294	*/
3295	hrc = pExtPack->i_callUninstallHookAndClose(m->pVirtualBox, a_fForcedRemoval);
3296	if (SUCCEEDED(hrc))
3297	{
3298	/*
3299	* Run the set-uid-to-root binary that performs the
3300	* uninstallation. Then refresh the object.
3301	*
3302	* This refresh is theorically subject to races, but it's of
3303	* the don't-do-that variety.
3304	*/
3305	const char *pszForcedOpt = a_fForcedRemoval ? "--forced" : NULL;
3306	hrc = i_runSetUidToRootHelper(a_pstrDisplayInfo,
3307	"uninstall",
3308	"--base-dir", m->strBaseDir.c_str(),
3309	"--name", a_pstrName->c_str(),
3310	pszForcedOpt, /* Last as it may be NULL. */
3311	(const char *)NULL);
3312	if (SUCCEEDED(hrc))
3313	{
3314	hrc = i_refreshExtPack(a_pstrName->c_str(), false /a_fUnusableIsError/, &pExtPack);
3315	if (SUCCEEDED(hrc))
3316	{
3317	if (!pExtPack)
3318	{
3319	LogRel(("ExtPackManager: Successfully uninstalled extension pack '%s'.\n", a_pstrName->c_str()));
3320	m->pVirtualBox->i_onExtPackInstalled(*a_pstrName);
3321	}
3322	else
3323	hrc = setError(E_FAIL,
3324	tr("Uninstall extension pack '%s' failed under mysterious circumstances"),
3325	a_pstrName->c_str());
3326	}
3327	}
3328	else
3329	{
3330	ErrorInfoKeeper Eik;
3331	i_refreshExtPack(a_pstrName->c_str(), false /a_fUnusableIsError/, NULL);
3332	}
3333	}
3334	}
3335	}
3336	}
3337	else
3338	{
3339	if (fRunningVMs)
3340	{
3341	LogRel(("Uninstall extension pack '%s' failed because at least one VM is still running.", a_pstrName->c_str()));
3342	hrc = setError(E_FAIL, tr("Uninstall extension pack '%s' failed because at least one VM is still running"),
3343	a_pstrName->c_str());
3344	}
3345	else if (fVetoingCP)
3346	{
3347	LogRel(("Uninstall extension pack '%s' failed because at least one Cloud Provider is still busy.", a_pstrName->c_str()));
3348	hrc = setError(E_FAIL, tr("Uninstall extension pack '%s' failed because at least one Cloud Provider is still busy"),
3349	a_pstrName->c_str());
3350	}
3351	else if (!fUnloadedCryptoMod)
3352	{
3353	LogRel(("Uninstall extension pack '%s' failed because the cryptographic support module is still in use.", a_pstrName->c_str()));
3354	hrc = setError(E_FAIL, tr("Uninstall extension pack '%s' failed because the cryptographic support module is still in use"),
3355	a_pstrName->c_str());
3356	}
3357	else
3358	{
3359	LogRel(("Uninstall extension pack '%s' failed for an unknown reason.", a_pstrName->c_str()));
3360	hrc = setError(E_FAIL, tr("Uninstall extension pack '%s' failed for an unknown reason"),
3361	a_pstrName->c_str());
3362
3363	}
3364	}
3365	}
3366	else if (SUCCEEDED(hrc) && !pExtPack)
3367	{
3368	hrc = setError(E_FAIL, tr("Extension pack '%s' is not installed.\n"), a_pstrName->c_str());
3369	}
3370
3371	/*
3372	* Do VirtualBoxReady callbacks now for any freshly installed
3373	* extension pack (old ones will not be called).
3374	*/
3375	if (m->enmContext == VBOXEXTPACKCTX_PER_USER_DAEMON)
3376	{
3377	autoLock.release();
3378	i_callAllVirtualBoxReadyHooks();
3379	}
3380	}
3381
3382	return hrc;
3383	}
3384
3385
3386	/**
3387	* Calls the pfnVirtualBoxReady hook for all working extension packs.
3388	*
3389	* @remarks The caller must not hold any locks.
3390	*/
3391	void ExtPackManager::i_callAllVirtualBoxReadyHooks(void)
3392	{
3393	AutoCaller autoCaller(this);
3394	HRESULT hrc = autoCaller.hrc();
3395	if (FAILED(hrc))
3396	return;
3397	AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS);
3398	ComPtr<ExtPackManager> ptrSelfRef = this;
3399
3400	for (ExtPackList::iterator it = m->llInstalledExtPacks.begin();
3401	it != m->llInstalledExtPacks.end();
3402	/* advancing below */)
3403	{
3404	if ((*it)->i_callVirtualBoxReadyHook(m->pVirtualBox, &autoLock))
3405	it = m->llInstalledExtPacks.begin();
3406	else
3407	++it;
3408	}
3409	}
3410
3411
3412	/**
3413	* Queries objects of type @a aObjUuid from all the extension packs.
3414	*
3415	* @returns COM status code.
3416	* @param aObjUuid The UUID of the kind of objects we're querying.
3417	* @param aObjects Where to return the objects.
3418	* @param a_pstrExtPackNames Where to return the corresponding extpack names (may be NULL).
3419	*
3420	* @remarks The caller must not hold any locks.
3421	*/
3422	HRESULT ExtPackManager::i_queryObjects(const com::Utf8Str &aObjUuid, std::vector<ComPtr<IUnknown> > &aObjects, std::vector<com::Utf8Str> *a_pstrExtPackNames)
3423	{
3424	aObjects.clear();
3425	if (a_pstrExtPackNames)
3426	a_pstrExtPackNames->clear();
3427
3428	AutoCaller autoCaller(this);
3429	HRESULT hrc = autoCaller.hrc();
3430	if (SUCCEEDED(hrc))
3431	{
3432	AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS);
3433	ComPtr<ExtPackManager> ptrSelfRef = this;
3434
3435	for (ExtPackList::iterator it = m->llInstalledExtPacks.begin();
3436	it != m->llInstalledExtPacks.end();
3437	++it)
3438	{
3439	ComPtr<IUnknown> ptrIf;
3440	HRESULT hrc2 = (*it)->queryObject(aObjUuid, ptrIf);
3441	if (SUCCEEDED(hrc2))
3442	{
3443	aObjects.push_back(ptrIf);
3444	if (a_pstrExtPackNames)
3445	a_pstrExtPackNames->push_back((*it)->m->Desc.strName);
3446	}
3447	else if (hrc2 != E_NOINTERFACE)
3448	hrc = hrc2;
3449	}
3450
3451	if (aObjects.size() > 0)
3452	hrc = S_OK;
3453	}
3454	return hrc;
3455	}
3456
3457	#endif /* !VBOX_COM_INPROC */
3458
3459	#ifdef VBOX_COM_INPROC
3460	/**
3461	* Calls the pfnConsoleReady hook for all working extension packs.
3462	*
3463	* @param a_pConsole The console interface.
3464	* @remarks The caller must not hold any locks.
3465	*/
3466	void ExtPackManager::i_callAllConsoleReadyHooks(IConsole *a_pConsole)
3467	{
3468	AutoCaller autoCaller(this);
3469	HRESULT hrc = autoCaller.hrc();
3470	if (FAILED(hrc))
3471	return;
3472	AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS);
3473	ComPtr<ExtPackManager> ptrSelfRef = this;
3474
3475	for (ExtPackList::iterator it = m->llInstalledExtPacks.begin();
3476	it != m->llInstalledExtPacks.end();
3477	/* advancing below */)
3478	{
3479	if ((*it)->i_callConsoleReadyHook(a_pConsole, &autoLock))
3480	it = m->llInstalledExtPacks.begin();
3481	else
3482	++it;
3483	}
3484	}
3485	#endif
3486
3487	#ifndef VBOX_COM_INPROC
3488	/**
3489	* Calls the pfnVMCreated hook for all working extension packs.
3490	*
3491	* @param a_pMachine The machine interface of the new VM.
3492	*/
3493	void ExtPackManager::i_callAllVmCreatedHooks(IMachine *a_pMachine)
3494	{
3495	AutoCaller autoCaller(this);
3496	HRESULT hrc = autoCaller.hrc();
3497	if (FAILED(hrc))
3498	return;
3499	AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS);
3500	ComPtr<ExtPackManager> ptrSelfRef = this; /* paranoia */
3501	ExtPackList llExtPacks = m->llInstalledExtPacks;
3502
3503	for (ExtPackList::iterator it = llExtPacks.begin(); it != llExtPacks.end(); ++it)
3504	(*it)->i_callVmCreatedHook(m->pVirtualBox, a_pMachine, &autoLock);
3505	}
3506	#endif
3507
3508	#ifdef VBOX_COM_INPROC
3509
3510	/**
3511	* Calls the pfnVMConfigureVMM hook for all working extension packs.
3512	*
3513	* @returns VBox status code. Stops on the first failure, expecting the caller
3514	* to signal this to the caller of the CFGM constructor.
3515	* @param a_pConsole The console interface for the VM.
3516	* @param a_pVM The VM handle.
3517	* @param a_pVMM The VMM function table.
3518	*/
3519	int ExtPackManager::i_callAllVmConfigureVmmHooks(IConsole *a_pConsole, PVM a_pVM, PCVMMR3VTABLE a_pVMM)
3520	{
3521	AutoCaller autoCaller(this);
3522	HRESULT hrc = autoCaller.hrc();
3523	if (FAILED(hrc))
3524	return Global::vboxStatusCodeFromCOM(hrc);
3525	AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS);
3526	ComPtr<ExtPackManager> ptrSelfRef = this; /* paranoia */
3527	ExtPackList llExtPacks = m->llInstalledExtPacks;
3528
3529	for (ExtPackList::iterator it = llExtPacks.begin(); it != llExtPacks.end(); ++it)
3530	{
3531	int vrc;
3532	(*it)->i_callVmConfigureVmmHook(a_pConsole, a_pVM, a_pVMM, &autoLock, &vrc);
3533	if (RT_FAILURE(vrc))
3534	return vrc;
3535	}
3536
3537	return VINF_SUCCESS;
3538	}
3539
3540	/**
3541	* Calls the pfnVMPowerOn hook for all working extension packs.
3542	*
3543	* @returns VBox status code. Stops on the first failure, expecting the caller
3544	* to not power on the VM.
3545	* @param a_pConsole The console interface for the VM.
3546	* @param a_pVM The VM handle.
3547	* @param a_pVMM The VMM function table.
3548	*/
3549	int ExtPackManager::i_callAllVmPowerOnHooks(IConsole *a_pConsole, PVM a_pVM, PCVMMR3VTABLE a_pVMM)
3550	{
3551	AutoCaller autoCaller(this);
3552	HRESULT hrc = autoCaller.hrc();
3553	if (FAILED(hrc))
3554	return Global::vboxStatusCodeFromCOM(hrc);
3555	AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS);
3556	ComPtr<ExtPackManager> ptrSelfRef = this; /* paranoia */
3557	ExtPackList llExtPacks = m->llInstalledExtPacks;
3558
3559	for (ExtPackList::iterator it = llExtPacks.begin(); it != llExtPacks.end(); ++it)
3560	{
3561	int vrc;
3562	(*it)->i_callVmPowerOnHook(a_pConsole, a_pVM, a_pVMM, &autoLock, &vrc);
3563	if (RT_FAILURE(vrc))
3564	return vrc;
3565	}
3566
3567	return VINF_SUCCESS;
3568	}
3569
3570	/**
3571	* Calls the pfnVMPowerOff hook for all working extension packs.
3572	*
3573	* @param a_pConsole The console interface for the VM.
3574	* @param a_pVM The VM handle. Can be NULL.
3575	* @param a_pVMM The VMM function table.
3576	*/
3577	void ExtPackManager::i_callAllVmPowerOffHooks(IConsole *a_pConsole, PVM a_pVM, PCVMMR3VTABLE a_pVMM)
3578	{
3579	AutoCaller autoCaller(this);
3580	HRESULT hrc = autoCaller.hrc();
3581	if (FAILED(hrc))
3582	return;
3583	AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS);
3584	ComPtr<ExtPackManager> ptrSelfRef = this; /* paranoia */
3585	ExtPackList llExtPacks = m->llInstalledExtPacks;
3586
3587	for (ExtPackList::iterator it = llExtPacks.begin(); it != llExtPacks.end(); ++it)
3588	(*it)->i_callVmPowerOffHook(a_pConsole, a_pVM, a_pVMM, &autoLock);
3589	}
3590
3591	#endif /* VBOX_COM_INPROC */
3592
3593	/**
3594	* Checks that the specified extension pack contains a VRDE module and that it
3595	* is shipshape.
3596	*
3597	* @returns S_OK if ok, appropriate failure status code with details.
3598	* @param a_pstrExtPack The name of the extension pack.
3599	*/
3600	HRESULT ExtPackManager::i_checkVrdeExtPack(Utf8Str const *a_pstrExtPack)
3601	{
3602	AutoCaller autoCaller(this);
3603	HRESULT hrc = autoCaller.hrc();
3604	if (SUCCEEDED(hrc))
3605	{
3606	AutoReadLock autoLock(this COMMA_LOCKVAL_SRC_POS);
3607
3608	ExtPack *pExtPack = i_findExtPack(a_pstrExtPack->c_str());
3609	if (pExtPack)
3610	hrc = pExtPack->i_checkVrde();
3611	else
3612	hrc = setError(VBOX_E_OBJECT_NOT_FOUND, tr("No extension pack by the name '%s' was found"), a_pstrExtPack->c_str());
3613	}
3614
3615	return hrc;
3616	}
3617
3618	/**
3619	* Gets the full path to the VRDE library of the specified extension pack.
3620	*
3621	* This will do extacly the same as checkVrdeExtPack and then resolve the
3622	* library path.
3623	*
3624	* @returns VINF_SUCCESS if a path is returned, VBox error status and message
3625	* return if not.
3626	* @param a_pstrExtPack The extension pack.
3627	* @param a_pstrVrdeLibrary Where to return the path.
3628	*/
3629	int ExtPackManager::i_getVrdeLibraryPathForExtPack(Utf8Str const a_pstrExtPack, Utf8Str a_pstrVrdeLibrary)
3630	{
3631	AutoCaller autoCaller(this);
3632	HRESULT hrc = autoCaller.hrc();
3633	if (SUCCEEDED(hrc))
3634	{
3635	AutoReadLock autoLock(this COMMA_LOCKVAL_SRC_POS);
3636
3637	ExtPack *pExtPack = i_findExtPack(a_pstrExtPack->c_str());
3638	if (pExtPack)
3639	hrc = pExtPack->i_getVrdpLibraryName(a_pstrVrdeLibrary);
3640	else
3641	hrc = setError(VBOX_E_OBJECT_NOT_FOUND, tr("No extension pack by the name '%s' was found"),
3642	a_pstrExtPack->c_str());
3643	}
3644
3645	return Global::vboxStatusCodeFromCOM(hrc);
3646	}
3647
3648	/**
3649	* Checks that the specified extension pack contains a cryptographic module and that it
3650	* is shipshape.
3651	*
3652	* @returns S_OK if ok, appropriate failure status code with details.
3653	* @param a_pstrExtPack The name of the extension pack.
3654	*/
3655	HRESULT ExtPackManager::i_checkCryptoExtPack(Utf8Str const *a_pstrExtPack)
3656	{
3657	AutoCaller autoCaller(this);
3658	HRESULT hrc = autoCaller.hrc();
3659	if (SUCCEEDED(hrc))
3660	{
3661	AutoReadLock autoLock(this COMMA_LOCKVAL_SRC_POS);
3662
3663	ExtPack *pExtPack = i_findExtPack(a_pstrExtPack->c_str());
3664	if (pExtPack)
3665	hrc = pExtPack->i_checkCrypto();
3666	else
3667	hrc = setError(VBOX_E_OBJECT_NOT_FOUND, tr("No extension pack by the name '%s' was found"), a_pstrExtPack->c_str());
3668	}
3669
3670	return hrc;
3671	}
3672
3673	/**
3674	* Gets the full path to the cryptographic library of the specified extension pack.
3675	*
3676	* This will do extacly the same as checkCryptoExtPack and then resolve the
3677	* library path.
3678	*
3679	* @returns VINF_SUCCESS if a path is returned, VBox error status and message
3680	* return if not.
3681	* @param a_pstrExtPack The extension pack.
3682	* @param a_pstrCryptoLibrary Where to return the path.
3683	*/
3684	int ExtPackManager::i_getCryptoLibraryPathForExtPack(Utf8Str const a_pstrExtPack, Utf8Str a_pstrCryptoLibrary)
3685	{
3686	AutoCaller autoCaller(this);
3687	HRESULT hrc = autoCaller.hrc();
3688	if (SUCCEEDED(hrc))
3689	{
3690	AutoReadLock autoLock(this COMMA_LOCKVAL_SRC_POS);
3691
3692	ExtPack *pExtPack = i_findExtPack(a_pstrExtPack->c_str());
3693	if (pExtPack)
3694	hrc = pExtPack->i_getCryptoLibraryName(a_pstrCryptoLibrary);
3695	else
3696	hrc = setError(VBOX_E_OBJECT_NOT_FOUND, tr("No extension pack by the name '%s' was found"),
3697	a_pstrExtPack->c_str());
3698	}
3699
3700	return Global::vboxStatusCodeFromCOM(hrc);
3701	}
3702
3703
3704	/**
3705	* Gets the full path to the specified library of the specified extension pack.
3706	*
3707	* @returns S_OK if a path is returned, COM error status and message return if
3708	* not.
3709	* @param a_pszModuleName The library.
3710	* @param a_pszExtPack The extension pack.
3711	* @param a_pstrLibrary Where to return the path.
3712	*/
3713	HRESULT ExtPackManager::i_getLibraryPathForExtPack(const char a_pszModuleName, const char a_pszExtPack, Utf8Str *a_pstrLibrary)
3714	{
3715	AutoCaller autoCaller(this);
3716	HRESULT hrc = autoCaller.hrc();
3717	if (SUCCEEDED(hrc))
3718	{
3719	AutoReadLock autoLock(this COMMA_LOCKVAL_SRC_POS);
3720
3721	ExtPack *pExtPack = i_findExtPack(a_pszExtPack);
3722	if (pExtPack)
3723	hrc = pExtPack->i_getLibraryName(a_pszModuleName, a_pstrLibrary);
3724	else
3725	hrc = setError(VBOX_E_OBJECT_NOT_FOUND, tr("No extension pack by the name '%s' was found"), a_pszExtPack);
3726	}
3727
3728	return hrc;
3729	}
3730
3731	/**
3732	* Gets the name of the default VRDE extension pack.
3733	*
3734	* @returns S_OK or some COM error status on red tape failure.
3735	* @param a_pstrExtPack Where to return the extension pack name. Returns
3736	* empty if no extension pack wishes to be the default
3737	* VRDP provider.
3738	*/
3739	HRESULT ExtPackManager::i_getDefaultVrdeExtPack(Utf8Str *a_pstrExtPack)
3740	{
3741	a_pstrExtPack->setNull();
3742
3743	AutoCaller autoCaller(this);
3744	HRESULT hrc = autoCaller.hrc();
3745	if (SUCCEEDED(hrc))
3746	{
3747	AutoReadLock autoLock(this COMMA_LOCKVAL_SRC_POS);
3748
3749	for (ExtPackList::iterator it = m->llInstalledExtPacks.begin();
3750	it != m->llInstalledExtPacks.end();
3751	++it)
3752	{
3753	if ((*it)->i_wantsToBeDefaultVrde())
3754	{
3755	a_pstrExtPack = (it)->m->Desc.strName;
3756	break;
3757	}
3758	}
3759	}
3760	return hrc;
3761	}
3762
3763	/**
3764	* Gets the name of the default cryptographic extension pack.
3765	*
3766	* @returns S_OK or some COM error status on red tape failure.
3767	* @param a_pstrExtPack Where to return the extension pack name. Returns
3768	* empty if no extension pack wishes to be the default
3769	* VRDP provider.
3770	*/
3771	HRESULT ExtPackManager::i_getDefaultCryptoExtPack(Utf8Str *a_pstrExtPack)
3772	{
3773	a_pstrExtPack->setNull();
3774
3775	AutoCaller autoCaller(this);
3776	HRESULT hrc = autoCaller.hrc();
3777	if (SUCCEEDED(hrc))
3778	{
3779	AutoReadLock autoLock(this COMMA_LOCKVAL_SRC_POS);
3780
3781	for (ExtPackList::iterator it = m->llInstalledExtPacks.begin();
3782	it != m->llInstalledExtPacks.end();
3783	++it)
3784	{
3785	if ((*it)->i_wantsToBeDefaultCrypto())
3786	{
3787	a_pstrExtPack = (it)->m->Desc.strName;
3788	break;
3789	}
3790	}
3791	}
3792	return hrc;
3793	}
3794
3795	/**
3796	* Checks if an extension pack is (present and) usable.
3797	*
3798	* @returns @c true if it is, otherwise @c false.
3799	* @param a_pszExtPack The name of the extension pack.
3800	*/
3801	bool ExtPackManager::i_isExtPackUsable(const char *a_pszExtPack)
3802	{
3803	AutoCaller autoCaller(this);
3804	HRESULT hrc = autoCaller.hrc();
3805	if (FAILED(hrc))
3806	return false;
3807	AutoReadLock autoLock(this COMMA_LOCKVAL_SRC_POS);
3808
3809	ExtPack *pExtPack = i_findExtPack(a_pszExtPack);
3810	return pExtPack != NULL
3811	&& pExtPack->m->fUsable;
3812	}
3813
3814	/**
3815	* Dumps all extension packs to the release log.
3816	*/
3817	void ExtPackManager::i_dumpAllToReleaseLog(void)
3818	{
3819	AutoCaller autoCaller(this);
3820	HRESULT hrc = autoCaller.hrc();
3821	if (FAILED(hrc))
3822	return;
3823	AutoReadLock autoLock(this COMMA_LOCKVAL_SRC_POS);
3824
3825	LogRel(("Installed Extension Packs:\n"));
3826	for (ExtPackList::iterator it = m->llInstalledExtPacks.begin();
3827	it != m->llInstalledExtPacks.end();
3828	++it)
3829	{
3830	ExtPack::Data pExtPackData = (it)->m;
3831	if (pExtPackData)
3832	{
3833	if (pExtPackData->fUsable)
3834	LogRel((" %s (Version: %s r%u%s%s; VRDE Module: %s; Crypto Module: %s)\n",
3835	pExtPackData->Desc.strName.c_str(),
3836	pExtPackData->Desc.strVersion.c_str(),
3837	pExtPackData->Desc.uRevision,
3838	pExtPackData->Desc.strEdition.isEmpty() ? "" : " ",
3839	pExtPackData->Desc.strEdition.c_str(),
3840	pExtPackData->Desc.strVrdeModule.c_str(),
3841	pExtPackData->Desc.strCryptoModule.c_str() ));
3842	else
3843	LogRel((" %s (Version: %s r%u%s%s; VRDE Module: %s; Crypto Module: %s unusable because of '%s')\n",
3844	pExtPackData->Desc.strName.c_str(),
3845	pExtPackData->Desc.strVersion.c_str(),
3846	pExtPackData->Desc.uRevision,
3847	pExtPackData->Desc.strEdition.isEmpty() ? "" : " ",
3848	pExtPackData->Desc.strEdition.c_str(),
3849	pExtPackData->Desc.strVrdeModule.c_str(),
3850	pExtPackData->Desc.strCryptoModule.c_str(),
3851	pExtPackData->strWhyUnusable.c_str() ));
3852	}
3853	else
3854	LogRel((" pExtPackData is NULL\n"));
3855	}
3856
3857	if (!m->llInstalledExtPacks.size())
3858	LogRel((" None installed!\n"));
3859	}
3860
3861	/**
3862	* Gets the update counter (reflecting extpack list updates).
3863	*/
3864	uint64_t ExtPackManager::i_getUpdateCounter(void)
3865	{
3866	AutoCaller autoCaller(this);
3867	HRESULT hrc = autoCaller.hrc();
3868	if (FAILED(hrc))
3869	return 0;
3870	AutoReadLock autoLock(this COMMA_LOCKVAL_SRC_POS);
3871	return m->cUpdate;
3872	}
3873
3874	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/src-all/ExtPackManagerImpl.cpp@ 104507

Download in other formats: