VirtualBox

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

Last change on this file since 67954 was 66294, checked in by vboxsync, 8 years ago

ExtPackManagerImpl.cpp: Must not hold the extpack manager lock when calling i_areThereAnyRunningVMs() or we trigger a lock order violation.

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette