VBoxProxyStub.c@ 91406

Last change on this file since 91406 was 83820, checked in by vboxsync, 5 years ago
Main: VC++ 14.1 adjustments and warnings. bugref:8489
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 100.1 KB

Line
1	/* $Id: VBoxProxyStub.c 83820 2020-04-19 01:08:36Z vboxsync $ */
2	/** @file
3	* VBoxProxyStub - Proxy Stub and Typelib, COM DLL exports and DLL init/term.
4	*
5	* @remarks This is a C file and not C++ because rpcproxy.h isn't C++ clean,
6	* at least not in SDK v7.1.
7	*/
8
9	/*
10	* Copyright (C) 2006-2020 Oracle Corporation
11	*
12	* This file is part of VirtualBox Open Source Edition (OSE), as
13	* available from http://www.virtualbox.org. This file is free software;
14	* you can redistribute it and/or modify it under the terms of the GNU
15	* General Public License (GPL) as published by the Free Software
16	* Foundation, in version 2 as it comes in the "COPYING" file of the
17	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
18	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
19	*/
20
21
22	/*********************************************************************************************************************************
23	* Header Files *
24	*********************************************************************************************************************************/
25	#define LOG_GROUP LOG_GROUP_MAIN
26	#define PROXY_DELEGATION /* see generated dlldata.c */
27	#include <iprt/nt/nt-and-windows.h>
28	#include <rpcproxy.h>
29	#include <iprt/win/shlwapi.h>
30	#include <stdio.h>
31
32	#include "VirtualBox.h"
33	#include <VBox/cdefs.h> /* for VBOX_STRICT */
34	#include <VBox/log.h>
35	#include <iprt/alloca.h>
36	#include <iprt/assert.h>
37	#include <iprt/ctype.h>
38	#include <iprt/initterm.h>
39	#include <iprt/path.h>
40	#include <iprt/string.h>
41	#include <iprt/uuid.h>
42	#include <iprt/utf16.h>
43
44
45	/*********************************************************************************************************************************
46	* Defined Constants And Macros *
47	*********************************************************************************************************************************/
48	#ifdef DEBUG_bird
49	# define VBSP_LOG_ENABLED
50	#endif
51
52	#ifdef VBSP_LOG_ENABLED
53	# define VBSP_LOG_VALUE_CHANGE(a) RTAssertMsg2 a
54	#else
55	# define VBSP_LOG_VALUE_CHANGE(a) do { } while (0)
56	#endif
57
58	#ifdef VBSP_LOG_ENABLED
59	# define VBSP_LOG_SET_VALUE(a) RTAssertMsg2 a
60	#else
61	# define VBSP_LOG_SET_VALUE(a) do { } while (0)
62	#endif
63
64	#ifdef VBSP_LOG_ENABLED
65	# define VBSP_LOG_NEW_KEY(a) RTAssertMsg2 a
66	#else
67	# define VBSP_LOG_NEW_KEY(a) do { } while (0)
68	#endif
69
70	#ifdef VBSP_LOG_ENABLED
71	# define VBSP_LOG_DEL_KEY(a) RTAssertMsg2 a
72	#else
73	# define VBSP_LOG_DEL_KEY(a) do { } while (0)
74	#endif
75
76	/**
77	* Selects the proxy stub DLL based on 32-on-64-bit and host OS version.
78	*
79	* The legacy DLL covers 64-bit pre Windows 7 versions of Windows. W2K3-amd64
80	* has trouble parsing the result when MIDL /target NT51 or higher. Vista and
81	* windows server 2008 seems to have trouble with newer IDL compilers.
82	*/
83	#if ARCH_BITS == 64 \|\| defined(VBOX_IN_32_ON_64_MAIN_API)
84	# define VBPS_PROXY_STUB_FILE(a_fIs32On64) ( (a_fIs32On64) ? "x86\\VBoxProxyStub-x86.dll" : VBPS_PROXY_STUB_FILE_SUB() )
85	#else
86	# define VBPS_PROXY_STUB_FILE(a_fIs32On64) VBPS_PROXY_STUB_FILE_SUB()
87	#endif
88	#define VBPS_PROXY_STUB_FILE_SUB() \
89	( RT_MAKE_U64(((PKUSER_SHARED_DATA)MM_SHARED_USER_DATA_VA)->NtMinorVersion, \
90	((PKUSER_SHARED_DATA)MM_SHARED_USER_DATA_VA)->NtMajorVersion) >= RT_MAKE_U64(1/Lo/,6/Hi/) \
91	? "VBoxProxyStub.dll" : "VBoxProxyStubLegacy.dll" )
92
93	/** For use with AssertLogRel except a_Expr1 from assertions but not LogRel. */
94	#ifdef RT_STRICT
95	# define VBPS_LOGREL_NO_ASSERT(a_Expr) (a_Expr)
96	#else
97	# define VBPS_LOGREL_NO_ASSERT(a_Expr) false
98	#endif
99
100
101	/*********************************************************************************************************************************
102	* Global Variables *
103	*********************************************************************************************************************************/
104	/** For NdrXxx. */
105	CStdPSFactoryBuffer g_ProxyStubFactory = /* see generated dlldata.c */
106	{
107	NULL,
108	0,
109	NULL,
110	0
111	};
112	/** Reference to VirtualBox_p.c structure. */
113	EXTERN_PROXY_FILE(VirtualBox) /* see generated dlldata.c */
114	/** For NdrXxx and for returning. */
115	static const ProxyFileInfo *g_apProxyFiles[] =
116	{
117	REFERENCE_PROXY_FILE(VirtualBox),
118	NULL /* terminator */
119	};
120	/** The class ID for this proxy stub factory (see Makefile). */
121	static const CLSID g_ProxyClsId = PROXY_CLSID_IS;
122	/** The instance handle of this DLL. For use in registration routines. */
123	static HINSTANCE g_hDllSelf;
124
125
126	/** Type library GUIDs to clean up manually.
127	* Must be upper case! */
128	static PCRTUTF16 const g_apwszTypeLibIds[] =
129	{
130	L"{46137EEC-703B-4FE5-AFD4-7C9BBBBA0259}",
131	L"{D7569351-1750-46F0-936E-BD127D5BC264}",
132	};
133
134	/** Type library version to clean up manually. */
135	static PCRTUTF16 const g_apwszTypelibVersions[] =
136	{
137	L"1.0",
138	L"1.3",
139	};
140
141	/** Proxy stub class IDs we wish to clean up manually.
142	* Must be upper case! */
143	static PCRTUTF16 const g_apwszProxyStubClsIds[] =
144	{
145	L"{0BB3B78C-1807-4249-5BA5-EA42D66AF0BF}",
146	L"{327E3C00-EE61-462F-AED3-0DFF6CBF9904}",
147	};
148
149
150	/**
151	* DLL main function.
152	*
153	* @returns TRUE (/ FALSE).
154	* @param hInstance The DLL handle.
155	* @param dwReason The rason for the call (DLL_XXX).
156	* @param lpReserved Reserved.
157	*/
158	BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
159	{
160	switch (dwReason)
161	{
162	case DLL_PROCESS_ATTACH:
163	/* Save the DLL handle so we can get the path to this DLL during
164	registration and updating. */
165	g_hDllSelf = hInstance;
166
167	/* We don't need callbacks for thread creation and destruction. */
168	DisableThreadLibraryCalls(hInstance);
169
170	/* Init IPRT. */
171	RTR3InitDll(RTR3INIT_FLAGS_UNOBTRUSIVE);
172	Log12(("VBoxProxyStub[%u]/DllMain: DLL_PROCESS_ATTACH\n", GetCurrentProcessId()));
173
174	#ifdef VBOX_STRICT
175	{
176	/*
177	* Check that no interface has more than 256 methods in the stub vtable.
178	*/
179	const ProxyFileInfo **ppProxyFile = &g_apProxyFiles[0];
180	const ProxyFileInfo *pProxyFile;
181	while ((pProxyFile = *ppProxyFile++) != NULL)
182	{
183	const PCInterfaceStubVtblList * const papStubVtbls = pProxyFile->pStubVtblList;
184	const char * const *papszNames = pProxyFile->pNamesArray;
185	unsigned iIf = pProxyFile->TableSize;
186	AssertStmt(iIf < 1024, iIf = 0);
187	Assert(pProxyFile->TableVersion == 2);
188
189	while (iIf-- > 0)
190	AssertMsg(papStubVtbls[iIf]->header.DispatchTableCount <= 256,
191	("%s: DispatchTableCount=%d\n", papszNames[iIf], papStubVtbls[iIf]->header.DispatchTableCount));
192	}
193	}
194	#endif
195	break;
196
197	case DLL_PROCESS_DETACH:
198	Log12(("VBoxProxyStub[%u]/DllMain: DLL_PROCESS_DETACH\n", GetCurrentProcessId()));
199	break;
200	}
201
202	NOREF(lpReserved);
203	return TRUE;
204	}
205
206
207	/**
208	* RPC entry point returning info about the proxy.
209	*/
210	void RPC_ENTRY GetProxyDllInfo(const ProxyFileInfo *ppapInfo, const CLSID ppClsid)
211	{
212	*ppapInfo = &g_apProxyFiles[0];
213	*ppClsid = &g_ProxyClsId;
214	Log12(("VBoxProxyStub[%u]/GetProxyDllInfo:\n", GetCurrentProcessId()));
215	}
216
217
218	/**
219	* Instantiate the proxy stub class object.
220	*
221	* @returns COM status code
222	* @param rclsid Reference to the ID of the call to instantiate (our
223	* g_ProxyClsId).
224	* @param riid The interface ID to return (IID_IPSFactoryBuffer).
225	* @param ppv Where to return the interface pointer on success.
226	*/
227	HRESULT STDAPICALLTYPE DllGetClassObject(REFCLSID rclsid, REFIID riid, void **ppv)
228	{
229	HRESULT hrc;
230	Assert(memcmp(rclsid, &g_ProxyClsId, sizeof(g_ProxyClsId)) == 0);
231
232	hrc = NdrDllGetClassObject(rclsid, riid, ppv, /* see DLLGETCLASSOBJECTROUTINE in RpcProxy.h */
233	g_apProxyFiles, &g_ProxyClsId, &g_ProxyStubFactory);
234
235	/*
236	* This may fail if the IDL compiler generates code that is incompatible
237	* with older windows releases. Like for instance 64-bit W2K8 SP1 not
238	* liking the output of MIDL 7.00.0555 (from the v7.1 SDK), despite
239	* /target being set to NT51.
240	*/
241	AssertLogRelMsg(hrc == S_OK, ("%Rhrc\n", hrc));
242	Log12(("VBoxProxyStub[%u]/DllGetClassObject(%RTuuid, %RTuuid, %p): %#x + *ppv=%p\n",
243	GetCurrentProcessId(), rclsid, riid, ppv, hrc, ppv ? *ppv : NULL));
244	return hrc;
245	}
246
247
248	/**
249	* Checks whether the DLL can be unloaded or not.
250	*
251	* @returns S_OK if it can be unloaded, S_FALSE if not.
252	*/
253	HRESULT STDAPICALLTYPE DllCanUnloadNow(void)
254	{
255	HRESULT hrc = NdrDllCanUnloadNow(&g_ProxyStubFactory); /* see DLLCANUNLOADNOW in RpcProxy.h */
256	Log12(("VBoxProxyStub[%u]/DllCanUnloadNow: %Rhrc\n", GetCurrentProcessId(), hrc));
257	return hrc;
258	}
259
260
261
262	/**
263	* Release call that could be referenced by VirtualBox_p.c via
264	* CStdStubBuffer_METHODS.
265	*
266	* @returns New reference count.
267	* @param pThis Buffer to release.
268	*/
269	ULONG STDMETHODCALLTYPE CStdStubBuffer_Release(IRpcStubBuffer pThis) / see CSTDSTUBBUFFERRELEASE in RpcProxy.h */
270	{
271	ULONG cRefs = NdrCStdStubBuffer_Release(pThis, (IPSFactoryBuffer *)&g_ProxyStubFactory);
272	Log12(("VBoxProxyStub[%u]/CStdStubBuffer_Release: %p -> %#x\n", GetCurrentProcessId(), pThis, cRefs));
273	return cRefs;
274	}
275
276
277	/**
278	* Release call referenced by VirtualBox_p.c via
279	* CStdStubBuffer_DELEGATING_METHODS.
280	*
281	* @returns New reference count.
282	* @param pThis Buffer to release.
283	*/
284	ULONG WINAPI CStdStubBuffer2_Release(IRpcStubBuffer pThis) / see CSTDSTUBBUFFER2RELEASE in RpcProxy.h */
285	{
286	ULONG cRefs = NdrCStdStubBuffer2_Release(pThis, (IPSFactoryBuffer *)&g_ProxyStubFactory);
287	Log12(("VBoxProxyStub[%u]/CStdStubBuffer2_Release: %p -> %#x\n", GetCurrentProcessId(), pThis, cRefs));
288	return cRefs;
289	}
290
291
292	/**
293	* Pure virtual method implementation referenced by VirtualBox_p.c
294	*/
295	void __cdecl _purecall(void) /* see DLLDUMMYPURECALL in RpcProxy.h */
296	{
297	AssertFailed();
298	}
299
300
301	#ifdef VBSP_LOG_ENABLED
302	# include <iprt/asm.h>
303
304	/** For logging full key names. */
305	static PCRTUTF16 vbpsDebugKeyToWSZ(HKEY hKey)
306	{
307	static union
308	{
309	KEY_NAME_INFORMATION NameInfo;
310	WCHAR awchPadding[260];
311	} s_aBufs[4];
312	static uint32_t volatile iNext = 0;
313	uint32_t i = ASMAtomicIncU32(&iNext) % RT_ELEMENTS(s_aBufs);
314	ULONG cbRet = 0;
315	NTSTATUS rcNt;
316
317	memset(&s_aBufs[i], 0, sizeof(s_aBufs[i]));
318	rcNt = NtQueryKey(hKey, KeyNameInformation, &s_aBufs[i], sizeof(s_aBufs[i]) - sizeof(WCHAR), &cbRet);
319	if (!NT_SUCCESS(rcNt))
320	s_aBufs[i].NameInfo.NameLength = 0;
321	s_aBufs[i].NameInfo.Name[s_aBufs[i].NameInfo.NameLength] = '\0';
322	return s_aBufs[i].NameInfo.Name;
323	}
324	#endif
325
326	/**
327	* Registry modifier state.
328	*/
329	typedef struct VBPSREGSTATE
330	{
331	/** Where the classes and stuff are to be registered. */
332	HKEY hkeyClassesRootDst;
333	/** The handle to the CLSID key under hkeyClassesRootDst. */
334	HKEY hkeyClsidRootDst;
335	/** The handle to the Interface key under hkeyClassesRootDst. */
336	HKEY hkeyInterfaceRootDst;
337
338	/** Alternative locations where data needs to be deleted, but never updated. */
339	struct
340	{
341	/** The classes root key handle. */
342	HKEY hkeyClasses;
343	/** The classes/CLSID key handle. */
344	HKEY hkeyClsid;
345	/** The classes/Interface key handle. */
346	HKEY hkeyInterface;
347	} aAltDeletes[3];
348	/** Alternative delete locations. */
349	uint32_t cAltDeletes;
350
351	/** The current total result. */
352	LSTATUS rc;
353
354	/** KEY_WOW64_32KEY, KEY_WOW64_64KEY or 0 (for default). Allows doing all
355	* almost the work from one process (at least W7+ due to aliases). */
356	DWORD fSamWow;
357	/** Desired key access when only deleting. */
358	DWORD fSamDelete;
359	/** Desired key access when only doing updates. */
360	DWORD fSamUpdate;
361	/** Desired key access when both deleting and updating. */
362	DWORD fSamBoth;
363	/** Whether to delete registrations first. */
364	bool fDelete;
365	/** Whether to update registry value and keys. */
366	bool fUpdate;
367
368	} VBPSREGSTATE;
369
370
371	/**
372	* Initializes a registry modification job state.
373	*
374	* Always call vbpsRegTerm!
375	*
376	* @returns Windows error code (ERROR_SUCCESS on success).
377	* @param pState The state to init.
378	* @param hkeyRoot The registry root tree constant.
379	* @param pszSubRoot The path to the where the classes are registered,
380	* NULL if @a hkeyRoot.
381	* @param fDelete Whether to delete registrations first.
382	* @param fUpdate Whether to update registrations.
383	* @param fSamWow KEY_WOW64_32KEY or 0.
384	*/
385	static LSTATUS vbpsRegInit(VBPSREGSTATE pState, HKEY hkeyRoot, const char pszSubRoot, bool fDelete, bool fUpdate, DWORD fSamWow)
386	{
387	LSTATUS rc;
388	unsigned i = 0;
389
390	/*
391	* Initialize the whole structure first so we can safely call vbpsRegTerm on failure.
392	*/
393	pState->hkeyClassesRootDst = NULL;
394	pState->hkeyClsidRootDst = NULL;
395	pState->hkeyInterfaceRootDst = NULL;
396	for (i = 0; i < RT_ELEMENTS(pState->aAltDeletes); i++)
397	{
398	pState->aAltDeletes[i].hkeyClasses = NULL;
399	pState->aAltDeletes[i].hkeyClsid = NULL;
400	pState->aAltDeletes[i].hkeyInterface = NULL;
401	}
402	pState->cAltDeletes = 0;
403	pState->rc = ERROR_SUCCESS;
404	pState->fDelete = fDelete;
405	pState->fUpdate = fUpdate;
406	pState->fSamWow = fSamWow;
407	pState->fSamDelete = 0;
408	if (fDelete)
409	pState->fSamDelete = pState->fSamWow \| DELETE \| KEY_ENUMERATE_SUB_KEYS \| KEY_QUERY_VALUE
410	\| STANDARD_RIGHTS_READ \| STANDARD_RIGHTS_WRITE;
411	pState->fSamUpdate = 0;
412	if (fUpdate)
413	pState->fSamUpdate = pState->fSamWow \| KEY_ENUMERATE_SUB_KEYS \| KEY_QUERY_VALUE \| KEY_SET_VALUE \| KEY_CREATE_SUB_KEY
414	\| STANDARD_RIGHTS_READ \| STANDARD_RIGHTS_WRITE;
415	pState->fSamBoth = pState->fSamDelete \| pState->fSamUpdate;
416
417	/*
418	* Open the root keys.
419	*/
420	rc = RegOpenKeyExA(hkeyRoot, pszSubRoot, 0 /fOptions/, pState->fSamBoth, &pState->hkeyClassesRootDst);
421	if (rc == ERROR_SUCCESS)
422	{
423	rc = RegCreateKeyExW(pState->hkeyClassesRootDst, L"CLSID", 0 /Reserved/, NULL /pszClass/, 0 /fOptions/,
424	pState->fSamBoth, NULL /pSecAttr/, &pState->hkeyClsidRootDst, NULL /pdwDisposition/);
425	if (rc == ERROR_SUCCESS)
426	return ERROR_SUCCESS;
427
428	/* Ignore access denied errors as these may easily happen for
429	non-admin users. Just give up when this happens */
430	AssertLogRelMsgReturn(rc == ERROR_ACCESS_DENIED, ("%u\n", rc), pState->rc = rc);
431	}
432	else
433	AssertLogRelMsgReturn(rc == ERROR_ACCESS_DENIED, ("%u\n", rc), pState->rc = rc);
434	return pState->rc = rc;
435	}
436
437
438	/**
439	* Terminates the state, closing all open keys.
440	*
441	* @param pState The state to clean up.
442	*/
443	static void vbpsRegTerm(VBPSREGSTATE *pState)
444	{
445	LSTATUS rc;
446	if (pState->hkeyClassesRootDst)
447	{
448	rc = RegCloseKey(pState->hkeyClassesRootDst);
449	Assert(rc == ERROR_SUCCESS);
450	pState->hkeyClassesRootDst = NULL;
451	}
452	if (pState->hkeyClsidRootDst)
453	{
454	rc = RegCloseKey(pState->hkeyClsidRootDst);
455	Assert(rc == ERROR_SUCCESS);
456	pState->hkeyClsidRootDst = NULL;
457	}
458	if (pState->hkeyInterfaceRootDst)
459	{
460	rc = RegCloseKey(pState->hkeyInterfaceRootDst);
461	Assert(rc == ERROR_SUCCESS);
462	pState->hkeyInterfaceRootDst = NULL;
463	}
464
465	while (pState->cAltDeletes > 0 && pState->cAltDeletes <= RT_ELEMENTS(pState->aAltDeletes))
466	{
467	unsigned i = --pState->cAltDeletes;
468	if (pState->aAltDeletes[i].hkeyClasses)
469	{
470	rc = RegCloseKey(pState->aAltDeletes[i].hkeyClasses);
471	Assert(rc == ERROR_SUCCESS);
472	pState->aAltDeletes[i].hkeyClasses = NULL;
473	}
474	if (pState->aAltDeletes[i].hkeyClsid)
475	{
476	rc = RegCloseKey(pState->aAltDeletes[i].hkeyClsid);
477	Assert(rc == ERROR_SUCCESS);
478	pState->aAltDeletes[i].hkeyClsid = NULL;
479	}
480	if (pState->aAltDeletes[i].hkeyInterface)
481	{
482	rc = RegCloseKey(pState->aAltDeletes[i].hkeyInterface);
483	Assert(rc == ERROR_SUCCESS);
484	pState->aAltDeletes[i].hkeyInterface = NULL;
485	}
486	}
487	}
488
489
490	/**
491	* Add an alternative registry classes tree from which to remove keys.
492	*
493	* @returns ERROR_SUCCESS if we successfully opened the destination root, other
494	* wise windows error code (remebered).
495	* @param pState The registry modifier state.
496	* @param hkeyAltRoot The root of the alternate registry classes
497	* location.
498	* @param pszAltSubRoot The path to the 'classes' sub-key, or NULL if
499	* hkeyAltRoot is it.
500	*/
501	static LSTATUS vbpsRegAddAltDelete(VBPSREGSTATE pState, HKEY hkeyAltRoot, const char pszAltSubRoot)
502	{
503	unsigned i;
504	LSTATUS rc;
505
506	/* Ignore call if not in delete mode. */
507	if (!pState->fDelete)
508	return ERROR_SUCCESS;
509
510	/* Check that there is space in the state. */
511	i = pState->cAltDeletes;
512	AssertReturn(i < RT_ELEMENTS(pState->aAltDeletes), pState->rc = ERROR_TOO_MANY_NAMES);
513
514
515	/* Open the root. */
516	rc = RegOpenKeyExA(hkeyAltRoot, pszAltSubRoot, 0 /fOptions/, pState->fSamDelete,
517	&pState->aAltDeletes[i].hkeyClasses);
518	if (rc == ERROR_SUCCESS)
519	{
520	/* Try open the CLSID subkey, it's fine if it doesn't exists. */
521	rc = RegOpenKeyExW(pState->aAltDeletes[i].hkeyClasses, L"CLSID", 0 /fOptions/, pState->fSamDelete,
522	&pState->aAltDeletes[i].hkeyClsid);
523	if (rc == ERROR_SUCCESS \|\| rc == ERROR_FILE_NOT_FOUND)
524	{
525	if (rc == ERROR_FILE_NOT_FOUND)
526	pState->aAltDeletes[i].hkeyClsid = NULL;
527	pState->cAltDeletes = i + 1;
528	return ERROR_SUCCESS;
529	}
530	AssertLogRelMsgFailed(("%u\n", rc));
531	RegCloseKey(pState->aAltDeletes[i].hkeyClasses);
532	}
533	/* No need to add non-existing alternative roots, nothing to delete in the void. */
534	else if (rc == ERROR_FILE_NOT_FOUND)
535	rc = ERROR_SUCCESS;
536	else
537	{
538	AssertLogRelMsgFailed(("%u (%#x %s)\n", rc));
539	pState->rc = rc;
540	}
541
542	pState->aAltDeletes[i].hkeyClasses = NULL;
543	pState->aAltDeletes[i].hkeyClsid = NULL;
544	return rc;
545	}
546
547
548	/**
549	* Open the 'Interface' keys under the current classes roots.
550	*
551	* We don't do this during vbpsRegInit as it's only needed for updating.
552	*
553	* @returns ERROR_SUCCESS if we successfully opened the destination root, other
554	* wise windows error code (remebered).
555	* @param pState The registry modifier state.
556	*/
557	static LSTATUS vbpsRegOpenInterfaceKeys(VBPSREGSTATE *pState)
558	{
559	unsigned i;
560	LSTATUS rc;
561
562	/*
563	* Under the root destination.
564	*/
565	if (pState->hkeyInterfaceRootDst == NULL)
566	{
567	if (pState->fSamUpdate)
568	rc = RegCreateKeyExW(pState->hkeyClassesRootDst, L"Interface", 0 /Reserved/, NULL /pszClass/, 0 /fOptions/,
569	pState->fSamBoth, NULL /pSecAttr/, &pState->hkeyInterfaceRootDst, NULL /pdwDisposition/);
570	else
571	rc = RegOpenKeyExW(pState->hkeyClassesRootDst, L"Interface", 0 /fOptions/, pState->fSamBoth,
572	&pState->hkeyClsidRootDst);
573	if (rc == ERROR_ACCESS_DENIED)
574	{
575	pState->hkeyInterfaceRootDst = NULL;
576	return pState->rc = rc;
577	}
578	AssertLogRelMsgReturnStmt(rc == ERROR_SUCCESS, ("%u\n", rc), pState->hkeyInterfaceRootDst = NULL, pState->rc = rc);
579	}
580
581	/*
582	* Under the alternative delete locations.
583	*/
584	i = pState->cAltDeletes;
585	while (i-- > 0)
586	if (pState->aAltDeletes[i].hkeyInterface == NULL)
587	{
588	rc = RegOpenKeyExW(pState->aAltDeletes[i].hkeyClasses, L"Interface", 0 /fOptions/, pState->fSamDelete,
589	&pState->aAltDeletes[i].hkeyInterface);
590	if (rc != ERROR_SUCCESS)
591	{
592	AssertMsgStmt(rc == ERROR_FILE_NOT_FOUND \|\| rc == ERROR_ACCESS_DENIED, ("%u\n", rc), pState->rc = rc);
593	pState->aAltDeletes[i].hkeyInterface = NULL;
594	}
595	}
596
597	return ERROR_SUCCESS;
598	}
599
600
601	/** The destination buffer size required by vbpsFormatUuidInCurly. */
602	#define CURLY_UUID_STR_BUF_SIZE 40
603
604	/**
605	* Formats a UUID to a string, inside curly braces.
606	*
607	* @returns @a pszString
608	* @param pszString Output buffer of size CURLY_UUID_STR_BUF_SIZE.
609	* @param pUuidIn The UUID to format.
610	*/
611	static const char vbpsFormatUuidInCurly(char pszString[CURLY_UUID_STR_BUF_SIZE], const CLSID pUuidIn)
612	{
613	static const char s_achDigits[17] = "0123456789abcdef";
614	PCRTUUID pUuid = (PCRTUUID)pUuidIn;
615	uint32_t u32TimeLow;
616	unsigned u;
617
618	pszString[ 0] = '{';
619	u32TimeLow = RT_H2LE_U32(pUuid->Gen.u32TimeLow);
620	pszString[ 1] = s_achDigits[(u32TimeLow >> 28)/& 0xf/];
621	pszString[ 2] = s_achDigits[(u32TimeLow >> 24) & 0xf];
622	pszString[ 3] = s_achDigits[(u32TimeLow >> 20) & 0xf];
623	pszString[ 4] = s_achDigits[(u32TimeLow >> 16) & 0xf];
624	pszString[ 5] = s_achDigits[(u32TimeLow >> 12) & 0xf];
625	pszString[ 6] = s_achDigits[(u32TimeLow >> 8) & 0xf];
626	pszString[ 7] = s_achDigits[(u32TimeLow >> 4) & 0xf];
627	pszString[ 8] = s_achDigits[(u32TimeLow/>>0/)& 0xf];
628	pszString[ 9] = '-';
629	u = RT_H2LE_U16(pUuid->Gen.u16TimeMid);
630	pszString[10] = s_achDigits[(u >> 12)/& 0xf/];
631	pszString[11] = s_achDigits[(u >> 8) & 0xf];
632	pszString[12] = s_achDigits[(u >> 4) & 0xf];
633	pszString[13] = s_achDigits[(u/>>0/)& 0xf];
634	pszString[14] = '-';
635	u = RT_H2LE_U16(pUuid->Gen.u16TimeHiAndVersion);
636	pszString[15] = s_achDigits[(u >> 12)/& 0xf/];
637	pszString[16] = s_achDigits[(u >> 8) & 0xf];
638	pszString[17] = s_achDigits[(u >> 4) & 0xf];
639	pszString[18] = s_achDigits[(u/>>0/)& 0xf];
640	pszString[19] = '-';
641	pszString[20] = s_achDigits[pUuid->Gen.u8ClockSeqHiAndReserved >> 4];
642	pszString[21] = s_achDigits[pUuid->Gen.u8ClockSeqHiAndReserved & 0xf];
643	pszString[22] = s_achDigits[pUuid->Gen.u8ClockSeqLow >> 4];
644	pszString[23] = s_achDigits[pUuid->Gen.u8ClockSeqLow & 0xf];
645	pszString[24] = '-';
646	pszString[25] = s_achDigits[pUuid->Gen.au8Node[0] >> 4];
647	pszString[26] = s_achDigits[pUuid->Gen.au8Node[0] & 0xf];
648	pszString[27] = s_achDigits[pUuid->Gen.au8Node[1] >> 4];
649	pszString[28] = s_achDigits[pUuid->Gen.au8Node[1] & 0xf];
650	pszString[29] = s_achDigits[pUuid->Gen.au8Node[2] >> 4];
651	pszString[30] = s_achDigits[pUuid->Gen.au8Node[2] & 0xf];
652	pszString[31] = s_achDigits[pUuid->Gen.au8Node[3] >> 4];
653	pszString[32] = s_achDigits[pUuid->Gen.au8Node[3] & 0xf];
654	pszString[33] = s_achDigits[pUuid->Gen.au8Node[4] >> 4];
655	pszString[34] = s_achDigits[pUuid->Gen.au8Node[4] & 0xf];
656	pszString[35] = s_achDigits[pUuid->Gen.au8Node[5] >> 4];
657	pszString[36] = s_achDigits[pUuid->Gen.au8Node[5] & 0xf];
658	pszString[37] = '}';
659	pszString[38] = '\0';
660
661	return pszString;
662
663	}
664
665
666	/**
667	* Sets a registry string value, wide char variant.
668	*
669	* @returns See RegSetValueExA (errors are remembered in the state).
670	* @param pState The registry modifier state.
671	* @param hkey The key to add the value to.
672	* @param pwszValueNm The value name. NULL for setting the default.
673	* @param pwszValue The value string.
674	* @param uLine The line we're called from.
675	*/
676	static LSTATUS vbpsSetRegValueWW(VBPSREGSTATE *pState, HKEY hkey, PCRTUTF16 pwszValueNm, PCRTUTF16 pwszValue, unsigned uLine)
677	{
678	DWORD const cbValue = (DWORD)((RTUtf16Len(pwszValue) + 1) * sizeof(RTUTF16));
679	LSTATUS rc;
680	Assert(pState->fUpdate);
681
682	/*
683	* If we're not deleting the key prior to updating, we're in gentle update
684	* mode where we will query if the existing value matches the incoming one.
685	*/
686	if (!pState->fDelete)
687	{
688	DWORD cbExistingData = cbValue + 128;
689	PRTUTF16 pwszExistingData = (PRTUTF16)alloca(cbExistingData);
690	DWORD dwExistingType;
691	rc = RegQueryValueExW(hkey, pwszValueNm, 0 /Reserved/, &dwExistingType, (BYTE *)pwszExistingData, &cbExistingData);
692	if (rc == ERROR_SUCCESS)
693	{
694	if ( dwExistingType == REG_SZ
695	&& cbExistingData == cbValue)
696	{
697	if (memcmp(pwszValue, pwszExistingData, cbValue) == 0)
698	return ERROR_SUCCESS;
699	}
700	VBSP_LOG_VALUE_CHANGE(("vbpsSetRegValueWW: Value difference: dwExistingType=%d cbExistingData=%#x cbValue=%#x\n"
701	" hkey=%#x %ls; value name=%ls\n"
702	"existing: %.Rhxs (%.ls)\n"
703	" new: %.*Rhxs (%ls)\n",
704	dwExistingType, cbExistingData, cbValue,
705	hkey, vbpsDebugKeyToWSZ(hkey), pwszValueNm ? pwszValueNm : L"(default)",
706	cbExistingData, pwszExistingData, cbExistingData / sizeof(RTUTF16), pwszExistingData,
707	cbValue, pwszValue, pwszValue));
708	}
709	else
710	Assert(rc == ERROR_FILE_NOT_FOUND \|\| rc == ERROR_MORE_DATA);
711	}
712
713	/*
714	* Set the value.
715	*/
716	rc = RegSetValueExW(hkey, pwszValueNm, 0 /Reserved/, REG_SZ, (const BYTE *)pwszValue, cbValue);
717	if (rc == ERROR_SUCCESS)
718	{
719	VBSP_LOG_SET_VALUE(("vbpsSetRegValueWW: %ls/%ls=%ls (at %d)\n",
720	vbpsDebugKeyToWSZ(hkey), pwszValueNm ? pwszValueNm : L"(Default)", pwszValue, uLine));
721	return ERROR_SUCCESS;
722	}
723
724	AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(rc == ERROR_ACCESS_DENIED),
725	("%d: '%ls'='%ls' -> %u\n", uLine, pwszValueNm, pwszValue, rc));
726	pState->rc = rc;
727	return rc;
728	}
729
730
731	/**
732	* Sets a registry string value.
733	*
734	* @returns See RegSetValueExA (errors are remembered in the state).
735	* @param pState The registry modifier state.
736	* @param hkey The key to add the value to.
737	* @param pszValueNm The value name. NULL for setting the default.
738	* @param pszValue The value string.
739	* @param uLine The line we're called from.
740	*/
741	static LSTATUS vbpsSetRegValueAA(VBPSREGSTATE pState, HKEY hkey, const char pszValueNm, const char *pszValue, unsigned uLine)
742	{
743	DWORD const cbValue = (DWORD)strlen(pszValue) + 1;
744	LSTATUS rc;
745	Assert(pState->fUpdate);
746
747	/*
748	* If we're not deleting the key prior to updating, we're in gentle update
749	* mode where we will query if the existing value matches the incoming one.
750	*/
751	if (!pState->fDelete)
752	{
753	DWORD cbExistingData = cbValue + 128;
754	char *pszExistingData = alloca(cbExistingData);
755	DWORD dwExistingType;
756	rc = RegQueryValueExA(hkey, pszValueNm, 0 /Reserved/, &dwExistingType, (PBYTE)pszExistingData, &cbExistingData);
757	if (rc == ERROR_SUCCESS)
758	{
759	if ( dwExistingType == REG_SZ
760	&& cbExistingData == cbValue)
761	{
762	if (memcmp(pszValue, pszExistingData, cbValue) == 0)
763	return ERROR_SUCCESS;
764	if (memicmp(pszValue, pszExistingData, cbValue) == 0)
765	return ERROR_SUCCESS;
766	}
767	VBSP_LOG_VALUE_CHANGE(("vbpsSetRegValueAA: Value difference: dwExistingType=%d cbExistingData=%#x cbValue=%#x\n"
768	" hkey=%#x %ls; value name=%s\n"
769	"existing: %.Rhxs (%.s)\n"
770	" new: %.*Rhxs (%s)\n",
771	dwExistingType, cbExistingData, cbValue,
772	hkey, vbpsDebugKeyToWSZ(hkey), pszValueNm ? pszValueNm : "(default)",
773	cbExistingData, pszExistingData, cbExistingData, pszExistingData,
774	cbValue, pszValue, pszValue));
775	}
776	else
777	Assert(rc == ERROR_FILE_NOT_FOUND \|\| rc == ERROR_MORE_DATA);
778	}
779
780	/*
781	* Set the value.
782	*/
783	rc = RegSetValueExA(hkey, pszValueNm, 0 /Reserved/, REG_SZ, (PBYTE)pszValue, cbValue);
784	if (rc == ERROR_SUCCESS)
785	{
786	VBSP_LOG_SET_VALUE(("vbpsSetRegValueAA: %ls/%s=%s (at %d)\n",
787	vbpsDebugKeyToWSZ(hkey), pszValueNm ? pszValueNm : "(Default)", pszValue, uLine));
788	return ERROR_SUCCESS;
789	}
790
791	AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(rc == ERROR_ACCESS_DENIED),
792	("%d: '%s'='%s' -> %u\n", uLine, pszValueNm, pszValue, rc));
793	pState->rc = rc;
794	return rc;
795	}
796
797
798	/**
799	* Closes a registry key.
800	*
801	* @returns See RegCloseKey (errors are remembered in the state).
802	* @param pState The registry modifier state.
803	* @param hkey The key to close.
804	* @param uLine The line we're called from.
805	*/
806	static LSTATUS vbpsCloseKey(VBPSREGSTATE *pState, HKEY hkey, unsigned uLine)
807	{
808	LSTATUS rc = RegCloseKey(hkey);
809	if (rc == ERROR_SUCCESS)
810	return ERROR_SUCCESS;
811
812	AssertLogRelMsgFailed(("%d: close key -> %u\n", uLine, rc));
813	pState->rc = rc;
814	return rc;
815	}
816
817
818	/**
819	* Creates a registry key.
820	*
821	* @returns See RegCreateKeyA and RegSetValueExA (errors are remembered in the
822	* state).
823	* @param pState The registry modifier state.
824	* @param hkeyParent The parent key.
825	* @param pszKey The new key under @a hkeyParent.
826	* @param phkey Where to return the handle to the new key.
827	* @param uLine The line we're called from.
828	*/
829	static LSTATUS vbpsCreateRegKeyA(VBPSREGSTATE pState, HKEY hkeyParent, const char pszKey, PHKEY phkey, unsigned uLine)
830	{
831	/*
832	* This will open if it exists and create if new, which is exactly what we want.
833	*/
834	HKEY hNewKey;
835	DWORD dwDisposition = 0;
836	LSTATUS rc = RegCreateKeyExA(hkeyParent, pszKey, 0 /Reserved/, NULL /pszClass/, 0 /fOptions/,
837	pState->fSamBoth, NULL /pSecAttr/, &hNewKey, &dwDisposition);
838	if (rc == ERROR_SUCCESS)
839	{
840	*phkey = hNewKey;
841	if (dwDisposition == REG_CREATED_NEW_KEY)
842	VBSP_LOG_NEW_KEY(("vbpsCreateRegKeyA: %ls/%s (at %d)\n", vbpsDebugKeyToWSZ(hkeyParent), pszKey, uLine));
843	}
844	else
845	{
846	AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(rc == ERROR_ACCESS_DENIED),
847	("%d: create key '%s' -> %u\n", uLine, pszKey, rc));
848	pState->rc = rc;
849	*phkey = NULL;
850	}
851	return rc;
852	}
853
854
855	/**
856	* Creates a registry key with a default string value.
857	*
858	* @returns See RegCreateKeyA and RegSetValueExA (errors are remembered in the
859	* state).
860	* @param pState The registry modifier state.
861	* @param hkeyParent The parent key.
862	* @param pszKey The new key under @a hkeyParent.
863	* @param pszValue The value string.
864	* @param uLine The line we're called from.
865	*/
866	static LSTATUS vbpsCreateRegKeyWithDefaultValueAA(VBPSREGSTATE pState, HKEY hkeyParent, const char pszKey,
867	const char *pszValue, unsigned uLine)
868	{
869	HKEY hNewKey;
870	LSTATUS rc = vbpsCreateRegKeyA(pState, hkeyParent, pszKey, &hNewKey, uLine);
871	if (rc == ERROR_SUCCESS)
872	{
873	rc = vbpsSetRegValueAA(pState, hNewKey, NULL /pszValueNm/, pszValue, uLine);
874	vbpsCloseKey(pState, hNewKey, uLine);
875	}
876	else
877	{
878	AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(rc == ERROR_ACCESS_DENIED),
879	("%d: create key '%s'(/Default='%s') -> %u\n", uLine, pszKey, pszValue, rc));
880	pState->rc = rc;
881	}
882	return rc;
883	}
884
885
886	/**
887	* Creates a registry key with a default wide string value.
888	*
889	* @returns See RegCreateKeyA and RegSetValueExA (errors are remembered in the
890	* state).
891	* @param pState The registry modifier state.
892	* @param hkeyParent The parent key.
893	* @param pszKey The new key under @a hkeyParent.
894	* @param pwszValue The value string.
895	* @param uLine The line we're called from.
896	*/
897	static LSTATUS vbpsCreateRegKeyWithDefaultValueAW(VBPSREGSTATE pState, HKEY hkeyParent, const char pszKey,
898	PCRTUTF16 pwszValue, unsigned uLine)
899	{
900	HKEY hNewKey;
901	LSTATUS rc = vbpsCreateRegKeyA(pState, hkeyParent, pszKey, &hNewKey, uLine);
902	if (rc == ERROR_SUCCESS)
903	{
904	rc = vbpsSetRegValueWW(pState, hNewKey, NULL /pwszValueNm/, pwszValue, uLine);
905	vbpsCloseKey(pState, hNewKey, uLine);
906	}
907	else
908	{
909	AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(rc == ERROR_ACCESS_DENIED),
910	("%d: create key '%s'(/Default='%ls') -> %u\n", uLine, pszKey, pwszValue, rc));
911	pState->rc = rc;
912	}
913	return rc;
914	}
915
916
917	/**
918	* Creates a registry key with a default string value, return the key.
919	*
920	* @returns See RegCreateKeyA and RegSetValueExA (errors are remembered in the
921	* state).
922	* @param pState The registry modifier state.
923	* @param hkeyParent The parent key.
924	* @param pszKey The new key under @a hkeyParent.
925	* @param pszValue The value string.
926	* @param phkey Where to return the handle to the new key.
927	* @param uLine The line we're called from.
928	*/
929	static LSTATUS vbpsCreateRegKeyWithDefaultValueAAEx(VBPSREGSTATE pState, HKEY hkeyParent, const char pszKey,
930	const char *pszValue, PHKEY phkey, unsigned uLine)
931	{
932	HKEY hNewKey;
933	LSTATUS rc = vbpsCreateRegKeyA(pState, hkeyParent, pszKey, &hNewKey, uLine);
934	if (rc == ERROR_SUCCESS)
935	{
936	rc = vbpsSetRegValueAA(pState, hNewKey, NULL /pszValueNm/, pszValue, uLine);
937	*phkey = hNewKey;
938	}
939	else
940	{
941	AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(rc == ERROR_ACCESS_DENIED),
942	("%d: create key '%s'(/Default='%s') -> %u\n", uLine, pszKey, pszValue, rc));
943	pState->rc = rc;
944	*phkey = NULL;
945	}
946	return rc;
947	}
948
949
950	/**
951	* Recursively deletes a registry key.
952	*
953	* @returns See SHDeleteKeyA (errors are remembered in the state).
954	* @param pState The registry modifier state.
955	* @param hkeyParent The parent key.
956	* @param pszKey The key under @a hkeyParent that should be
957	* deleted.
958	* @param uLine The line we're called from.
959	*/
960	static LSTATUS vbpsDeleteKeyRecursiveA(VBPSREGSTATE pState, HKEY hkeyParent, const char pszKey, unsigned uLine)
961	{
962	LSTATUS rc;
963
964	Assert(pState->fDelete);
965	Assert(pszKey);
966	AssertReturn(*pszKey != '\0', pState->rc = ERROR_INVALID_PARAMETER);
967
968	#ifdef VBSP_LOG_ENABLED
969	{
970	HKEY hkeyLog;
971	rc = RegOpenKeyExA(hkeyParent, pszKey, 0 /fOptions/, pState->fSamDelete, &hkeyLog);
972	if (rc != ERROR_FILE_NOT_FOUND)
973	VBSP_LOG_DEL_KEY(("vbpsDeleteKeyRecursiveA: %ls/%s (at %d)\n", vbpsDebugKeyToWSZ(hkeyParent), pszKey, uLine));
974	if (rc == ERROR_SUCCESS)
975	RegCloseKey(hkeyLog);
976	}
977	#endif
978
979	rc = SHDeleteKeyA(hkeyParent, pszKey);
980	if (rc == ERROR_SUCCESS \|\| rc == ERROR_FILE_NOT_FOUND)
981	return ERROR_SUCCESS;
982
983	AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(rc == ERROR_ACCESS_DENIED),
984	("%d: delete key '%s' -> %u\n", uLine, pszKey, rc));
985	pState->rc = rc;
986	return rc;
987	}
988
989
990	/**
991	* Recursively deletes a registry key, wide char version.
992	*
993	* @returns See SHDeleteKeyW (errors are remembered in the state).
994	* @param pState The registry modifier state.
995	* @param hkeyParent The parent key.
996	* @param pwszKey The key under @a hkeyParent that should be
997	* deleted.
998	* @param uLine The line we're called from.
999	*/
1000	static LSTATUS vbpsDeleteKeyRecursiveW(VBPSREGSTATE *pState, HKEY hkeyParent, PCRTUTF16 pwszKey, unsigned uLine)
1001	{
1002	LSTATUS rc;
1003
1004	Assert(pState->fDelete);
1005	Assert(pwszKey);
1006	AssertReturn(*pwszKey != '\0', pState->rc = ERROR_INVALID_PARAMETER);
1007
1008	#ifdef VBSP_LOG_ENABLED
1009	{
1010	HKEY hkeyLog;
1011	rc = RegOpenKeyExW(hkeyParent, pwszKey, 0 /fOptions/, pState->fSamDelete, &hkeyLog);
1012	if (rc != ERROR_FILE_NOT_FOUND)
1013	VBSP_LOG_DEL_KEY(("vbpsDeleteKeyRecursiveW: %ls/%ls (at %d)\n", vbpsDebugKeyToWSZ(hkeyParent), pwszKey, uLine));
1014	if (rc == ERROR_SUCCESS)
1015	RegCloseKey(hkeyLog);
1016	}
1017	#endif
1018
1019	rc = SHDeleteKeyW(hkeyParent, pwszKey);
1020	if (rc == ERROR_SUCCESS \|\| rc == ERROR_FILE_NOT_FOUND)
1021	return ERROR_SUCCESS;
1022
1023	AssertLogRelMsg(VBPS_LOGREL_NO_ASSERT(rc == ERROR_ACCESS_DENIED),
1024	("%d: delete key '%ls' -> %u\n", uLine, pwszKey, rc));
1025	pState->rc = rc;
1026	return rc;
1027	}
1028
1029
1030	/**
1031	* Register an application id.
1032	*
1033	* @returns Windows error code (errors are rememberd in the state).
1034	* @param pState The registry modifier state.
1035	* @param pszModuleName The module name.
1036	* @param pszAppId The application UUID string.
1037	* @param pszDescription The description string.
1038	* @param pszServiceName The window service name if the application is a
1039	* service, otherwise this must be NULL.
1040	*/
1041	LSTATUS VbpsRegisterAppId(VBPSREGSTATE pState, const char pszModuleName, const char *pszAppId,
1042	const char pszDescription, const char pszServiceName)
1043	{
1044	LSTATUS rc;
1045	HKEY hkeyAppIds;
1046	Assert(*pszAppId == '{');
1047
1048	/*
1049	* Delete.
1050	*/
1051	if (pState->fDelete)
1052	{
1053	unsigned i = pState->cAltDeletes;
1054	while (i-- > 0)
1055	{
1056	rc = RegOpenKeyExW(pState->aAltDeletes[i].hkeyClasses, L"AppID", 0 /fOptions/, pState->fSamDelete, &hkeyAppIds);
1057	AssertLogRelMsgStmt(rc == ERROR_SUCCESS \|\| rc == ERROR_FILE_NOT_FOUND, ("%u\n", rc), pState->rc = rc);
1058	if (rc == ERROR_SUCCESS)
1059	{
1060	vbpsDeleteKeyRecursiveA(pState, hkeyAppIds, pszAppId, __LINE__);
1061	vbpsCloseKey(pState, hkeyAppIds, __LINE__);
1062	}
1063	}
1064	}
1065
1066	if (pState->fUpdate)
1067	{
1068	rc = RegCreateKeyExW(pState->hkeyClassesRootDst, L"AppID", 0 /Reserved/, NULL /pszClass/, 0 /fOptions/,
1069	pState->fSamBoth, NULL /pSecAttr/, &hkeyAppIds, NULL /pdwDisposition/);
1070	if (rc == ERROR_ACCESS_DENIED)
1071	return ERROR_SUCCESS;
1072	}
1073	else
1074	{
1075	rc = RegOpenKeyExW(pState->hkeyClassesRootDst, L"AppID", 0 /fOptions/, pState->fSamBoth, &hkeyAppIds);
1076	if (rc == ERROR_FILE_NOT_FOUND \|\| rc == ERROR_ACCESS_DENIED)
1077	return ERROR_SUCCESS;
1078	}
1079	if (rc == ERROR_ACCESS_DENIED)
1080	return pState->rc = rc;
1081	AssertLogRelMsgReturn(rc == ERROR_SUCCESS, ("%u\n", rc), pState->rc = rc);
1082
1083	if (pState->fDelete)
1084	{
1085	vbpsDeleteKeyRecursiveA(pState, hkeyAppIds, pszAppId, __LINE__);
1086	vbpsDeleteKeyRecursiveA(pState, hkeyAppIds, pszModuleName, __LINE__);
1087	}
1088
1089	/*
1090	* Register / update.
1091	*/
1092	if (pState->fUpdate)
1093	{
1094	HKEY hkey;
1095	rc = vbpsCreateRegKeyA(pState, hkeyAppIds, pszAppId, &hkey, __LINE__);
1096	if (rc == ERROR_SUCCESS)
1097	{
1098	vbpsSetRegValueAA(pState, hkey, NULL /pszValueNm/, pszDescription, __LINE__);
1099	if (pszServiceName)
1100	vbpsSetRegValueAA(pState, hkey, "LocalService", pszServiceName, __LINE__);
1101	vbpsCloseKey(pState, hkey, __LINE__);
1102	}
1103
1104	rc = vbpsCreateRegKeyA(pState, hkeyAppIds, pszModuleName, &hkey, __LINE__);
1105	if (rc == ERROR_SUCCESS)
1106	{
1107	vbpsSetRegValueAA(pState, hkey, NULL /pszValueNm/, "", __LINE__);
1108	vbpsSetRegValueAA(pState, hkey, "AppID", pszAppId, __LINE__);
1109	vbpsCloseKey(pState, hkey, __LINE__);
1110	}
1111	}
1112
1113	vbpsCloseKey(pState, hkeyAppIds, __LINE__);
1114
1115	return pState->rc;
1116	}
1117
1118
1119	/**
1120	* Register an class name.
1121	*
1122	* @returns Windows error code (errors are rememberd in the state).
1123	* @param pState The registry modifier state.
1124	* @param pszClassName The name of the class.
1125	* @param pszDescription The description string
1126	* @param pClsId The UUID for the class.
1127	* @param pszCurVerSuffIfRootName This is the current version suffix to
1128	* append to @a pszClassName when
1129	* registering the version idependent name.
1130	*/
1131	LSTATUS VbpsRegisterClassName(VBPSREGSTATE pState, const char pszClassName, const char *pszDescription,
1132	const CLSID pClsId, const char pszCurVerSuffIfRootName)
1133	{
1134	LSTATUS rc;
1135
1136	/*
1137	* Delete.
1138	*/
1139	if (pState->fDelete)
1140	{
1141	unsigned i = pState->cAltDeletes;
1142	while (i-- > 0)
1143	vbpsDeleteKeyRecursiveA(pState, pState->aAltDeletes[i].hkeyClasses, pszClassName, __LINE__);
1144	vbpsDeleteKeyRecursiveA(pState, pState->hkeyClassesRootDst, pszClassName, __LINE__);
1145	}
1146
1147	/*
1148	* Update.
1149	*/
1150	if (pState->fUpdate)
1151	{
1152	/* pszClassName/Default = description. */
1153	HKEY hkeyClass;
1154	rc = vbpsCreateRegKeyWithDefaultValueAAEx(pState, pState->hkeyClassesRootDst, pszClassName, pszDescription,
1155	&hkeyClass, __LINE__);
1156	if (rc == ERROR_SUCCESS)
1157	{
1158	char szClsId[CURLY_UUID_STR_BUF_SIZE];
1159
1160	/* CLSID/Default = pClsId. */
1161	vbpsCreateRegKeyWithDefaultValueAA(pState, hkeyClass, "CLSID", vbpsFormatUuidInCurly(szClsId, pClsId), __LINE__);
1162
1163	/* CurVer/Default = pszClassName+Suffix. */
1164	if (pszCurVerSuffIfRootName != NULL)
1165	{
1166	char szCurClassNameVer[128];
1167	rc = RTStrCopy(szCurClassNameVer, sizeof(szCurClassNameVer), pszClassName);
1168	if (RT_SUCCESS(rc))
1169	rc = RTStrCat(szCurClassNameVer, sizeof(szCurClassNameVer), pszCurVerSuffIfRootName);
1170	AssertStmt(RT_SUCCESS(rc), pState->rc = rc = ERROR_INVALID_DATA);
1171	if (rc == ERROR_SUCCESS)
1172	vbpsCreateRegKeyWithDefaultValueAA(pState, hkeyClass, "CurVer", szCurClassNameVer, __LINE__);
1173	}
1174
1175	vbpsCloseKey(pState, hkeyClass, __LINE__);
1176	}
1177	}
1178
1179	return pState->rc;
1180	}
1181
1182
1183	/**
1184	* Registers a class ID.
1185	*
1186	* @returns Windows error code (errors are rememberd in the state).
1187	* @param pState The registry modifier state.
1188	* @param pClsId The UUID for the class.
1189	* @param pszDescription The description string.
1190	* @param pszAppId The application ID.
1191	* @param pszClassName The version idependent class name.
1192	* @param pszCurClassNameVerSuffix The suffix to add to @a pszClassName for
1193	* the current version.
1194	* @param pTypeLibId The UUID for the typelib this class
1195	* belongs to.
1196	* @param pszServerType The server type (InprocServer32 or
1197	* LocalServer32).
1198	* @param pwszVBoxDir The VirtualBox install directory
1199	* (unicode), trailing slash.
1200	* @param pszServerSubPath What to append to @a pwszVBoxDir to
1201	* construct the server module name.
1202	* @param pszThreadingModel The threading model for inproc servers,
1203	* NULL for local servers.
1204	*/
1205	LSTATUS VbpsRegisterClassId(VBPSREGSTATE pState, const CLSID pClsId, const char pszDescription, const char pszAppId,
1206	const char pszClassName, const char pszCurClassNameVerSuffix, const CLSID *pTypeLibId,
1207	const char pszServerType, PCRTUTF16 pwszVBoxDir, const char pszServerSubPath,
1208	const char *pszThreadingModel)
1209	{
1210	LSTATUS rc;
1211	char szClsId[CURLY_UUID_STR_BUF_SIZE];
1212	RT_NOREF(pszAppId);
1213
1214	Assert(!pszAppId \|\| *pszAppId == '{');
1215	Assert((pwszVBoxDir == NULL && !pState->fUpdate) \|\| pwszVBoxDir[RTUtf16Len(pwszVBoxDir) - 1] == '\\');
1216
1217	/*
1218	* We need this, whatever we end up having to do.
1219	*/
1220	vbpsFormatUuidInCurly(szClsId, pClsId);
1221
1222	/*
1223	* Delete.
1224	*/
1225	if (pState->fDelete)
1226	{
1227	unsigned i = pState->cAltDeletes;
1228	while (i-- > 0)
1229	if (pState->aAltDeletes[i].hkeyClsid != NULL)
1230	vbpsDeleteKeyRecursiveA(pState, pState->aAltDeletes[i].hkeyClsid, szClsId, __LINE__);
1231	vbpsDeleteKeyRecursiveA(pState, pState->hkeyClsidRootDst, szClsId, __LINE__);
1232	}
1233
1234	/*
1235	* Update.
1236	*/
1237	if (pState->fUpdate)
1238	{
1239	HKEY hkeyClass;
1240	rc = vbpsCreateRegKeyWithDefaultValueAAEx(pState, pState->hkeyClsidRootDst, szClsId, pszDescription,
1241	&hkeyClass, __LINE__);
1242	if (rc == ERROR_SUCCESS)
1243	{
1244	bool const fIsLocalServer32 = strcmp(pszServerType, "LocalServer32") == 0;
1245	HKEY hkeyServerType;
1246	char szCurClassNameVer[128];
1247
1248	/* pszServerType/Default = module. */
1249	rc = vbpsCreateRegKeyA(pState, hkeyClass, pszServerType, &hkeyServerType, __LINE__);
1250	if (rc == ERROR_SUCCESS)
1251	{
1252	RTUTF16 wszModule[MAX_PATH * 2];
1253	PRTUTF16 pwszCur = wszModule;
1254	if (fIsLocalServer32)
1255	*pwszCur++ = '"';
1256
1257	rc = RTUtf16Copy(pwszCur, MAX_PATH, pwszVBoxDir); AssertRC(rc);
1258	pwszCur += RTUtf16Len(pwszCur);
1259	rc = RTUtf16CopyAscii(pwszCur, MAX_PATH - 3, pszServerSubPath); AssertRC(rc);
1260	pwszCur += RTUtf16Len(pwszCur);
1261
1262	if (fIsLocalServer32)
1263	*pwszCur++ = '"';
1264	pwszCur++ = '\0'; / included, so ++. */
1265
1266	vbpsSetRegValueWW(pState, hkeyServerType, NULL /pszValueNm/, wszModule, __LINE__);
1267
1268	/* pszServerType/ThreadingModel = pszThreading Model. */
1269	if (pszThreadingModel)
1270	vbpsSetRegValueAA(pState, hkeyServerType, "ThreadingModel", pszThreadingModel, __LINE__);
1271
1272	vbpsCloseKey(pState, hkeyServerType, __LINE__);
1273	}
1274
1275	/* ProgId/Default = pszClassName + pszCurClassNameVerSuffix. */
1276	if (pszClassName)
1277	{
1278	rc = RTStrCopy(szCurClassNameVer, sizeof(szCurClassNameVer), pszClassName);
1279	if (RT_SUCCESS(rc))
1280	rc = RTStrCat(szCurClassNameVer, sizeof(szCurClassNameVer), pszCurClassNameVerSuffix);
1281	AssertStmt(RT_SUCCESS(rc), pState->rc = rc = ERROR_INVALID_DATA);
1282	if (rc == ERROR_SUCCESS)
1283	vbpsCreateRegKeyWithDefaultValueAA(pState, hkeyClass, "ProgId", szCurClassNameVer, __LINE__);
1284
1285	/* VersionIndependentProgID/Default = pszClassName. */
1286	vbpsCreateRegKeyWithDefaultValueAA(pState, hkeyClass, "VersionIndependentProgID", pszClassName, __LINE__);
1287	}
1288
1289	/* TypeLib/Default = pTypeLibId. */
1290	if (pTypeLibId)
1291	{
1292	char szTypeLibId[CURLY_UUID_STR_BUF_SIZE];
1293	vbpsCreateRegKeyWithDefaultValueAA(pState, hkeyClass, "TypeLib",
1294	vbpsFormatUuidInCurly(szTypeLibId, pTypeLibId), __LINE__);
1295	}
1296
1297	/* AppID = pszAppId */
1298	if (pszAppId && fIsLocalServer32)
1299	vbpsSetRegValueAA(pState, hkeyClass, "AppID", pszAppId, __LINE__);
1300
1301	vbpsCloseKey(pState, hkeyClass, __LINE__);
1302	}
1303	}
1304
1305	return pState->rc;
1306	}
1307
1308
1309	/**
1310	* Register modules and classes from the VirtualBox.xidl file.
1311	*
1312	* @returns COM status code.
1313	* @param pState
1314	* @param pwszVBoxDir The VirtualBox application directory.
1315	* @param fIs32On64 Set if this is the 32-bit on 64-bit component.
1316	*
1317	* @todo convert to XSLT.
1318	*/
1319	void RegisterXidlModulesAndClassesGenerated(VBPSREGSTATE *pState, PCRTUTF16 pwszVBoxDir, bool fIs32On64)
1320	{
1321	const char *pszAppId = "{819B4D85-9CEE-493C-B6FC-64FFE759B3C9}";
1322	const char *pszInprocDll = !fIs32On64 ? "VBoxC.dll" : "x86\\VBoxClient-x86.dll";
1323	const char *pszLocalServer = "VBoxSVC.exe";
1324	#ifdef VBOX_WITH_SDS
1325	const char *pszSdsAppId = "{EC0E78E8-FA43-43E8-AC0A-02C784C4A4FA}";
1326	const char *pszSdsExe = "VBoxSDS.exe";
1327	const char *pszSdsServiceName = "VBoxSDS";
1328	#endif
1329
1330	/* VBoxSVC */
1331	VbpsRegisterAppId(pState, pszLocalServer, pszAppId, "VirtualBox Application", NULL);
1332	VbpsRegisterClassName(pState, "VirtualBox.VirtualBox.1", "VirtualBox Class", &CLSID_VirtualBox, NULL);
1333	VbpsRegisterClassName(pState, "VirtualBox.VirtualBox", "VirtualBox Class", &CLSID_VirtualBox, ".1");
1334	VbpsRegisterClassId(pState, &CLSID_VirtualBox, "VirtualBox Class", pszAppId, "VirtualBox.VirtualBox", ".1",
1335	&LIBID_VirtualBox, "LocalServer32", pwszVBoxDir, pszLocalServer, NULL /N/A/);
1336	/* VBoxC */
1337	VbpsRegisterClassName(pState, "VirtualBox.Session.1", "Session Class", &CLSID_Session, NULL);
1338	VbpsRegisterClassName(pState, "VirtualBox.Session", "Session Class", &CLSID_Session, ".1");
1339	VbpsRegisterClassId(pState, &CLSID_Session, "Session Class", pszAppId, "VirtualBox.Session", ".1",
1340	&LIBID_VirtualBox, "InprocServer32", pwszVBoxDir, pszInprocDll, "Free");
1341
1342	VbpsRegisterClassName(pState, "VirtualBox.VirtualBoxClient.1", "VirtualBoxClient Class", &CLSID_VirtualBoxClient, NULL);
1343	VbpsRegisterClassName(pState, "VirtualBox.VirtualBoxClient", "VirtualBoxClient Class", &CLSID_VirtualBoxClient, ".1");
1344	VbpsRegisterClassId(pState, &CLSID_VirtualBoxClient, "VirtualBoxClient Class", pszAppId,
1345	"VirtualBox.VirtualBoxClient", ".1",
1346	&LIBID_VirtualBox, "InprocServer32", pwszVBoxDir, pszInprocDll, "Free");
1347
1348	#ifdef VBOX_WITH_SDS
1349	/* VBoxSDS */
1350	VbpsRegisterAppId(pState, pszSdsExe, pszSdsAppId, "VirtualBox System Service", pszSdsServiceName);
1351	VbpsRegisterClassName(pState, "VirtualBox.VirtualBoxSDS.1", "VirtualBoxSDS Class", &CLSID_VirtualBoxSDS, NULL);
1352	VbpsRegisterClassName(pState, "VirtualBox.VirtualBoxSDS", "VirtualBoxSDS Class", &CLSID_VirtualBoxSDS, ".1");
1353	VbpsRegisterClassId(pState, &CLSID_VirtualBoxSDS, "VirtualBoxSDS Class", pszSdsAppId, "VirtualBox.VirtualBoxSDS", ".1",
1354	&LIBID_VirtualBox, "LocalServer32", pwszVBoxDir, pszSdsExe, NULL /N/A/);
1355	#endif
1356	}
1357
1358
1359	/**
1360	* Updates the VBox type lib registration.
1361	*
1362	* This is only used when updating COM registrations during com::Initialize.
1363	* For normal registration and unregistrations we use the RegisterTypeLib and
1364	* UnRegisterTypeLib APIs.
1365	*
1366	* @param pState The registry modifier state.
1367	* @param pwszVBoxDir The VirtualBox install directory (unicode),
1368	* trailing slash.
1369	* @param fIs32On64 Set if we're registering the 32-bit proxy stub
1370	* on a 64-bit system.
1371	*/
1372	static void vbpsUpdateTypeLibRegistration(VBPSREGSTATE *pState, PCRTUTF16 pwszVBoxDir, bool fIs32On64)
1373	{
1374	const char * const pszTypeLibDll = VBPS_PROXY_STUB_FILE(fIs32On64);
1375	#if ARCH_BITS == 32 && !defined(VBOX_IN_32_ON_64_MAIN_API)
1376	const char * const pszWinXx = "win32";
1377	#else
1378	const char * const pszWinXx = !fIs32On64 ? "win64" : "win32";
1379	#endif
1380	const char * const pszDescription = "VirtualBox Type Library";
1381
1382	char szTypeLibId[CURLY_UUID_STR_BUF_SIZE];
1383	HKEY hkeyTypeLibs;
1384	HKEY hkeyTypeLibId;
1385	LSTATUS rc;
1386	RT_NOREF(fIs32On64);
1387
1388	Assert(pState->fUpdate && !pState->fDelete);
1389
1390	/*
1391	* Type library registration (w/o interfaces).
1392	*/
1393
1394	/* Open Classes/TypeLib/. */
1395	rc = vbpsCreateRegKeyA(pState, pState->hkeyClassesRootDst, "TypeLib", &hkeyTypeLibs, __LINE__);
1396	if (rc != ERROR_SUCCESS)
1397	return;
1398
1399	/* Create TypeLib/{UUID}. */
1400	rc = vbpsCreateRegKeyA(pState, hkeyTypeLibs, vbpsFormatUuidInCurly(szTypeLibId, &LIBID_VirtualBox), &hkeyTypeLibId, __LINE__);
1401	if (rc == ERROR_SUCCESS)
1402	{
1403	/* {UUID}/Major.Minor/Default = pszDescription. */
1404	HKEY hkeyMajMin;
1405	char szMajMin[64];
1406	sprintf(szMajMin, "%u.%u", kTypeLibraryMajorVersion, kTypeLibraryMinorVersion);
1407	rc = vbpsCreateRegKeyWithDefaultValueAAEx(pState, hkeyTypeLibId, szMajMin, pszDescription, &hkeyMajMin, __LINE__);
1408	if (rc == ERROR_SUCCESS)
1409	{
1410	RTUTF16 wszBuf[MAX_PATH * 2];
1411
1412	/* {UUID}/Major.Minor/0. */
1413	HKEY hkey0;
1414	rc = vbpsCreateRegKeyA(pState, hkeyMajMin, "0", &hkey0, __LINE__);
1415	if (rc == ERROR_SUCCESS)
1416	{
1417	/* {UUID}/Major.Minor/0/winXX/Default = VBoxProxyStub. */
1418	rc = RTUtf16Copy(wszBuf, MAX_PATH, pwszVBoxDir); AssertRC(rc);
1419	rc = RTUtf16CatAscii(wszBuf, MAX_PATH * 2, pszTypeLibDll); AssertRC(rc);
1420
1421	vbpsCreateRegKeyWithDefaultValueAW(pState, hkey0, pszWinXx, wszBuf, __LINE__);
1422	vbpsCloseKey(pState, hkey0, __LINE__);
1423	}
1424
1425	/* {UUID}/Major.Minor/FLAGS */
1426	vbpsCreateRegKeyWithDefaultValueAA(pState, hkeyMajMin, "FLAGS", "0", __LINE__);
1427
1428	/* {UUID}/Major.Minor/HELPDIR */
1429	rc = RTUtf16Copy(wszBuf, MAX_PATH, pwszVBoxDir); AssertRC(rc);
1430	#if 0 /* MSI: trailing slash; regsvr32/comregister: strip unnecessary trailing slash. Go with MSI to avoid user issues. */
1431	{
1432	size_t off = RTUtf16Len(wszBuf);
1433	while (off > 2 && wszBuf[off - 2] != ':' && RTPATH_IS_SLASH(wszBuf[off - 1]))
1434	off--;
1435	wszBuf[off] = '\0';
1436	}
1437	#endif
1438	vbpsCreateRegKeyWithDefaultValueAW(pState, hkeyMajMin, "HELPDIR", wszBuf, __LINE__);
1439
1440	vbpsCloseKey(pState, hkeyMajMin, __LINE__);
1441	}
1442	vbpsCloseKey(pState, hkeyTypeLibId, __LINE__);
1443	}
1444	vbpsCloseKey(pState, hkeyTypeLibs, __LINE__);
1445	}
1446
1447
1448	/**
1449	* Update the VBox proxy stub registration.
1450	*
1451	* This is only used when updating COM registrations during com::Initialize.
1452	* For normal registration and unregistrations we use the NdrDllRegisterProxy
1453	* and NdrDllUnregisterProxy.
1454	*
1455	* @param pState The registry modifier state.
1456	* @param pwszVBoxDir The VirtualBox install directory (unicode),
1457	* trailing slash.
1458	* @param fIs32On64 Set if we're registering the 32-bit proxy stub
1459	* on a 64-bit system.
1460	*/
1461	static void vbpsUpdateProxyStubRegistration(VBPSREGSTATE *pState, PCRTUTF16 pwszVBoxDir, bool fIs32On64)
1462	{
1463	/*
1464	* Register the proxy stub factory class ID.
1465	* It's simple compared to the VBox classes, thus all the NULL parameters.
1466	*/
1467	const char *pszPsDll = VBPS_PROXY_STUB_FILE(fIs32On64);
1468	RT_NOREF(fIs32On64);
1469	Assert(pState->fUpdate && !pState->fDelete);
1470	VbpsRegisterClassId(pState, &g_ProxyClsId, "PSFactoryBuffer", NULL /pszAppId/,
1471	NULL /pszClassName/, NULL /pszCurClassNameVerSuffix/, NULL /pTypeLibId/,
1472	"InprocServer32", pwszVBoxDir, pszPsDll, "Both");
1473	}
1474
1475
1476	/**
1477	* Updates the VBox interface registrations.
1478	*
1479	* This is only used when updating COM registrations during com::Initialize.
1480	* For normal registration and unregistrations we use the NdrDllRegisterProxy
1481	* and NdrDllUnregisterProxy.
1482	*
1483	* @param pState The registry modifier state.
1484	*/
1485	static void vbpsUpdateInterfaceRegistrations(VBPSREGSTATE *pState)
1486	{
1487	const ProxyFileInfo **ppProxyFile = &g_apProxyFiles[0];
1488	const ProxyFileInfo *pProxyFile;
1489	LSTATUS rc;
1490	char szProxyClsId[CURLY_UUID_STR_BUF_SIZE];
1491	char szTypeLibId[CURLY_UUID_STR_BUF_SIZE];
1492	char szTypeLibVersion[64];
1493
1494	vbpsFormatUuidInCurly(szProxyClsId, &g_ProxyClsId);
1495	vbpsFormatUuidInCurly(szTypeLibId, &LIBID_VirtualBox);
1496	sprintf(szTypeLibVersion, "%u.%u", kTypeLibraryMajorVersion, kTypeLibraryMinorVersion);
1497
1498	Assert(pState->fUpdate && !pState->fDelete);
1499	rc = vbpsRegOpenInterfaceKeys(pState);
1500	if (rc != ERROR_SUCCESS)
1501	return;
1502
1503	/*
1504	* We walk the proxy file list (even if we only have one).
1505	*/
1506	while ((pProxyFile = *ppProxyFile++) != NULL)
1507	{
1508	const PCInterfaceStubVtblList * const papStubVtbls = pProxyFile->pStubVtblList;
1509	const char * const *papszNames = pProxyFile->pNamesArray;
1510	unsigned iIf = pProxyFile->TableSize;
1511	AssertStmt(iIf < 1024, iIf = 0);
1512	Assert(pProxyFile->TableVersion == 2);
1513
1514	/*
1515	* Walk the interfaces in that file, picking data from the various tables.
1516	*/
1517	while (iIf-- > 0)
1518	{
1519	char szIfId[CURLY_UUID_STR_BUF_SIZE];
1520	const char * const pszIfNm = papszNames[iIf];
1521	size_t const cchIfNm = RT_VALID_PTR(pszIfNm) ? strlen(pszIfNm) : 0;
1522	char szMethods[32];
1523	uint32_t const cMethods = papStubVtbls[iIf]->header.DispatchTableCount;
1524	HKEY hkeyIfId;
1525
1526	AssertReturnVoidStmt(cchIfNm >= 3 && cchIfNm <= 72, pState->rc = ERROR_INVALID_DATA);
1527
1528	AssertReturnVoidStmt(cMethods >= 3 && cMethods < 1024, pState->rc = ERROR_INVALID_DATA);
1529	sprintf(szMethods, "%u", cMethods);
1530
1531	rc = vbpsCreateRegKeyWithDefaultValueAAEx(pState, pState->hkeyInterfaceRootDst,
1532	vbpsFormatUuidInCurly(szIfId, papStubVtbls[iIf]->header.piid),
1533	pszIfNm, &hkeyIfId, __LINE__);
1534	if (rc == ERROR_SUCCESS)
1535	{
1536	HKEY hkeyTypeLib;
1537	vbpsCreateRegKeyWithDefaultValueAA(pState, hkeyIfId, "ProxyStubClsid32", szProxyClsId, __LINE__);
1538	vbpsCreateRegKeyWithDefaultValueAA(pState, hkeyIfId, "NumMethods", szMethods, __LINE__);
1539
1540	/* The MSI seems to still be putting TypeLib keys here. So, let's do that too. */
1541	rc = vbpsCreateRegKeyWithDefaultValueAAEx(pState, hkeyIfId, "TypeLib", szTypeLibId, &hkeyTypeLib, __LINE__);
1542	if (rc == ERROR_SUCCESS)
1543	{
1544	vbpsSetRegValueAA(pState, hkeyTypeLib, "Version", szTypeLibVersion, __LINE__);
1545	vbpsCloseKey(pState, hkeyTypeLib, __LINE__);
1546	}
1547
1548	vbpsCloseKey(pState, hkeyIfId, __LINE__);
1549	}
1550	}
1551	}
1552	}
1553
1554
1555	static bool vbpsIsUpToDate(VBPSREGSTATE *pState)
1556	{
1557	/** @todo read some registry key and */
1558	NOREF(pState);
1559	return false;
1560	}
1561
1562	static bool vbpsMarkUpToDate(VBPSREGSTATE *pState)
1563	{
1564	/** @todo write the key vbpsIsUpToDate uses, if pState indicates success. */
1565	NOREF(pState);
1566	return false;
1567	}
1568
1569
1570
1571	/**
1572	* Strips the stub dll name and any x86 subdir off the full DLL path to get a
1573	* path to the VirtualBox application directory.
1574	*
1575	* @param pwszDllPath The path to strip, returns will end with a slash.
1576	*/
1577	static void vbpsDllPathToVBoxDir(PRTUTF16 pwszDllPath)
1578	{
1579	RTUTF16 wc;
1580	size_t off = RTUtf16Len(pwszDllPath);
1581	while ( off > 0
1582	&& ( (wc = pwszDllPath[off - 1]) >= 127U
1583	\|\| !RTPATH_IS_SEP((unsigned char)wc)))
1584	off--;
1585
1586	#ifdef VBOX_IN_32_ON_64_MAIN_API
1587	/*
1588	* The -x86 variant is in a x86 subdirectory, drop it.
1589	*/
1590	while ( off > 0
1591	&& ( (wc = pwszDllPath[off - 1]) < 127U
1592	&& RTPATH_IS_SEP((unsigned char)wc)))
1593	off--;
1594	while ( off > 0
1595	&& ( (wc = pwszDllPath[off - 1]) >= 127U
1596	\|\| !RTPATH_IS_SEP((unsigned char)wc)))
1597	off--;
1598	#endif
1599	pwszDllPath[off] = '\0';
1600	}
1601
1602
1603	/**
1604	* Wrapper around RegisterXidlModulesAndClassesGenerated for the convenience of
1605	* the standard registration entry points.
1606	*
1607	* @returns COM status code.
1608	* @param pwszVBoxDir The VirtualBox install directory (unicode),
1609	* trailing slash.
1610	* @param fDelete Whether to delete registration keys and values.
1611	* @param fUpdate Whether to update registration keys and values.
1612	*/
1613	HRESULT RegisterXidlModulesAndClasses(PRTUTF16 pwszVBoxDir, bool fDelete, bool fUpdate)
1614	{
1615	#ifdef VBOX_IN_32_ON_64_MAIN_API
1616	bool const fIs32On64 = true;
1617	#else
1618	bool const fIs32On64 = false;
1619	#endif
1620	VBPSREGSTATE State;
1621	LSTATUS rc;
1622
1623	/*
1624	* Do registration for the current execution mode of the DLL.
1625	*/
1626	rc = vbpsRegInit(&State, HKEY_CLASSES_ROOT, NULL /* Alt: HKEY_LOCAL_MACHINE, "Software\\Classes", */, fDelete, fUpdate, 0);
1627	if (rc == ERROR_SUCCESS)
1628	{
1629	if (!fUpdate)
1630	{
1631	/* When only unregistering, really purge everything twice or trice. :-) */
1632	vbpsRegAddAltDelete(&State, HKEY_LOCAL_MACHINE, "Software\\Classes");
1633	vbpsRegAddAltDelete(&State, HKEY_CURRENT_USER, "Software\\Classes");
1634	vbpsRegAddAltDelete(&State, HKEY_CLASSES_ROOT, NULL);
1635	}
1636
1637	RegisterXidlModulesAndClassesGenerated(&State, pwszVBoxDir, fIs32On64);
1638	rc = State.rc;
1639	}
1640	vbpsRegTerm(&State);
1641
1642	/*
1643	* Translate error code? Return.
1644	*/
1645	if (rc == ERROR_SUCCESS)
1646	return S_OK;
1647	return E_FAIL;
1648	}
1649
1650
1651	/**
1652	* Checks if the string matches any of our type library versions.
1653	*
1654	* @returns true on match, false on mismatch.
1655	* @param pwszTypeLibVersion The type library version string.
1656	*/
1657	DECLINLINE(bool) vbpsIsTypeLibVersionToRemove(PCRTUTF16 pwszTypeLibVersion)
1658	{
1659	AssertCompile(RT_ELEMENTS(g_apwszTypelibVersions) == 2);
1660
1661	/* ASSUMES: 1.x version strings and that the input buffer is at least 3 wchars long. */
1662	if ( g_apwszTypelibVersions[0][3] == pwszTypeLibVersion[3]
1663	&& RTUtf16Cmp(g_apwszTypelibVersions[0], pwszTypeLibVersion) == 0)
1664	return true;
1665	if ( g_apwszTypelibVersions[1][3] == pwszTypeLibVersion[3]
1666	&& RTUtf16Cmp(g_apwszTypelibVersions[1], pwszTypeLibVersion) == 0)
1667	return true;
1668
1669	return false;
1670	}
1671
1672
1673	/**
1674	* Quick check whether the given string looks like a UUID in braces.
1675	*
1676	* This does not check the whole string, just do a quick sweep.
1677	*
1678	* @returns true if possible UUID, false if definitely not.
1679	* @param pwszUuid Alleged UUID in braces.
1680	*/
1681	DECLINLINE(bool) vbpsIsUuidInBracesQuickW(PCRTUTF16 pwszUuid)
1682	{
1683	return pwszUuid[ 0] == '{'
1684	&& pwszUuid[ 9] == '-'
1685	&& pwszUuid[14] == '-'
1686	&& pwszUuid[19] == '-'
1687	&& pwszUuid[24] == '-'
1688	&& pwszUuid[37] == '}'
1689	&& pwszUuid[38] == '\0'
1690	&& RT_C_IS_XDIGIT(pwszUuid[1]);
1691	}
1692
1693
1694	/**
1695	* Compares two UUIDs (in braces).
1696	*
1697	* @returns true on match, false if no match.
1698	* @param pwszUuid1 The first UUID.
1699	* @param pwszUuid2 The second UUID.
1700	*/
1701	static bool vbpsCompareUuidW(PCRTUTF16 pwszUuid1, PCRTUTF16 pwszUuid2)
1702	{
1703	#define COMPARE_EXACT_RET(a_wch1, a_wch2) \
1704	if ((a_wch1) == (a_wch2)) { } else return false
1705
1706	#define COMPARE_XDIGITS_RET(a_wch1, a_wch2) \
1707	if ((a_wch1) == (a_wch2)) { } \
1708	else if (RT_C_TO_UPPER(a_wch1) != RT_C_TO_UPPER(a_wch2) \|\| (a_wch1) >= 127U \|\| (a_wch2) >= 127U) \
1709	return false
1710	COMPARE_EXACT_RET( pwszUuid1[ 0], pwszUuid2[ 0]); /* { */
1711	COMPARE_XDIGITS_RET(pwszUuid1[ 1], pwszUuid2[ 1]); /* 5 */
1712	COMPARE_XDIGITS_RET(pwszUuid1[ 2], pwszUuid2[ 2]); /* e */
1713	COMPARE_XDIGITS_RET(pwszUuid1[ 3], pwszUuid2[ 3]); /* 5 */
1714	COMPARE_XDIGITS_RET(pwszUuid1[ 4], pwszUuid2[ 4]); /* e */
1715	COMPARE_XDIGITS_RET(pwszUuid1[ 5], pwszUuid2[ 5]); /* 3 */
1716	COMPARE_XDIGITS_RET(pwszUuid1[ 6], pwszUuid2[ 6]); /* 6 */
1717	COMPARE_XDIGITS_RET(pwszUuid1[ 7], pwszUuid2[ 7]); /* 4 */
1718	COMPARE_XDIGITS_RET(pwszUuid1[ 8], pwszUuid2[ 8]); /* 0 */
1719	COMPARE_EXACT_RET( pwszUuid1[ 9], pwszUuid2[ 9]); /* - */
1720	COMPARE_XDIGITS_RET(pwszUuid1[10], pwszUuid2[10]); /* 7 */
1721	COMPARE_XDIGITS_RET(pwszUuid1[11], pwszUuid2[11]); /* 4 */
1722	COMPARE_XDIGITS_RET(pwszUuid1[12], pwszUuid2[12]); /* f */
1723	COMPARE_XDIGITS_RET(pwszUuid1[13], pwszUuid2[13]); /* 3 */
1724	COMPARE_EXACT_RET( pwszUuid1[14], pwszUuid2[14]); /* - */
1725	COMPARE_XDIGITS_RET(pwszUuid1[15], pwszUuid2[15]); /* 4 */
1726	COMPARE_XDIGITS_RET(pwszUuid1[16], pwszUuid2[16]); /* 6 */
1727	COMPARE_XDIGITS_RET(pwszUuid1[17], pwszUuid2[17]); /* 8 */
1728	COMPARE_XDIGITS_RET(pwszUuid1[18], pwszUuid2[18]); /* 9 */
1729	COMPARE_EXACT_RET( pwszUuid1[19], pwszUuid2[19]); /* - */
1730	COMPARE_XDIGITS_RET(pwszUuid1[20], pwszUuid2[20]); /* 9 */
1731	COMPARE_XDIGITS_RET(pwszUuid1[21], pwszUuid2[21]); /* 7 */
1732	COMPARE_XDIGITS_RET(pwszUuid1[22], pwszUuid2[22]); /* 9 */
1733	COMPARE_XDIGITS_RET(pwszUuid1[23], pwszUuid2[23]); /* f */
1734	COMPARE_EXACT_RET( pwszUuid1[24], pwszUuid2[24]); /* - */
1735	COMPARE_XDIGITS_RET(pwszUuid1[25], pwszUuid2[25]); /* 6 */
1736	COMPARE_XDIGITS_RET(pwszUuid1[26], pwszUuid2[26]); /* b */
1737	COMPARE_XDIGITS_RET(pwszUuid1[27], pwszUuid2[27]); /* 1 */
1738	COMPARE_XDIGITS_RET(pwszUuid1[28], pwszUuid2[28]); /* b */
1739	COMPARE_XDIGITS_RET(pwszUuid1[29], pwszUuid2[29]); /* 8 */
1740	COMPARE_XDIGITS_RET(pwszUuid1[30], pwszUuid2[30]); /* d */
1741	COMPARE_XDIGITS_RET(pwszUuid1[31], pwszUuid2[31]); /* 7 */
1742	COMPARE_XDIGITS_RET(pwszUuid1[32], pwszUuid2[32]); /* 6 */
1743	COMPARE_XDIGITS_RET(pwszUuid1[33], pwszUuid2[33]); /* 0 */
1744	COMPARE_XDIGITS_RET(pwszUuid1[34], pwszUuid2[34]); /* 9 */
1745	COMPARE_XDIGITS_RET(pwszUuid1[35], pwszUuid2[35]); /* a */
1746	COMPARE_XDIGITS_RET(pwszUuid1[36], pwszUuid2[36]); /* 5 */
1747	COMPARE_EXACT_RET( pwszUuid1[37], pwszUuid2[37]); /* } */
1748	COMPARE_EXACT_RET( pwszUuid1[38], pwszUuid2[38]); /* \0 */
1749	#undef COMPARE_EXACT_RET
1750	#undef COMPARE_XDIGITS_RET
1751	return true;
1752	}
1753
1754
1755	/**
1756	* Checks if the type library ID is one of the ones we wish to clean up.
1757	*
1758	* @returns true if it should be cleaned up, false if not.
1759	* @param pwszTypeLibId The type library ID as a bracketed string.
1760	*/
1761	DECLINLINE(bool) vbpsIsTypeLibIdToRemove(PRTUTF16 pwszTypeLibId)
1762	{
1763	AssertCompile(RT_ELEMENTS(g_apwszTypeLibIds) == 2);
1764	#ifdef VBOX_STRICT
1765	static bool s_fDoneStrict = false;
1766	if (s_fDoneStrict) { }
1767	else
1768	{
1769	Assert(RT_ELEMENTS(g_apwszTypeLibIds) == 2);
1770	Assert(g_apwszTypeLibIds[0][0] == '{');
1771	Assert(g_apwszTypeLibIds[1][0] == '{');
1772	Assert(RT_C_IS_XDIGIT(g_apwszTypeLibIds[0][1]));
1773	Assert(RT_C_IS_XDIGIT(g_apwszTypeLibIds[1][1]));
1774	Assert(RT_C_IS_UPPER(g_apwszTypeLibIds[0][1]) \|\| RT_C_IS_DIGIT(g_apwszTypeLibIds[0][1]));
1775	Assert(RT_C_IS_UPPER(g_apwszTypeLibIds[1][1]) \|\| RT_C_IS_DIGIT(g_apwszTypeLibIds[1][1]));
1776	s_fDoneStrict = true;
1777	}
1778	#endif
1779
1780	/*
1781	* Rolled out matching with inlined check of the opening braces
1782	* and first two digits.
1783	*
1784	* ASSUMES input buffer is at least 3 wchars big and uppercased UUID in
1785	* our matching array.
1786	*/
1787	if (pwszTypeLibId[0] == '{')
1788	{
1789	RTUTF16 const wcFirstDigit = RT_C_TO_UPPER(pwszTypeLibId[1]);
1790	RTUTF16 const wcSecondDigit = RT_C_TO_UPPER(pwszTypeLibId[2]);
1791	PCRTUTF16 pwsz2 = g_apwszTypeLibIds[0];
1792	if ( wcFirstDigit == pwsz2[1]
1793	&& wcSecondDigit == pwsz2[2]
1794	&& vbpsCompareUuidW(pwszTypeLibId, pwsz2))
1795	return true;
1796	pwsz2 = g_apwszTypeLibIds[1];
1797	if ( wcFirstDigit == pwsz2[1]
1798	&& wcSecondDigit == pwsz2[2]
1799	&& vbpsCompareUuidW(pwszTypeLibId, pwsz2))
1800	return true;
1801	}
1802	return false;
1803	}
1804
1805
1806	/**
1807	* Checks if the proxy stub class ID is one of the ones we wish to clean up.
1808	*
1809	* @returns true if it should be cleaned up, false if not.
1810	* @param pwszProxyStubId The proxy stub class ID.
1811	*/
1812	DECLINLINE(bool) vbpsIsProxyStubClsIdToRemove(PRTUTF16 pwszProxyStubId)
1813	{
1814	AssertCompile(RT_ELEMENTS(g_apwszProxyStubClsIds) == 2);
1815	#ifdef VBOX_STRICT
1816	static bool s_fDoneStrict = false;
1817	if (s_fDoneStrict) { }
1818	else
1819	{
1820	Assert(RT_ELEMENTS(g_apwszProxyStubClsIds) == 2);
1821	Assert(g_apwszProxyStubClsIds[0][0] == '{');
1822	Assert(g_apwszProxyStubClsIds[1][0] == '{');
1823	Assert(RT_C_IS_XDIGIT(g_apwszProxyStubClsIds[0][1]));
1824	Assert(RT_C_IS_XDIGIT(g_apwszProxyStubClsIds[1][1]));
1825	Assert(RT_C_IS_UPPER(g_apwszProxyStubClsIds[0][1]) \|\| RT_C_IS_DIGIT(g_apwszProxyStubClsIds[0][1]));
1826	Assert(RT_C_IS_UPPER(g_apwszProxyStubClsIds[1][1]) \|\| RT_C_IS_DIGIT(g_apwszProxyStubClsIds[1][1]));
1827	s_fDoneStrict = true;
1828	}
1829	#endif
1830
1831	/*
1832	* Rolled out matching with inlined check of the opening braces
1833	* and first two digits.
1834	*
1835	* ASSUMES input buffer is at least 3 wchars big and uppercased UUID in
1836	* our matching array.
1837	*/
1838	if (pwszProxyStubId[0] == '{')
1839	{
1840	RTUTF16 const wcFirstDigit = RT_C_TO_UPPER(pwszProxyStubId[1]);
1841	RTUTF16 const wcSecondDigit = RT_C_TO_UPPER(pwszProxyStubId[2]);
1842	PCRTUTF16 pwsz2 = g_apwszProxyStubClsIds[0];
1843	if ( wcFirstDigit == pwsz2[1]
1844	&& wcSecondDigit == pwsz2[2]
1845	&& vbpsCompareUuidW(pwszProxyStubId, pwsz2))
1846	return true;
1847	pwsz2 = g_apwszProxyStubClsIds[1];
1848	if ( wcFirstDigit == pwsz2[1]
1849	&& wcSecondDigit == pwsz2[2]
1850	&& vbpsCompareUuidW(pwszProxyStubId, pwsz2))
1851	return true;
1852	}
1853	return false;
1854	}
1855
1856
1857	/**
1858	* Hack to clean out the interfaces belonging to obsolete typelibs on
1859	* development boxes and such likes.
1860	*/
1861	static void vbpsRemoveOldInterfaces(VBPSREGSTATE *pState)
1862	{
1863	unsigned iAlt = pState->cAltDeletes;
1864	while (iAlt-- > 0)
1865	{
1866	/*
1867	* Open the interface root key. Not using the vbpsRegOpenInterfaceKeys feature
1868	* here in case it messes things up by keeping the special HKEY_CLASSES_ROOT key
1869	* open with possibly pending deletes in parent views or other weird stuff.
1870	*/
1871	HKEY hkeyInterfaces;
1872	LRESULT rc = RegOpenKeyExW(pState->aAltDeletes[iAlt].hkeyClasses, L"Interface",
1873	0 /fOptions/, pState->fSamDelete, &hkeyInterfaces);
1874	if (rc == ERROR_SUCCESS)
1875	{
1876	/*
1877	* This is kind of expensive, but we have to check all registered interfaces.
1878	* Only use wide APIs to avoid wasting time on string conversion.
1879	*/
1880	DWORD idxKey;
1881	for (idxKey = 0;; idxKey++)
1882	{
1883	RTUTF16 wszCurNm[128 + 48];
1884	DWORD cwcCurNm = 128;
1885	rc = RegEnumKeyExW(hkeyInterfaces, idxKey, wszCurNm, &cwcCurNm,
1886	NULL /pdwReserved/, NULL /pwszClass/, NULL /pcwcClass/, NULL /pLastWriteTime/);
1887	if (rc == ERROR_SUCCESS)
1888	{
1889	/*
1890	* We match the interface by type library ID or proxy stub class ID.
1891	*
1892	* We have to check the proxy ID last, as it is almost always there
1893	* and we can safely skip it if there is a mismatching type lib
1894	* associated with the interface.
1895	*/
1896	static RTUTF16 const s_wszTypeLib[] = L"\\TypeLib";
1897	bool fDeleteMe = false;
1898	HKEY hkeySub;
1899	RTUTF16 wszValue[128];
1900	DWORD cbValue;
1901	DWORD dwType;
1902
1903	/* Skip this entry if it doesn't look like a braced UUID. */
1904	wszCurNm[cwcCurNm] = '\0'; /* paranoia */
1905	if (vbpsIsUuidInBracesQuickW(wszCurNm)) { }
1906	else continue;
1907
1908	/* Try the TypeLib sub-key. */
1909	memcpy(&wszCurNm[cwcCurNm], s_wszTypeLib, sizeof(s_wszTypeLib));
1910	rc = RegOpenKeyExW(hkeyInterfaces, wszCurNm, 0 /fOptions/, KEY_QUERY_VALUE, &hkeySub);
1911	if (rc == ERROR_SUCCESS)
1912	{
1913	cbValue = sizeof(wszValue) - sizeof(RTUTF16);
1914	rc = RegQueryValueExW(hkeySub, NULL /pszValueNm/, NULL /pdwReserved/,
1915	&dwType, (PBYTE)&wszValue[0], &cbValue);
1916	if (rc != ERROR_SUCCESS \|\| dwType != REG_SZ)
1917	cbValue = 0;
1918	wszValue[cbValue / sizeof(RTUTF16)] = '\0';
1919
1920	if ( rc == ERROR_SUCCESS
1921	&& vbpsIsTypeLibIdToRemove(wszValue))
1922	{
1923	/* Check the TypeLib/Version value to make sure. */
1924	cbValue = sizeof(wszValue) - sizeof(RTUTF16);
1925	rc = RegQueryValueExW(hkeySub, L"Version", 0 /pdwReserved/, &dwType, (PBYTE)&wszValue[0], &cbValue);
1926	if (rc != ERROR_SUCCESS)
1927	cbValue = 0;
1928	wszValue[cbValue] = '\0';
1929
1930	if ( rc == ERROR_SUCCESS
1931	&& vbpsIsTypeLibVersionToRemove(wszValue))
1932	fDeleteMe = true;
1933	}
1934	vbpsCloseKey(pState, hkeySub, __LINE__);
1935	}
1936	else if (rc == ERROR_FILE_NOT_FOUND)
1937	{
1938	/* No TypeLib, try the ProxyStubClsid32 sub-key next. */
1939	static RTUTF16 const s_wszProxyStubClsid32[] = L"\\ProxyStubClsid32";
1940	memcpy(&wszCurNm[cwcCurNm], s_wszProxyStubClsid32, sizeof(s_wszProxyStubClsid32));
1941	rc = RegOpenKeyExW(hkeyInterfaces, wszCurNm, 0 /fOptions/, KEY_QUERY_VALUE, &hkeySub);
1942	if (rc == ERROR_SUCCESS)
1943	{
1944	cbValue = sizeof(wszValue) - sizeof(RTUTF16);
1945	rc = RegQueryValueExW(hkeySub, NULL /pszValueNm/, NULL /pdwReserved/,
1946	&dwType, (PBYTE)&wszValue[0], &cbValue);
1947	if (rc != ERROR_SUCCESS \|\| dwType != REG_SZ)
1948	cbValue = 0;
1949	wszValue[cbValue / sizeof(RTUTF16)] = '\0';
1950
1951	if ( rc == ERROR_SUCCESS
1952	&& vbpsIsProxyStubClsIdToRemove(wszValue))
1953	fDeleteMe = true;
1954
1955	vbpsCloseKey(pState, hkeySub, __LINE__);
1956	}
1957	}
1958
1959	if (fDeleteMe)
1960	{
1961	/*
1962	* Ok, it's an orphaned VirtualBox interface. Delete it.
1963	*/
1964	wszCurNm[cwcCurNm] = '\0';
1965	vbpsDeleteKeyRecursiveW(pState, hkeyInterfaces, wszCurNm, __LINE__);
1966	}
1967	}
1968	else
1969	{
1970	Assert(rc == ERROR_NO_MORE_ITEMS);
1971	break;
1972	}
1973	}
1974
1975	vbpsCloseKey(pState, hkeyInterfaces, __LINE__);
1976	}
1977	}
1978	}
1979
1980
1981	/**
1982	* Hack to clean out the class IDs belonging to obsolete typelibs on development
1983	* boxes and such likes.
1984	*/
1985	static void vbpsRemoveOldClassIDs(VBPSREGSTATE *pState)
1986	{
1987	unsigned iAlt = pState->cAltDeletes;
1988	while (iAlt-- > 0)
1989	{
1990	/*
1991	* Open the CLSID key if it exists.
1992	* We don't use the hKeyClsid member for the same paranoid reasons as
1993	* already stated in vbpsRemoveOldInterfaces.
1994	*/
1995	HKEY hkeyClsIds;
1996	LRESULT rc;
1997	rc = RegOpenKeyExW(pState->aAltDeletes[iAlt].hkeyClasses, L"CLSID", 0 /fOptions/, pState->fSamDelete, &hkeyClsIds);
1998	if (rc == ERROR_SUCCESS)
1999	{
2000	/*
2001	* This is kind of expensive, but we have to check all registered interfaces.
2002	* Only use wide APIs to avoid wasting time on string conversion.
2003	*/
2004	DWORD idxKey;
2005	for (idxKey = 0;; idxKey++)
2006	{
2007	RTUTF16 wszCurNm[128 + 48];
2008	DWORD cwcCurNm = 128;
2009	rc = RegEnumKeyExW(hkeyClsIds, idxKey, wszCurNm, &cwcCurNm,
2010	NULL /pdwReserved/, NULL /pwszClass/, NULL /pcwcClass/, NULL /pLastWriteTime/);
2011	if (rc == ERROR_SUCCESS)
2012	{
2013	/*
2014	* Match both the type library ID and the program ID.
2015	*/
2016	static RTUTF16 const s_wszTypeLib[] = L"\\TypeLib";
2017	HKEY hkeySub;
2018	RTUTF16 wszValue[128];
2019	DWORD cbValue;
2020	DWORD dwType;
2021
2022
2023	/* Skip this entry if it doesn't look like a braced UUID. (Microsoft
2024	has one two malformed ones plus a hack.) */
2025	wszCurNm[cwcCurNm] = '\0'; /* paranoia */
2026	if (vbpsIsUuidInBracesQuickW(wszCurNm)) { }
2027	else continue;
2028
2029	/* The TypeLib sub-key. */
2030	memcpy(&wszCurNm[cwcCurNm], s_wszTypeLib, sizeof(s_wszTypeLib));
2031	rc = RegOpenKeyExW(hkeyClsIds, wszCurNm, 0 /fOptions/, KEY_QUERY_VALUE, &hkeySub);
2032	if (rc == ERROR_SUCCESS)
2033	{
2034	bool fDeleteMe = false;
2035
2036	cbValue = sizeof(wszValue) - sizeof(RTUTF16);
2037	rc = RegQueryValueExW(hkeySub, NULL /pszValueNm/, NULL /pdwReserved/,
2038	&dwType, (PBYTE)&wszValue[0], &cbValue);
2039	if (rc != ERROR_SUCCESS \|\| dwType != REG_SZ)
2040	cbValue = 0;
2041	wszValue[cbValue / sizeof(RTUTF16)] = '\0';
2042
2043	if ( rc == ERROR_SUCCESS
2044	&& vbpsIsTypeLibIdToRemove(wszValue))
2045	fDeleteMe = true;
2046
2047	vbpsCloseKey(pState, hkeySub, __LINE__);
2048
2049	if (fDeleteMe)
2050	{
2051	/* The ProgId sub-key. */
2052	static RTUTF16 const s_wszProgId[] = L"\\ProgId";
2053	memcpy(&wszCurNm[cwcCurNm], s_wszProgId, sizeof(s_wszProgId));
2054	rc = RegOpenKeyExW(hkeyClsIds, wszCurNm, 0 /fOptions/, KEY_QUERY_VALUE, &hkeySub);
2055	if (rc == ERROR_SUCCESS)
2056	{
2057	static RTUTF16 const s_wszProgIdPrefix[] = L"VirtualBox.";
2058
2059	cbValue = sizeof(wszValue) - sizeof(RTUTF16);
2060	rc = RegQueryValueExW(hkeySub, NULL /pszValueNm/, NULL /pdwReserved/,
2061	&dwType, (PBYTE)&wszValue[0], &cbValue);
2062	if (rc != ERROR_SUCCESS \|\| dwType != REG_SZ)
2063	cbValue = 0;
2064	wszValue[cbValue / sizeof(RTUTF16)] = '\0';
2065
2066	if ( cbValue < sizeof(s_wszProgIdPrefix)
2067	\|\| memcmp(wszValue, s_wszProgIdPrefix, sizeof(s_wszProgIdPrefix) - sizeof(RTUTF16)) != 0)
2068	fDeleteMe = false;
2069
2070	vbpsCloseKey(pState, hkeySub, __LINE__);
2071	}
2072	else
2073	AssertStmt(rc == ERROR_FILE_NOT_FOUND, fDeleteMe = false);
2074
2075	if (fDeleteMe)
2076	{
2077	/*
2078	* Ok, it's an orphaned VirtualBox interface. Delete it.
2079	*/
2080	wszCurNm[cwcCurNm] = '\0';
2081	vbpsDeleteKeyRecursiveW(pState, hkeyClsIds, wszCurNm, __LINE__);
2082	}
2083	}
2084	}
2085	else
2086	Assert(rc == ERROR_FILE_NOT_FOUND);
2087	}
2088	else
2089	{
2090	Assert(rc == ERROR_NO_MORE_ITEMS);
2091	break;
2092	}
2093	}
2094
2095	vbpsCloseKey(pState, hkeyClsIds, __LINE__);
2096	}
2097	else
2098	Assert(rc == ERROR_FILE_NOT_FOUND);
2099	}
2100	}
2101
2102
2103	/**
2104	* Hack to clean obsolete typelibs on development boxes and such.
2105	*/
2106	static void vbpsRemoveOldTypeLibs(VBPSREGSTATE *pState)
2107	{
2108	unsigned iAlt = pState->cAltDeletes;
2109	while (iAlt-- > 0)
2110	{
2111	/*
2112	* Open the TypeLib key, if it exists.
2113	*/
2114	HKEY hkeyTypeLibs;
2115	LSTATUS rc;
2116	rc = RegOpenKeyExW(pState->aAltDeletes[iAlt].hkeyClasses, L"TypeLib", 0 /fOptions/, pState->fSamDelete, &hkeyTypeLibs);
2117	if (rc == ERROR_SUCCESS)
2118	{
2119	/*
2120	* Look for our type library IDs.
2121	*/
2122	unsigned iTlb = RT_ELEMENTS(g_apwszTypeLibIds);
2123	while (iTlb-- > 0)
2124	{
2125	HKEY hkeyTypeLibId;
2126	rc = RegOpenKeyExW(hkeyTypeLibs, g_apwszTypeLibIds[iTlb], 0 /fOptions/, pState->fSamDelete, &hkeyTypeLibId);
2127	if (rc == ERROR_SUCCESS)
2128	{
2129	unsigned iVer = RT_ELEMENTS(g_apwszTypelibVersions);
2130	while (iVer-- > 0)
2131	{
2132	HKEY hkeyVer;
2133	rc = RegOpenKeyExW(hkeyTypeLibId, g_apwszTypelibVersions[iVer], 0, KEY_READ, &hkeyVer);
2134	if (rc == ERROR_SUCCESS)
2135	{
2136	char szValue[128];
2137	DWORD cbValue = sizeof(szValue) - 1;
2138	rc = RegQueryValueExA(hkeyVer, NULL, NULL, NULL, (PBYTE)&szValue[0], &cbValue);
2139	vbpsCloseKey(pState, hkeyVer, __LINE__);
2140	if (rc == ERROR_SUCCESS)
2141	{
2142	szValue[cbValue] = '\0';
2143	if (!strcmp(szValue, "VirtualBox Type Library"))
2144	{
2145	/*
2146	* Delete the type library version.
2147	* We do not delete the whole type library ID, just this version of it.
2148	*/
2149	vbpsDeleteKeyRecursiveW(pState, hkeyTypeLibId, g_apwszTypelibVersions[iVer], __LINE__);
2150	}
2151	}
2152	}
2153	}
2154	vbpsCloseKey(pState, hkeyTypeLibId, __LINE__);
2155
2156	/*
2157	* The type library ID key should be empty now, so we can try remove it (non-recursively).
2158	*/
2159	rc = RegDeleteKeyW(hkeyTypeLibs, g_apwszTypeLibIds[iTlb]);
2160	Assert(rc == ERROR_SUCCESS);
2161	}
2162	}
2163	}
2164	else
2165	Assert(rc == ERROR_FILE_NOT_FOUND);
2166	}
2167	}
2168
2169
2170	/**
2171	* Hack to clean out obsolete typelibs on development boxes and such.
2172	*/
2173	static void vbpsRemoveOldMessSub(REGSAM fSamWow)
2174	{
2175	/*
2176	* Note! The worker procedures does not use the default destination,
2177	* because it's much much simpler to enumerate alternative locations.
2178	*/
2179	VBPSREGSTATE State;
2180	LRESULT rc = vbpsRegInit(&State, HKEY_CLASSES_ROOT, NULL, true /fDelete/, false /fUpdate/, fSamWow);
2181	if (rc == ERROR_SUCCESS)
2182	{
2183	vbpsRegAddAltDelete(&State, HKEY_CURRENT_USER, "Software\\Classes");
2184	vbpsRegAddAltDelete(&State, HKEY_LOCAL_MACHINE, "Software\\Classes");
2185	vbpsRegAddAltDelete(&State, HKEY_CLASSES_ROOT, NULL);
2186
2187	vbpsRemoveOldInterfaces(&State);
2188	vbpsRemoveOldClassIDs(&State);
2189	vbpsRemoveOldTypeLibs(&State);
2190	}
2191	vbpsRegTerm(&State);
2192	}
2193
2194
2195	/**
2196	* Hack to clean out obsolete typelibs on development boxes and such.
2197	*/
2198	static void removeOldMess(void)
2199	{
2200	vbpsRemoveOldMessSub(0 /fSamWow/);
2201	#if ARCH_BITS == 64 \|\| defined(VBOX_IN_32_ON_64_MAIN_API)
2202	vbpsRemoveOldMessSub(KEY_WOW64_32KEY);
2203	#endif
2204	}
2205
2206
2207
2208	/**
2209	* Register the interfaces proxied by this DLL, and to avoid duplication and
2210	* minimize work the VBox type library, classes and servers are also registered.
2211	*
2212	* This is normally only used by developers via comregister.cmd and the heat.exe
2213	* tool during MSI creation. The only situation where users may end up here is
2214	* if they're playing around or we recommend it as a solution to COM problems.
2215	* So, no problem if this approach is less gentle, though we leave the cleaning
2216	* up of orphaned interfaces to DllUnregisterServer.
2217	*
2218	* @returns COM status code.
2219	*/
2220	HRESULT STDAPICALLTYPE DllRegisterServer(void)
2221	{
2222	HRESULT hrc;
2223
2224	/*
2225	* Register the type library first.
2226	*/
2227	ITypeLib *pITypeLib;
2228	WCHAR wszDllName[MAX_PATH];
2229	DWORD cwcRet = GetModuleFileNameW(g_hDllSelf, wszDllName, RT_ELEMENTS(wszDllName));
2230	AssertReturn(cwcRet > 0 && cwcRet < RT_ELEMENTS(wszDllName), CO_E_PATHTOOLONG);
2231
2232	hrc = LoadTypeLib(wszDllName, &pITypeLib);
2233	AssertMsgReturn(SUCCEEDED(hrc), ("%Rhrc\n", hrc), hrc);
2234	hrc = RegisterTypeLib(pITypeLib, wszDllName, NULL /pszHelpDir/);
2235	pITypeLib->lpVtbl->Release(pITypeLib);
2236	AssertMsgReturn(SUCCEEDED(hrc), ("%Rhrc\n", hrc), hrc);
2237
2238	/*
2239	* Register proxy stub.
2240	*/
2241	hrc = NdrDllRegisterProxy(g_hDllSelf, &g_apProxyFiles[0], &g_ProxyClsId); /* see DLLREGISTRY_ROUTINES in RpcProxy.h */
2242	AssertMsgReturn(SUCCEEDED(hrc), ("%Rhrc\n", hrc), hrc);
2243
2244	/*
2245	* Register the VBox modules and classes.
2246	*/
2247	vbpsDllPathToVBoxDir(wszDllName);
2248	hrc = RegisterXidlModulesAndClasses(wszDllName, true /fDelete/, true /fUpdate/);
2249	AssertMsgReturn(SUCCEEDED(hrc), ("%Rhrc\n", hrc), hrc);
2250
2251	return S_OK;
2252	}
2253
2254
2255	/**
2256	* Reverse of DllRegisterServer.
2257	*
2258	* This is normally only used by developers via comregister.cmd. Users may be
2259	* asked to perform it in order to fix some COM issue. So, it's OK if we spend
2260	* some extra time and clean up orphaned interfaces, because developer boxes
2261	* will end up with a bunch of those as interface UUIDs changes.
2262	*
2263	* @returns COM status code.
2264	*/
2265	HRESULT STDAPICALLTYPE DllUnregisterServer(void)
2266	{
2267	HRESULT hrc = S_OK;
2268	HRESULT hrc2;
2269
2270	/*
2271	* Unregister the type library.
2272	*
2273	* We ignore TYPE_E_REGISTRYACCESS as that is what is returned if the
2274	* type lib hasn't been registered (W10).
2275	*/
2276	hrc2 = UnRegisterTypeLib(&LIBID_VirtualBox, kTypeLibraryMajorVersion, kTypeLibraryMinorVersion,
2277	0 /LCid/, RT_CONCAT(SYS_WIN, ARCH_BITS));
2278	AssertMsgStmt(SUCCEEDED(hrc2) \|\| hrc2 == TYPE_E_REGISTRYACCESS, ("%Rhrc\n", hrc2), if (SUCCEEDED(hrc)) hrc = hrc2);
2279
2280	/*
2281	* Unregister the proxy stub.
2282	*
2283	* We ignore ERROR_FILE_NOT_FOUND as that is returned if not registered (W10).
2284	*/
2285	hrc2 = NdrDllUnregisterProxy(g_hDllSelf, &g_apProxyFiles[0], &g_ProxyClsId); /* see DLLREGISTRY_ROUTINES in RpcProxy.h */
2286	AssertMsgStmt( SUCCEEDED(hrc2)
2287	\|\| hrc2 == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_FILE_NOT_FOUND)
2288	\|\| hrc2 == REGDB_E_INVALIDVALUE,
2289	("%Rhrc\n", hrc2), if (SUCCEEDED(hrc)) hrc = hrc2);
2290
2291	/*
2292	* Register the VBox modules and classes.
2293	*/
2294	hrc2 = RegisterXidlModulesAndClasses(NULL, true /fDelete/, false /fUpdate/);
2295	AssertMsgStmt(SUCCEEDED(hrc2), ("%Rhrc\n", hrc2), if (SUCCEEDED(hrc)) hrc = hrc2);
2296
2297	/*
2298	* Purge old mess.
2299	*/
2300	removeOldMess();
2301
2302	return hrc;
2303	}
2304
2305
2306	#ifdef VBOX_WITH_SDS
2307	/**
2308	* Update a SCM service.
2309	*
2310	* @param pState The state.
2311	* @param pwszVBoxDir The VirtualBox install directory (unicode),
2312	* trailing slash.
2313	* @param pwszModule The service module.
2314	* @param pwszServiceName The service name.
2315	* @param pwszDisplayName The service display name.
2316	* @param pwszDescription The service description.
2317	*/
2318	static void vbpsUpdateWindowsService(VBPSREGSTATE pState, const WCHAR pwszVBoxDir, const WCHAR *pwszModule,
2319	const WCHAR pwszServiceName, const WCHAR pwszDisplayName, const WCHAR *pwszDescription)
2320	{
2321	SC_HANDLE hSCM;
2322
2323	/* Configuration options that are currently standard. */
2324	uint32_t const uServiceType = SERVICE_WIN32_OWN_PROCESS;
2325	uint32_t const uStartType = SERVICE_DEMAND_START;
2326	uint32_t const uErrorControl = SERVICE_ERROR_NORMAL;
2327	WCHAR const * const pwszServiceStartName = L"LocalSystem";
2328	static WCHAR const wszzDependencies[] = L"RPCSS\0";
2329
2330	/*
2331	* Make double quoted executable file path. ASSUMES pwszVBoxDir ends with a slash!
2332	*/
2333	WCHAR wszFilePath[MAX_PATH + 2];
2334	int rc = RTUtf16CopyAscii(wszFilePath, RT_ELEMENTS(wszFilePath), "\"");
2335	if (RT_SUCCESS(rc))
2336	rc = RTUtf16Cat(wszFilePath, RT_ELEMENTS(wszFilePath), pwszVBoxDir);
2337	if (RT_SUCCESS(rc))
2338	rc = RTUtf16Cat(wszFilePath, RT_ELEMENTS(wszFilePath), pwszModule);
2339	if (RT_SUCCESS(rc))
2340	rc = RTUtf16CatAscii(wszFilePath, RT_ELEMENTS(wszFilePath), "\"");
2341	AssertLogRelRCReturnVoid(rc);
2342
2343	/*
2344	* Open the service manager for the purpose of checking the configuration.
2345	*/
2346	hSCM = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
2347	if (hSCM != NULL)
2348	{
2349	union
2350	{
2351	QUERY_SERVICE_CONFIGW Config;
2352	SERVICE_STATUS Status;
2353	SERVICE_DESCRIPTIONW Desc;
2354	uint8_t abPadding[sizeof(QUERY_SERVICE_CONFIGW) + 5 * _1K];
2355	} uBuf;
2356	SC_HANDLE hService;
2357	bool fCreateIt = pState->fUpdate;
2358	bool fDeleteIt = true;
2359
2360	/*
2361	* Step #1: Open the service and validate the configuration.
2362	*/
2363	if (pState->fUpdate)
2364	{
2365	hService = OpenServiceW(hSCM, pwszServiceName, SERVICE_QUERY_CONFIG);
2366	if (hService != NULL)
2367	{
2368	DWORD cbNeeded = 0;
2369	if (QueryServiceConfigW(hService, &uBuf.Config, sizeof(uBuf), &cbNeeded))
2370	{
2371	if (uBuf.Config.dwErrorControl)
2372	{
2373	uint32_t cErrors = 0;
2374	if (uBuf.Config.dwServiceType != uServiceType)
2375	{
2376	LogRel(("update service '%ls': dwServiceType %u, expected %u\n",
2377	pwszServiceName, uBuf.Config.dwServiceType, uServiceType));
2378	cErrors++;
2379	}
2380	if (uBuf.Config.dwStartType != uStartType)
2381	{
2382	LogRel(("update service '%ls': dwStartType %u, expected %u\n",
2383	pwszServiceName, uBuf.Config.dwStartType, uStartType));
2384	cErrors++;
2385	}
2386	if (uBuf.Config.dwErrorControl != uErrorControl)
2387	{
2388	LogRel(("update service '%ls': dwErrorControl %u, expected %u\n",
2389	pwszServiceName, uBuf.Config.dwErrorControl, uErrorControl));
2390	cErrors++;
2391	}
2392	if (RTUtf16ICmp(uBuf.Config.lpBinaryPathName, wszFilePath) != 0)
2393	{
2394	LogRel(("update service '%ls': lpBinaryPathName '%ls', expected '%ls'\n",
2395	pwszServiceName, uBuf.Config.lpBinaryPathName, wszFilePath));
2396	cErrors++;
2397	}
2398	if ( uBuf.Config.lpServiceStartName != NULL
2399	&& *uBuf.Config.lpServiceStartName != L'\0'
2400	&& RTUtf16ICmp(uBuf.Config.lpServiceStartName, pwszServiceStartName) != 0)
2401	{
2402	LogRel(("update service '%ls': lpServiceStartName '%ls', expected '%ls'\n",
2403	pwszServiceName, uBuf.Config.lpBinaryPathName, pwszServiceStartName));
2404	cErrors++;
2405	}
2406
2407	fDeleteIt = fCreateIt = cErrors > 0;
2408	}
2409	}
2410	else
2411	AssertLogRelMsgFailed(("QueryServiceConfigW returned %u (cbNeeded=%u vs %zu)\n",
2412	GetLastError(), cbNeeded, sizeof(uBuf)));
2413	}
2414	else
2415	{
2416	DWORD dwErr = GetLastError();
2417	fDeleteIt = dwErr != ERROR_SERVICE_DOES_NOT_EXIST;
2418	AssertLogRelMsg(dwErr == ERROR_SERVICE_DOES_NOT_EXIST, ("OpenServiceW('%ls') -> %u\n", pwszServiceName, dwErr));
2419	}
2420	CloseServiceHandle(hService);
2421	}
2422
2423	/*
2424	* Step #2: Stop and delete the service if needed.
2425	* We can do this without reopening the service manager.
2426	*/
2427	if (fDeleteIt)
2428	{
2429	hService = OpenServiceW(hSCM, pwszServiceName, SERVICE_STOP \| DELETE);
2430	if (hService)
2431	{
2432	BOOL fRet;
2433	DWORD dwErr;
2434	RT_ZERO(uBuf.Status);
2435	SetLastError(ERROR_SERVICE_NOT_ACTIVE);
2436	fRet = ControlService(hService, SERVICE_CONTROL_STOP, &uBuf.Status);
2437	dwErr = GetLastError();
2438	if ( fRet
2439	\|\| dwErr == ERROR_SERVICE_NOT_ACTIVE
2440	\|\| ( dwErr == ERROR_SERVICE_CANNOT_ACCEPT_CTRL
2441	&& uBuf.Status.dwCurrentState == SERVICE_STOP_PENDING) )
2442	{
2443	if (DeleteService(hService))
2444	LogRel(("update service '%ls': deleted\n", pwszServiceName));
2445	else
2446	AssertLogRelMsgFailed(("Failed to not delete service %ls: %u\n", pwszServiceName, GetLastError()));
2447	}
2448	else
2449	AssertMsg(dwErr == ERROR_ACCESS_DENIED,
2450	("Failed to stop service %ls: %u (state=%u)\n", pwszServiceName, dwErr, uBuf.Status.dwCurrentState));
2451	CloseServiceHandle(hService);
2452	}
2453	else
2454	{
2455	pState->rc = GetLastError();
2456	LogRel(("Failed to not open service %ls for stop+delete: %u\n", pwszServiceName, pState->rc));
2457	hService = OpenServiceW(hSCM, pwszServiceName, SERVICE_CHANGE_CONFIG);
2458	}
2459	CloseServiceHandle(hService);
2460	}
2461
2462	CloseServiceHandle(hSCM);
2463
2464	/*
2465	* Step #3: Create the service (if requested).
2466	* Need to have the SC_MANAGER_CREATE_SERVICE access right for this.
2467	*/
2468	if (fCreateIt)
2469	{
2470	Assert(pState->fUpdate);
2471	hSCM = OpenSCManagerW(NULL, NULL, SC_MANAGER_CREATE_SERVICE);
2472	if (hSCM)
2473	{
2474	hService = CreateServiceW(hSCM,
2475	pwszServiceName,
2476	pwszDisplayName,
2477	SERVICE_CHANGE_CONFIG /* dwDesiredAccess */,
2478	uServiceType,
2479	uStartType,
2480	uErrorControl,
2481	wszFilePath,
2482	NULL /* pwszLoadOrderGroup */,
2483	NULL /* pdwTagId */,
2484	wszzDependencies,
2485	NULL /* pwszServiceStartName */,
2486	NULL /* pwszPassword */);
2487	if (hService != NULL)
2488	{
2489	uBuf.Desc.lpDescription = (WCHAR *)pwszDescription;
2490	if (ChangeServiceConfig2W(hService, SERVICE_CONFIG_DESCRIPTION, &uBuf.Desc))
2491	LogRel(("update service '%ls': created\n", pwszServiceName));
2492	else
2493	AssertMsgFailed(("Failed to set service description for %ls: %u\n", pwszServiceName, GetLastError()));
2494	CloseServiceHandle(hService);
2495	}
2496	else
2497	{
2498	pState->rc = GetLastError();
2499	AssertMsgFailed(("Failed to create service '%ls': %u\n", pwszServiceName, pState->rc));
2500	}
2501	CloseServiceHandle(hSCM);
2502	}
2503	else
2504	{
2505	pState->rc = GetLastError();
2506	LogRel(("Failed to open service manager with create service access: %u\n", pState->rc));
2507	}
2508	}
2509	}
2510	else
2511	AssertLogRelMsgFailed(("OpenSCManagerW failed: %u\n", GetLastError()));
2512	}
2513	#endif /* VBOX_WITH_SDS */
2514
2515
2516
2517	/**
2518	* Gently update the COM registrations for VirtualBox.
2519	*
2520	* API that com::Initialize (VBoxCOM/initterm.cpp) calls the first time COM is
2521	* initialized in a process. ASSUMES that the caller has initialized IPRT.
2522	*
2523	* @returns Windows error code.
2524	*/
2525	DECLEXPORT(uint32_t) VbpsUpdateRegistrations(void)
2526	{
2527	LSTATUS rc;
2528	VBPSREGSTATE State;
2529	#ifdef VBOX_IN_32_ON_64_MAIN_API
2530	bool const fIs32On64 = true;
2531	#else
2532	bool const fIs32On64 = false;
2533	#endif
2534
2535	/** @todo Should probably skip this when VBoxSVC is already running... Use
2536	* some mutex or something for checking. */
2537
2538	/*
2539	* Find the VirtualBox application directory first.
2540	*/
2541	WCHAR wszVBoxDir[MAX_PATH];
2542	DWORD cwcRet = GetModuleFileNameW(g_hDllSelf, wszVBoxDir, RT_ELEMENTS(wszVBoxDir));
2543	AssertReturn(cwcRet > 0 && cwcRet < RT_ELEMENTS(wszVBoxDir), ERROR_BUFFER_OVERFLOW);
2544	vbpsDllPathToVBoxDir(wszVBoxDir);
2545
2546	/*
2547	* Update registry entries for the current CPU bitness.
2548	*/
2549	rc = vbpsRegInit(&State, HKEY_CLASSES_ROOT, NULL, false /fDelete/, true /fUpdate/, 0);
2550	if (rc == ERROR_SUCCESS && !vbpsIsUpToDate(&State))
2551	{
2552
2553	#ifdef VBOX_WITH_SDS
2554	vbpsUpdateWindowsService(&State, wszVBoxDir, L"VBoxSDS.exe", L"VBoxSDS",
2555	L"VirtualBox system service", L"Used as a COM server for VirtualBox API.");
2556	#endif
2557	vbpsUpdateTypeLibRegistration(&State, wszVBoxDir, fIs32On64);
2558	vbpsUpdateProxyStubRegistration(&State, wszVBoxDir, fIs32On64);
2559	vbpsUpdateInterfaceRegistrations(&State);
2560	RegisterXidlModulesAndClassesGenerated(&State, wszVBoxDir, fIs32On64);
2561	vbpsMarkUpToDate(&State);
2562	rc = State.rc;
2563	}
2564	vbpsRegTerm(&State);
2565
2566
2567	#if (ARCH_BITS == 64 && defined(VBOX_WITH_32_ON_64_MAIN_API)) /\|\| defined(VBOX_IN_32_ON_64_MAIN_API) ??/
2568	/*
2569	* Update registry entries for the other CPU bitness.
2570	*/
2571	if (rc == ERROR_SUCCESS)
2572	{
2573	rc = vbpsRegInit(&State, HKEY_CLASSES_ROOT, NULL, false /fDelete/, true /fUpdate/,
2574	!fIs32On64 ? KEY_WOW64_32KEY : KEY_WOW64_64KEY);
2575	if (rc == ERROR_SUCCESS && !vbpsIsUpToDate(&State))
2576	{
2577	vbpsUpdateTypeLibRegistration(&State, wszVBoxDir, !fIs32On64);
2578	vbpsUpdateProxyStubRegistration(&State, wszVBoxDir, !fIs32On64);
2579	vbpsUpdateInterfaceRegistrations(&State);
2580	RegisterXidlModulesAndClassesGenerated(&State, wszVBoxDir, !fIs32On64);
2581	vbpsMarkUpToDate(&State);
2582	rc = State.rc;
2583	}
2584	vbpsRegTerm(&State);
2585	}
2586	#endif
2587
2588	return VINF_SUCCESS;
2589	}

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

source: vbox/trunk/src/VBox/Main/src-all/win/VBoxProxyStub.c@ 91406

Download in other formats: