ExtPackManagerImpl.cpp@ 91322

Last change on this file since 91322 was 91322, checked in by vboxsync, 4 years ago
Main: bugref:1909: Fixed SEGFAULT when extpack plugin is not loaded but NLS is enabled
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 125.2 KB

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

Download in other formats: