VirtualBoxClientImpl.cpp@ 105978

Last change on this file since 105978 was 98103, checked in by vboxsync, 23 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 31.7 KB

Line
1	/* $Id: VirtualBoxClientImpl.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* VirtualBox COM class implementation
4	*/
5
6	/*
7	* Copyright (C) 2010-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28	#define LOG_GROUP LOG_GROUP_MAIN_VIRTUALBOXCLIENT
29	#include "LoggingNew.h"
30
31	#include "VirtualBoxClientImpl.h"
32
33	#include "AutoCaller.h"
34	#include "VBoxEvents.h"
35	#include "VBox/com/ErrorInfo.h"
36	#include "VBox/com/listeners.h"
37
38	#include <iprt/asm.h>
39	#include <iprt/thread.h>
40	#include <iprt/critsect.h>
41	#include <iprt/path.h>
42	#include <iprt/semaphore.h>
43	#include <iprt/cpp/utils.h>
44	#include <iprt/utf16.h>
45	#ifdef RT_OS_WINDOWS
46	# include <iprt/err.h>
47	# include <iprt/ldr.h>
48	# include <msi.h>
49	# include <WbemIdl.h>
50	#endif
51
52	#include <new>
53
54
55	/** Waiting time between probing whether VBoxSVC is alive. */
56	#define VBOXCLIENT_DEFAULT_INTERVAL 30000
57
58
59	/** Initialize instance counter class variable */
60	uint32_t VirtualBoxClient::g_cInstances = 0;
61
62	LONG VirtualBoxClient::s_cUnnecessaryAtlModuleLocks = 0;
63
64	#ifdef VBOX_WITH_MAIN_NLS
65
66	/* listener class for language updates */
67	class VBoxEventListener
68	{
69	public:
70	VBoxEventListener()
71	{}
72
73
74	HRESULT init(void *)
75	{
76	return S_OK;
77	}
78
79	HRESULT init()
80	{
81	return S_OK;
82	}
83
84	void uninit()
85	{
86	}
87
88	virtual ~VBoxEventListener()
89	{
90	}
91
92	STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent *aEvent)
93	{
94	switch(aType)
95	{
96	case VBoxEventType_OnLanguageChanged:
97	{
98	/*
99	* Proceed with uttmost care as we might be racing com::Shutdown()
100	* and have the ground open up beneath us.
101	*/
102	LogFunc(("VBoxEventType_OnLanguageChanged\n"));
103	VirtualBoxTranslator *pTranslator = VirtualBoxTranslator::tryInstance();
104	if (pTranslator)
105	{
106	ComPtr<ILanguageChangedEvent> pEvent = aEvent;
107	Assert(pEvent);
108
109	/* This call may fail if we're racing COM shutdown. */
110	com::Bstr bstrLanguageId;
111	HRESULT hrc = pEvent->COMGETTER(LanguageId)(bstrLanguageId.asOutParam());
112	if (SUCCEEDED(hrc))
113	{
114	try
115	{
116	com::Utf8Str strLanguageId(bstrLanguageId);
117	LogFunc(("New language ID: %s\n", strLanguageId.c_str()));
118	pTranslator->i_loadLanguage(strLanguageId.c_str());
119	}
120	catch (std::bad_alloc &)
121	{
122	LogFunc(("Caught bad_alloc"));
123	}
124	}
125	else
126	LogFunc(("Failed to get new language ID: %Rhrc\n", hrc));
127
128	pTranslator->release();
129	}
130	break;
131	}
132
133	default:
134	AssertFailed();
135	}
136
137	return S_OK;
138	}
139	};
140
141	typedef ListenerImpl<VBoxEventListener> VBoxEventListenerImpl;
142
143	VBOX_LISTENER_DECLARE(VBoxEventListenerImpl)
144
145	#endif /* VBOX_WITH_MAIN_NLS */
146
147	// constructor / destructor
148	/////////////////////////////////////////////////////////////////////////////
149
150	/** @relates VirtualBoxClient::FinalConstruct() */
151	HRESULT VirtualBoxClient::FinalConstruct()
152	{
153	HRESULT hrc = init();
154	BaseFinalConstruct();
155	return hrc;
156	}
157
158	void VirtualBoxClient::FinalRelease()
159	{
160	uninit();
161	BaseFinalRelease();
162	}
163
164
165	// public initializer/uninitializer for internal purposes only
166	/////////////////////////////////////////////////////////////////////////////
167
168	/**
169	* Initializes the VirtualBoxClient object.
170	*
171	* @returns COM result indicator
172	*/
173	HRESULT VirtualBoxClient::init()
174	{
175	LogFlowThisFuncEnter();
176
177	/* Enclose the state transition NotReady->InInit->Ready */
178	AutoInitSpan autoInitSpan(this);
179	AssertReturn(autoInitSpan.isOk(), E_FAIL);
180
181	/* Important: DO NOT USE any kind of "early return" (except the single
182	* one above, checking the init span success) in this method. It is vital
183	* for correct error handling that it has only one point of return, which
184	* does all the magic on COM to signal object creation success and
185	* reporting the error later for every API method. COM translates any
186	* unsuccessful object creation to REGDB_E_CLASSNOTREG errors or similar
187	* unhelpful ones which cause us a lot of grief with troubleshooting. */
188
189	HRESULT hrc = S_OK;
190	try
191	{
192	if (ASMAtomicIncU32(&g_cInstances) != 1)
193	AssertFailedStmt(throw setError(E_FAIL, "Attempted to create more than one VirtualBoxClient instance"));
194
195	mData.m_ThreadWatcher = NIL_RTTHREAD;
196	mData.m_SemEvWatcher = NIL_RTSEMEVENT;
197
198	hrc = mData.m_pVirtualBox.createLocalObject(CLSID_VirtualBox);
199	if (FAILED(hrc))
200	#ifdef RT_OS_WINDOWS
201	throw i_investigateVirtualBoxObjectCreationFailure(hrc);
202	#else
203	throw hrc;
204	#endif
205
206	/* VirtualBox error return is postponed to method calls, fetch it. */
207	ULONG rev;
208	hrc = mData.m_pVirtualBox->COMGETTER(Revision)(&rev);
209	if (FAILED(hrc))
210	throw hrc;
211
212	hrc = unconst(mData.m_pEventSource).createObject();
213	AssertComRCThrow(hrc, setError(hrc, "Could not create EventSource for VirtualBoxClient"));
214	hrc = mData.m_pEventSource->init();
215	AssertComRCThrow(hrc, setError(hrc, "Could not initialize EventSource for VirtualBoxClient"));
216
217	/* HACK ALERT! This is for DllCanUnloadNow(). */
218	s_cUnnecessaryAtlModuleLocks++;
219	AssertMsg(s_cUnnecessaryAtlModuleLocks == 1, ("%d\n", s_cUnnecessaryAtlModuleLocks));
220
221	int vrc;
222	#ifdef VBOX_WITH_MAIN_NLS
223	/* Create the translator singelton (must work) and try load translations (non-fatal). */
224	mData.m_pVBoxTranslator = VirtualBoxTranslator::instance();
225	if (mData.m_pVBoxTranslator == NULL)
226	throw setError(VBOX_E_IPRT_ERROR, "Failed to create translator instance");
227
228	char szNlsPath[RTPATH_MAX];
229	vrc = RTPathAppPrivateNoArch(szNlsPath, sizeof(szNlsPath));
230	if (RT_SUCCESS(vrc))
231	vrc = RTPathAppend(szNlsPath, sizeof(szNlsPath), "nls" RTPATH_SLASH_STR "VirtualBoxAPI");
232
233	if (RT_SUCCESS(vrc))
234	{
235	vrc = mData.m_pVBoxTranslator->registerTranslation(szNlsPath, true, &mData.m_pTrComponent);
236	if (RT_SUCCESS(vrc))
237	{
238	hrc = i_reloadApiLanguage();
239	if (SUCCEEDED(hrc))
240	i_registerEventListener(); /* for updates */
241	else
242	LogRelFunc(("i_reloadApiLanguage failed: %Rhrc\n", hrc));
243	}
244	else
245	LogRelFunc(("Register translation failed: %Rrc\n", vrc));
246	}
247	else
248	LogRelFunc(("Path constructing failed: %Rrc\n", vrc));
249	#endif
250	/* Setting up the VBoxSVC watcher thread. If anything goes wrong here it
251	* is not considered important enough to cause any sort of visible
252	* failure. The monitoring will not be done, but that's all. */
253	vrc = RTSemEventCreate(&mData.m_SemEvWatcher);
254	if (RT_FAILURE(vrc))
255	{
256	mData.m_SemEvWatcher = NIL_RTSEMEVENT;
257	AssertRCStmt(vrc, throw setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Failed to create semaphore (vrc=%Rrc)"), vrc));
258	}
259
260	vrc = RTThreadCreate(&mData.m_ThreadWatcher, SVCWatcherThread, this, 0,
261	RTTHREADTYPE_INFREQUENT_POLLER, RTTHREADFLAGS_WAITABLE, "VBoxSVCWatcher");
262	if (RT_FAILURE(vrc))
263	{
264	RTSemEventDestroy(mData.m_SemEvWatcher);
265	mData.m_SemEvWatcher = NIL_RTSEMEVENT;
266	AssertRCStmt(vrc, throw setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Failed to create watcher thread (vrc=%Rrc)"), vrc));
267	}
268	}
269	catch (HRESULT err)
270	{
271	/* we assume that error info is set by the thrower */
272	hrc = err;
273	}
274	catch (...)
275	{
276	hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
277	}
278
279	/* Confirm a successful initialization when it's the case. Must be last,
280	* as on failure it will uninitialize the object. */
281	if (SUCCEEDED(hrc))
282	autoInitSpan.setSucceeded();
283	else
284	autoInitSpan.setFailed(hrc);
285
286	LogFlowThisFunc(("hrc=%Rhrc\n", hrc));
287	LogFlowThisFuncLeave();
288	/* Unconditionally return success, because the error return is delayed to
289	* the attribute/method calls through the InitFailed object state. */
290	return S_OK;
291	}
292
293	#ifdef RT_OS_WINDOWS
294
295	/**
296	* Looks into why we failed to create the VirtualBox object.
297	*
298	* @returns hrcCaller thru setError.
299	* @param hrcCaller The failure status code.
300	*/
301	HRESULT VirtualBoxClient::i_investigateVirtualBoxObjectCreationFailure(HRESULT hrcCaller)
302	{
303	HRESULT hrc;
304
305	# ifdef VBOX_WITH_SDS
306	/*
307	* Check that the VBoxSDS service is configured to run as LocalSystem and is enabled.
308	*/
309	WCHAR wszBuffer[256];
310	uint32_t uStartType;
311	int vrc = i_getServiceAccountAndStartType(L"VBoxSDS", wszBuffer, RT_ELEMENTS(wszBuffer), &uStartType);
312	if (RT_SUCCESS(vrc))
313	{
314	LogRelFunc(("VBoxSDS service is running under the '%ls' account with start type %u.\n", wszBuffer, uStartType));
315	if (RTUtf16Cmp(wszBuffer, L"LocalSystem") != 0)
316	return setError(hrcCaller,
317	tr("VBoxSDS is misconfigured to run under the '%ls' account instead of the SYSTEM one.\n"
318	"Reinstall VirtualBox to fix it. Alternatively you can fix it using the Windows Service Control "
319	"Manager or by running 'sc config VBoxSDS obj=LocalSystem' on a command line."), wszBuffer);
320	if (uStartType == SERVICE_DISABLED)
321	return setError(hrcCaller,
322	tr("The VBoxSDS windows service is disabled.\n"
323	"Reinstall VirtualBox to fix it. Alternatively try reenable the service by setting it to "
324	" 'Manual' startup type in the Windows Service management console, or by runing "
325	"'sc config VBoxSDS start=demand' on the command line."));
326	}
327	else if (vrc == VERR_NOT_FOUND)
328	return setError(hrcCaller,
329	tr("The VBoxSDS windows service was not found.\n"
330	"Reinstall VirtualBox to fix it. Alternatively you can try start VirtualBox as Administrator, this "
331	"should automatically reinstall the service, or you can run "
332	"'VBoxSDS.exe --regservice' command from an elevated Administrator command line."));
333	else
334	LogRelFunc(("VirtualBoxClient::i_getServiceAccount failed: %Rrc\n", vrc));
335	# endif
336
337	/*
338	* First step is to try get an IUnknown interface of the VirtualBox object.
339	*
340	* This will succeed even when oleaut32.msm (see @bugref{8016}, @ticketref{12087})
341	* is accidentally installed and messes up COM. It may also succeed when the COM
342	* registration is partially broken (though that's unlikely to happen these days).
343	*/
344	IUnknown *pUnknown = NULL;
345	hrc = CoCreateInstance(CLSID_VirtualBox, NULL, CLSCTX_LOCAL_SERVER, IID_IUnknown, (void **)&pUnknown);
346	if (FAILED(hrc))
347	{
348	if (hrc == hrcCaller)
349	return setError(hrcCaller, tr("Completely failed to instantiate CLSID_VirtualBox: %Rhrc"), hrcCaller);
350	return setError(hrcCaller, tr("Completely failed to instantiate CLSID_VirtualBox: %Rhrc & %Rhrc"), hrcCaller, hrc);
351	}
352
353	/*
354	* Try query the IVirtualBox interface (should fail), if it succeed we return
355	* straight away so we have more columns to spend on long messages below.
356	*/
357	IVirtualBox *pVirtualBox;
358	hrc = pUnknown->QueryInterface(IID_IVirtualBox, (void **)&pVirtualBox);
359	if (SUCCEEDED(hrc))
360	{
361	pVirtualBox->Release();
362	pUnknown->Release();
363	return setError(hrcCaller,
364	tr("Failed to instantiate CLSID_VirtualBox the first time, but worked when checking out why ... weird"));
365	}
366
367	/*
368	* Check for oleaut32.msm traces in the registry.
369	*/
370	HKEY hKey;
371	LSTATUS lrc = RegOpenKeyExW(HKEY_CLASSES_ROOT, L"CLSID\\{00020420-0000-0000-C000-000000000046}\\InprocServer32",
372	0 /fFlags/, KEY_QUERY_VALUE \| KEY_ENUMERATE_SUB_KEYS \| STANDARD_RIGHTS_READ, &hKey);
373	if (lrc == ERROR_SUCCESS)
374	{
375	wchar_t wszBuf[8192];
376	DWORD cbBuf = sizeof(wszBuf) - sizeof(wchar_t);
377	DWORD dwType = 0;
378	lrc = RegQueryValueExW(hKey, L"InprocServer32", NULL /pvReserved/, &dwType, (BYTE *)&wszBuf[0], &cbBuf);
379	if (lrc == ERROR_SUCCESS)
380	{
381	wszBuf[cbBuf / sizeof(wchar_t)] = '\0';
382	bool fSetError = false;
383
384	/*
385	* Try decode the string and improve the message.
386	*/
387	typedef UINT (WINAPI *PFNMSIDECOMPOSEDESCRIPTORW)(PCWSTR pwszDescriptor,
388	LPWSTR pwszProductCode /[40]/,
389	LPWSTR pwszFeatureId /[40]/,
390	LPWSTR pwszComponentCode /[40]/,
391	DWORD *poffArguments);
392	PFNMSIDECOMPOSEDESCRIPTORW pfnMsiDecomposeDescriptorW;
393	pfnMsiDecomposeDescriptorW = (PFNMSIDECOMPOSEDESCRIPTORW)RTLdrGetSystemSymbol("msi.dll", "MsiDecomposeDescriptorW");
394	if ( pfnMsiDecomposeDescriptorW
395	&& ( dwType == REG_SZ
396	\|\| dwType == REG_MULTI_SZ))
397	{
398	wchar_t wszProductCode[RTUUID_STR_LENGTH + 2 + 16] = { 0 };
399	wchar_t wszFeatureId[RTUUID_STR_LENGTH + 2 + 16] = { 0 };
400	wchar_t wszComponentCode[RTUUID_STR_LENGTH + 2 + 16] = { 0 };
401	DWORD offArguments = ~(DWORD)0;
402	UINT uRc = pfnMsiDecomposeDescriptorW(wszBuf, wszProductCode, wszFeatureId, wszComponentCode, &offArguments);
403	if (uRc == 0)
404	{
405	/*
406	* Can we resolve the product code into a name?
407	*/
408	typedef UINT (WINAPI PFNMSIOPENPRODUCTW)(PCWSTR, MSIHANDLE );
409	PFNMSIOPENPRODUCTW pfnMsiOpenProductW;
410	pfnMsiOpenProductW = (PFNMSIOPENPRODUCTW)RTLdrGetSystemSymbol("msi.dll", "MsiOpenProductW");
411
412	typedef UINT (WINAPI *PFNMSICLOSEHANDLE)(MSIHANDLE);
413	PFNMSICLOSEHANDLE pfnMsiCloseHandle;
414	pfnMsiCloseHandle = (PFNMSICLOSEHANDLE)RTLdrGetSystemSymbol("msi.dll", "MsiCloseHandle");
415
416	typedef UINT (WINAPI *PFNGETPRODUCTPROPERTYW)(MSIHANDLE, PCWSTR, PWSTR, PDWORD);
417	PFNGETPRODUCTPROPERTYW pfnMsiGetProductPropertyW;
418	pfnMsiGetProductPropertyW = (PFNGETPRODUCTPROPERTYW)RTLdrGetSystemSymbol("msi.dll", "MsiGetProductPropertyW");
419	if ( pfnMsiGetProductPropertyW
420	&& pfnMsiCloseHandle
421	&& pfnMsiOpenProductW)
422	{
423	MSIHANDLE hMsi = 0;
424	uRc = pfnMsiOpenProductW(wszProductCode, &hMsi);
425	if (uRc == 0)
426	{
427	static wchar_t const * const s_apwszProps[] =
428	{
429	INSTALLPROPERTY_INSTALLEDPRODUCTNAME,
430	INSTALLPROPERTY_PRODUCTNAME,
431	INSTALLPROPERTY_PACKAGENAME,
432	};
433
434	wchar_t wszProductName[1024];
435	DWORD cwcProductName;
436	unsigned i = 0;
437	do
438	{
439	cwcProductName = RT_ELEMENTS(wszProductName) - 1;
440	uRc = pfnMsiGetProductPropertyW(hMsi, s_apwszProps[i], wszProductName, &cwcProductName);
441	}
442	while ( ++i < RT_ELEMENTS(s_apwszProps)
443	&& ( uRc != 0
444	\|\| cwcProductName < 2
445	\|\| cwcProductName >= RT_ELEMENTS(wszProductName)) );
446	uRc = pfnMsiCloseHandle(hMsi);
447	if (uRc == 0 && cwcProductName >= 2)
448	{
449	wszProductName[RT_MIN(cwcProductName, RT_ELEMENTS(wszProductName) - 1)] = '\0';
450	setError(hrcCaller,
451	tr("Failed to instantiate CLSID_VirtualBox w/ IVirtualBox, but CLSID_VirtualBox w/ IUnknown works.\n"
452	"PSDispatch looks broken by the '%ls' (%ls) program, suspecting that it features the broken oleaut32.msm module as component %ls.\n"
453	"\n"
454	"We suggest you try uninstall '%ls'.\n"
455	"\n"
456	"See also https://support.microsoft.com/en-us/kb/316911 "),
457	wszProductName, wszProductCode, wszComponentCode, wszProductName);
458	fSetError = true;
459	}
460	}
461	}
462
463	/* MSI uses COM and may mess up our stuff. So, we wait with the fallback till afterwards in this case. */
464	if (!fSetError)
465	{
466	setError(hrcCaller,
467	tr("Failed to instantiate CLSID_VirtualBox w/ IVirtualBox, CLSID_VirtualBox w/ IUnknown works.\n"
468	"PSDispatch looks broken by installer %ls featuring the broken oleaut32.msm module as component %ls.\n"
469	"\n"
470	"See also https://support.microsoft.com/en-us/kb/316911 "),
471	wszProductCode, wszComponentCode);
472	fSetError = true;
473	}
474	}
475	}
476	if (!fSetError)
477	setError(hrcCaller, tr("Failed to instantiate CLSID_VirtualBox w/ IVirtualBox, CLSID_VirtualBox w/ IUnknown works.\n"
478	"PSDispatch looks broken by some installer featuring the broken oleaut32.msm module as a component.\n"
479	"\n"
480	"See also https://support.microsoft.com/en-us/kb/316911 "));
481	}
482	else if (lrc == ERROR_FILE_NOT_FOUND)
483	setError(hrcCaller, tr("Failed to instantiate CLSID_VirtualBox w/ IVirtualBox, but CLSID_VirtualBox w/ IUnknown works.\n"
484	"PSDispatch looks fine. Weird"));
485	else
486	setError(hrcCaller, tr("Failed to instantiate CLSID_VirtualBox w/ IVirtualBox, but CLSID_VirtualBox w/ IUnknown works.\n"
487	"Checking out PSDispatch registration ended with error: %u (%#x)"), lrc, lrc);
488	RegCloseKey(hKey);
489	}
490
491	pUnknown->Release();
492	return hrcCaller;
493	}
494
495	# ifdef VBOX_WITH_SDS
496	/**
497	* Gets the service account name and start type for the given service.
498	*
499	* @returns IPRT status code (for some reason).
500	* @param pwszServiceName The name of the service.
501	* @param pwszAccountName Where to return the account name.
502	* @param cwcAccountName The length of the account name buffer (in WCHARs).
503	* @param puStartType Where to return the start type.
504	*/
505	int VirtualBoxClient::i_getServiceAccountAndStartType(const wchar_t *pwszServiceName,
506	wchar_t pwszAccountName, size_t cwcAccountName, uint32_t puStartType)
507	{
508	AssertPtr(pwszServiceName);
509	AssertPtr(pwszAccountName);
510	Assert(cwcAccountName);
511	*pwszAccountName = '\0';
512	*puStartType = SERVICE_DEMAND_START;
513
514	int vrc;
515
516	// Get a handle to the SCM database.
517	SC_HANDLE hSCManager = OpenSCManagerW(NULL /pwszMachineName/, NULL /pwszDatabaseName/, SC_MANAGER_CONNECT);
518	if (hSCManager != NULL)
519	{
520	SC_HANDLE hService = OpenServiceW(hSCManager, pwszServiceName, SERVICE_QUERY_CONFIG);
521	if (hService != NULL)
522	{
523	DWORD cbNeeded = sizeof(QUERY_SERVICE_CONFIGW) + _1K;
524	if (!QueryServiceConfigW(hService, NULL, 0, &cbNeeded))
525	{
526	Assert(GetLastError() == ERROR_INSUFFICIENT_BUFFER);
527	LPQUERY_SERVICE_CONFIGW pSc = (LPQUERY_SERVICE_CONFIGW)RTMemTmpAllocZ(cbNeeded + _1K);
528	if (pSc)
529	{
530	DWORD cbNeeded2 = 0;
531	if (QueryServiceConfigW(hService, pSc, cbNeeded + _1K, &cbNeeded2))
532	{
533	*puStartType = pSc->dwStartType;
534	vrc = RTUtf16Copy(pwszAccountName, cwcAccountName, pSc->lpServiceStartName);
535	if (RT_FAILURE(vrc))
536	LogRel(("Error: SDS service name is too long (%Rrc): %ls\n", vrc, pSc->lpServiceStartName));
537	}
538	else
539	{
540	int dwError = GetLastError();
541	vrc = RTErrConvertFromWin32(dwError);
542	LogRel(("Error: Failed querying '%ls' service config: %Rwc (%u) -> %Rrc; cbNeeded=%d cbNeeded2=%d\n",
543	pwszServiceName, dwError, dwError, vrc, cbNeeded, cbNeeded2));
544	}
545	RTMemTmpFree(pSc);
546	}
547	else
548	{
549	LogRel(("Error: Failed allocating %#x bytes of memory for service config!\n", cbNeeded + _1K));
550	vrc = VERR_NO_TMP_MEMORY;
551	}
552	}
553	else
554	{
555	AssertLogRelMsgFailed(("Error: QueryServiceConfigW returns success with zero buffer!\n"));
556	vrc = VERR_IPE_UNEXPECTED_STATUS;
557	}
558	CloseServiceHandle(hService);
559	}
560	else
561	{
562	int dwError = GetLastError();
563	vrc = RTErrConvertFromWin32(dwError);
564	LogRel(("Error: Could not open service '%ls': %Rwc (%u) -> %Rrc\n", pwszServiceName, dwError, dwError, vrc));
565	}
566	CloseServiceHandle(hSCManager);
567	}
568	else
569	{
570	int dwError = GetLastError();
571	vrc = RTErrConvertFromWin32(dwError);
572	LogRel(("Error: Could not open SCM: %Rwc (%u) -> %Rrc\n", dwError, dwError, vrc));
573	}
574	return vrc;
575	}
576	# endif /* VBOX_WITH_SDS */
577
578	#endif /* RT_OS_WINDOWS */
579
580	/**
581	* Uninitializes the instance and sets the ready flag to FALSE.
582	* Called either from FinalRelease() or by the parent when it gets destroyed.
583	*/
584	void VirtualBoxClient::uninit()
585	{
586	LogFlowThisFunc(("\n"));
587
588	/* Enclose the state transition Ready->InUninit->NotReady */
589	AutoUninitSpan autoUninitSpan(this);
590	if (autoUninitSpan.uninitDone())
591	{
592	LogFlowThisFunc(("already done\n"));
593	return;
594	}
595
596	#ifdef VBOX_WITH_MAIN_NLS
597	i_unregisterEventListener();
598	#endif
599
600	if (mData.m_ThreadWatcher != NIL_RTTHREAD)
601	{
602	/* Signal the event semaphore and wait for the thread to terminate.
603	* if it hangs for some reason exit anyway, this can cause a crash
604	* though as the object will no longer be available. */
605	RTSemEventSignal(mData.m_SemEvWatcher);
606	RTThreadWait(mData.m_ThreadWatcher, 30000, NULL);
607	mData.m_ThreadWatcher = NIL_RTTHREAD;
608	RTSemEventDestroy(mData.m_SemEvWatcher);
609	mData.m_SemEvWatcher = NIL_RTSEMEVENT;
610	}
611	#ifdef VBOX_WITH_MAIN_NLS
612	if (mData.m_pVBoxTranslator != NULL)
613	{
614	mData.m_pVBoxTranslator->release();
615	mData.m_pVBoxTranslator = NULL;
616	mData.m_pTrComponent = NULL;
617	}
618	#endif
619	mData.m_pToken.setNull();
620	mData.m_pVirtualBox.setNull();
621
622	ASMAtomicDecU32(&g_cInstances);
623
624	LogFlowThisFunc(("returns\n"));
625	}
626
627	// IVirtualBoxClient properties
628	/////////////////////////////////////////////////////////////////////////////
629
630	/**
631	* Returns a reference to the VirtualBox object.
632	*
633	* @returns COM status code
634	* @param aVirtualBox Address of result variable.
635	*/
636	HRESULT VirtualBoxClient::getVirtualBox(ComPtr<IVirtualBox> &aVirtualBox)
637	{
638	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
639	aVirtualBox = mData.m_pVirtualBox;
640	return S_OK;
641	}
642
643	/**
644	* Create a new Session object and return a reference to it.
645	*
646	* @returns COM status code
647	* @param aSession Address of result variable.
648	*/
649	HRESULT VirtualBoxClient::getSession(ComPtr<ISession> &aSession)
650	{
651	/* this is not stored in this object, no need to lock */
652	ComPtr<ISession> pSession;
653	HRESULT hrc = pSession.createInprocObject(CLSID_Session);
654	if (SUCCEEDED(hrc))
655	aSession = pSession;
656	return hrc;
657	}
658
659	/**
660	* Return reference to the EventSource associated with this object.
661	*
662	* @returns COM status code
663	* @param aEventSource Address of result variable.
664	*/
665	HRESULT VirtualBoxClient::getEventSource(ComPtr<IEventSource> &aEventSource)
666	{
667	/* this is const, no need to lock */
668	aEventSource = mData.m_pEventSource;
669	return aEventSource.isNull() ? E_FAIL : S_OK;
670	}
671
672	// IVirtualBoxClient methods
673	/////////////////////////////////////////////////////////////////////////////
674
675	/**
676	* Checks a Machine object for any pending errors.
677	*
678	* @returns COM status code
679	* @param aMachine Machine object to check.
680	*/
681	HRESULT VirtualBoxClient::checkMachineError(const ComPtr<IMachine> &aMachine)
682	{
683	BOOL fAccessible = FALSE;
684	HRESULT hrc = aMachine->COMGETTER(Accessible)(&fAccessible);
685	if (FAILED(hrc))
686	return setError(hrc, tr("Could not check the accessibility status of the VM"));
687	else if (!fAccessible)
688	{
689	ComPtr<IVirtualBoxErrorInfo> pAccessError;
690	hrc = aMachine->COMGETTER(AccessError)(pAccessError.asOutParam());
691	if (FAILED(hrc))
692	return setError(hrc, tr("Could not get the access error message of the VM"));
693	else
694	{
695	ErrorInfo info(pAccessError);
696	ErrorInfoKeeper eik(info);
697	return info.getResultCode();
698	}
699	}
700	return S_OK;
701	}
702
703	// private methods
704	/////////////////////////////////////////////////////////////////////////////
705
706
707	/// @todo AM Add pinging of VBoxSDS
708	/static/
709	DECLCALLBACK(int) VirtualBoxClient::SVCWatcherThread(RTTHREAD ThreadSelf,
710	void *pvUser)
711	{
712	NOREF(ThreadSelf);
713	Assert(pvUser);
714	VirtualBoxClient pThis = (VirtualBoxClient )pvUser;
715	RTSEMEVENT sem = pThis->mData.m_SemEvWatcher;
716	RTMSINTERVAL cMillies = VBOXCLIENT_DEFAULT_INTERVAL;
717
718	/* The likelihood of early crashes are high, so start with a short wait. */
719	int vrc = RTSemEventWait(sem, cMillies / 2);
720
721	/* As long as the waiting times out keep retrying the wait. */
722	while (RT_FAILURE(vrc))
723	{
724	{
725	HRESULT hrc = S_OK;
726	ComPtr<IVirtualBox> pV;
727	{
728	AutoReadLock alock(pThis COMMA_LOCKVAL_SRC_POS);
729	pV = pThis->mData.m_pVirtualBox;
730	}
731	if (!pV.isNull())
732	{
733	ULONG rev;
734	hrc = pV->COMGETTER(Revision)(&rev);
735	if (FAILED_DEAD_INTERFACE(hrc))
736	{
737	LogRel(("VirtualBoxClient: detected unresponsive VBoxSVC (hrc=%Rhrc)\n", hrc));
738	{
739	AutoWriteLock alock(pThis COMMA_LOCKVAL_SRC_POS);
740	/* Throw away the VirtualBox reference, it's no longer
741	* usable as VBoxSVC terminated in the mean time. */
742	pThis->mData.m_pVirtualBox.setNull();
743	}
744	::FireVBoxSVCAvailabilityChangedEvent(pThis->mData.m_pEventSource, FALSE);
745	}
746	}
747	else
748	{
749	/* Try to get a new VirtualBox reference straight away, and if
750	* this fails use an increased waiting time as very frequent
751	* restart attempts in some wedged config can cause high CPU
752	* and disk load. */
753	ComPtr<IVirtualBox> pVirtualBox;
754	ComPtr<IToken> pToken;
755	hrc = pVirtualBox.createLocalObject(CLSID_VirtualBox);
756	if (FAILED(hrc))
757	cMillies = 3 * VBOXCLIENT_DEFAULT_INTERVAL;
758	else
759	{
760	LogRel(("VirtualBoxClient: detected working VBoxSVC (hrc=%Rhrc)\n", hrc));
761	{
762	AutoWriteLock alock(pThis COMMA_LOCKVAL_SRC_POS);
763	/* Update the VirtualBox reference, there's a working
764	* VBoxSVC again from now on. */
765	pThis->mData.m_pVirtualBox = pVirtualBox;
766	pThis->mData.m_pToken = pToken;
767	#ifdef VBOX_WITH_MAIN_NLS
768	/* update language using new instance of IVirtualBox in case the language settings was changed */
769	pThis->i_reloadApiLanguage();
770	pThis->i_registerEventListener();
771	#endif
772	}
773	::FireVBoxSVCAvailabilityChangedEvent(pThis->mData.m_pEventSource, TRUE);
774	cMillies = VBOXCLIENT_DEFAULT_INTERVAL;
775	}
776	}
777	}
778	vrc = RTSemEventWait(sem, cMillies);
779	}
780	return 0;
781	}
782
783	#ifdef VBOX_WITH_MAIN_NLS
784
785	HRESULT VirtualBoxClient::i_reloadApiLanguage()
786	{
787	if (mData.m_pVBoxTranslator == NULL)
788	return S_OK;
789
790	HRESULT hrc = mData.m_pVBoxTranslator->loadLanguage(mData.m_pVirtualBox);
791	if (FAILED(hrc))
792	setError(hrc, tr("Failed to load user language instance"));
793	return hrc;
794	}
795
796	HRESULT VirtualBoxClient::i_registerEventListener()
797	{
798	HRESULT hrc = mData.m_pVirtualBox->COMGETTER(EventSource)(mData.m_pVBoxEventSource.asOutParam());
799	if (SUCCEEDED(hrc))
800	{
801	ComObjPtr<VBoxEventListenerImpl> pVBoxListener;
802	pVBoxListener.createObject();
803	pVBoxListener->init(new VBoxEventListener());
804	mData.m_pVBoxEventListener = pVBoxListener;
805	com::SafeArray<VBoxEventType_T> eventTypes;
806	eventTypes.push_back(VBoxEventType_OnLanguageChanged);
807	hrc = mData.m_pVBoxEventSource->RegisterListener(pVBoxListener, ComSafeArrayAsInParam(eventTypes), true);
808	if (FAILED(hrc))
809	{
810	hrc = setError(hrc, tr("Failed to register listener"));
811	mData.m_pVBoxEventListener.setNull();
812	mData.m_pVBoxEventSource.setNull();
813	}
814	}
815	else
816	hrc = setError(hrc, tr("Failed to get event source from VirtualBox"));
817	return hrc;
818	}
819
820	void VirtualBoxClient::i_unregisterEventListener()
821	{
822	if (mData.m_pVBoxEventListener.isNotNull())
823	{
824	if (mData.m_pVBoxEventSource.isNotNull())
825	mData.m_pVBoxEventSource->UnregisterListener(mData.m_pVBoxEventListener);
826	mData.m_pVBoxEventListener.setNull();
827	}
828	mData.m_pVBoxEventSource.setNull();
829	}
830
831	#endif /* VBOX_WITH_MAIN_NLS */
832
833	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/src-client/VirtualBoxClientImpl.cpp@ 105978

Download in other formats: