VBoxServiceVMInfo-win.cpp@ 31955

Last change on this file since 31955 was 30225, checked in by vboxsync, 15 years ago
VBoxServiceVMInfo-win.cpp: bump _WIN32_WINNT to 0x0502 to get the CachedRemoteInteractive constant with newer SDKs.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 21.6 KB

Line
1	/* $Id: VBoxServiceVMInfo-win.cpp 30225 2010-06-16 01:56:56Z vboxsync $ */
2	/** @file
3	* VBoxService - Virtual Machine Information for the Host, Windows specifics.
4	*/
5
6	/*
7	* Copyright (C) 2009-2010 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0502
23	# undef _WIN32_WINNT
24	# define _WIN32_WINNT 0x0502 /* CachedRemoteInteractive in recent SDKs. */
25	#endif
26	#include <Windows.h>
27	#include <wtsapi32.h> /* For WTS* calls. */
28	#include <psapi.h> /* EnumProcesses. */
29	#include <Ntsecapi.h> /* Needed for process security information. */
30
31	#include <iprt/assert.h>
32	#include <iprt/mem.h>
33	#include <iprt/thread.h>
34	#include <iprt/string.h>
35	#include <iprt/semaphore.h>
36	#include <iprt/system.h>
37	#include <iprt/time.h>
38	#include <VBox/VBoxGuestLib.h>
39	#include "VBoxServiceInternal.h"
40	#include "VBoxServiceUtils.h"
41
42
43	/*******************************************************************************
44	* Structures and Typedefs *
45	*******************************************************************************/
46	/** Structure for storing the looked up user information. */
47	typedef struct
48	{
49	WCHAR wszUser[_MAX_PATH];
50	WCHAR wszAuthenticationPackage[_MAX_PATH];
51	WCHAR wszLogonDomain[_MAX_PATH];
52	} VBOXSERVICEVMINFOUSER, *PVBOXSERVICEVMINFOUSER;
53
54	/** Structure for the file information lookup. */
55	typedef struct
56	{
57	char *pszFilePath;
58	char *pszFileName;
59	} VBOXSERVICEVMINFOFILE, *PVBOXSERVICEVMINFOFILE;
60
61	/** Structure for process information lookup. */
62	typedef struct
63	{
64	DWORD id;
65	LUID luid;
66	} VBOXSERVICEVMINFOPROC, *PVBOXSERVICEVMINFOPROC;
67
68
69	/*******************************************************************************
70	* Prototypes
71	*******************************************************************************/
72	bool VBoxServiceVMInfoWinSessionHasProcesses(PLUID pSession, VBOXSERVICEVMINFOPROC const *paProcs, DWORD cProcs);
73	bool VBoxServiceVMInfoWinIsLoggedIn(PVBOXSERVICEVMINFOUSER a_pUserInfo, PLUID a_pSession);
74	int VBoxServiceVMInfoWinProcessesEnumerate(PVBOXSERVICEVMINFOPROC ppProc, DWORD pdwCount);
75	void VBoxServiceVMInfoWinProcessesFree(PVBOXSERVICEVMINFOPROC paProcs);
76
77
78
79	#ifndef TARGET_NT4
80
81	/**
82	* Fills in more data for a process.
83	*
84	* @returns VBox status code.
85	* @param pProc The process structure to fill data into.
86	* @param tkClass The kind of token information to get.
87	*/
88	static int VBoxServiceVMInfoWinProcessesGetTokenInfo(PVBOXSERVICEVMINFOPROC pProc,
89	TOKEN_INFORMATION_CLASS tkClass)
90	{
91	AssertPtr(pProc);
92	HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pProc->id);
93	if (h == NULL)
94	return RTErrConvertFromWin32(GetLastError());
95
96	int rc = VERR_NO_MEMORY;
97	HANDLE hToken;
98	if (OpenProcessToken(h, TOKEN_QUERY, &hToken))
99	{
100	void *pvTokenInfo = NULL;
101	DWORD dwTokenInfoSize;
102	switch (tkClass)
103	{
104	case TokenStatistics:
105	dwTokenInfoSize = sizeof(TOKEN_STATISTICS);
106	pvTokenInfo = RTMemAlloc(dwTokenInfoSize);
107	break;
108
109	/** @todo Implement more token classes here. */
110
111	default:
112	VBoxServiceError("Token class not implemented: %ld", tkClass);
113	rc = VERR_NOT_IMPLEMENTED;
114	break;
115	}
116
117	if (pvTokenInfo)
118	{
119	DWORD dwRetLength;
120	if (GetTokenInformation(hToken, tkClass, pvTokenInfo, dwTokenInfoSize, &dwRetLength))
121	{
122	switch (tkClass)
123	{
124	case TokenStatistics:
125	{
126	TOKEN_STATISTICS pStats = (TOKEN_STATISTICS)pvTokenInfo;
127	pProc->luid = pStats->AuthenticationId;
128	/** @todo Add more information of TOKEN_STATISTICS as needed. */
129	break;
130	}
131
132	default:
133	/* Should never get here! */
134	break;
135	}
136	rc = VINF_SUCCESS;
137	}
138	else
139	rc = RTErrConvertFromWin32(GetLastError());
140	RTMemFree(pvTokenInfo);
141	}
142	CloseHandle(hToken);
143	}
144	else
145	rc = RTErrConvertFromWin32(GetLastError());
146	CloseHandle(h);
147	return rc;
148	}
149
150
151	/**
152	* Enumerate all the processes in the system and get the logon user IDs for
153	* them.
154	*
155	* @returns VBox status code.
156	* @param ppaProcs Where to return the process snapshot. This must be
157	* freed by calling VBoxServiceVMInfoWinProcessesFree.
158	*
159	* @param pcProcs Where to store the returned process count.
160	*/
161	int VBoxServiceVMInfoWinProcessesEnumerate(PVBOXSERVICEVMINFOPROC *ppaProcs, PDWORD pcProcs)
162	{
163	AssertPtr(ppaProcs);
164	AssertPtr(pcProcs);
165
166	/*
167	* Call EnumProcesses with an increasingly larger buffer until it all fits
168	* or we think something is screwed up.
169	*/
170	DWORD cProcesses = 64;
171	PDWORD paPids = NULL;
172	int rc = VINF_SUCCESS;
173	do
174	{
175	/* Allocate / grow the buffer first. */
176	cProcesses *= 2;
177	void pvNew = RTMemRealloc(paPids, cProcesses sizeof(DWORD));
178	if (!pvNew)
179	{
180	rc = VERR_NO_MEMORY;
181	break;
182	}
183	paPids = (PDWORD)pvNew;
184
185	/* Query the processes. Not the cbRet == buffer size means there could be more work to be done. */
186	DWORD cbRet;
187	if (!EnumProcesses(paPids, cProcesses * sizeof(DWORD), &cbRet))
188	{
189	rc = RTErrConvertFromWin32(GetLastError());
190	break;
191	}
192	if (cbRet < cProcesses * sizeof(DWORD))
193	{
194	cProcesses = cbRet / sizeof(DWORD);
195	break;
196	}
197	} while (cProcesses <= 32768); /* Should be enough; see: http://blogs.technet.com/markrussinovich/archive/2009/07/08/3261309.aspx */
198	if (RT_SUCCESS(rc))
199	{
200	/*
201	* Allocate out process structures and fill data into them.
202	* We currently only try lookup their LUID's.
203	*/
204	PVBOXSERVICEVMINFOPROC paProcs;
205	paProcs = (PVBOXSERVICEVMINFOPROC)RTMemAllocZ(cProcesses * sizeof(VBOXSERVICEVMINFOPROC));
206	if (paProcs)
207	{
208	for (DWORD i = 0; i < cProcesses; i++)
209	{
210	paProcs[i].id = paPids[i];
211	rc = VBoxServiceVMInfoWinProcessesGetTokenInfo(&paProcs[i], TokenStatistics);
212	if (RT_FAILURE(rc))
213	{
214	/* Because some processes cannot be opened/parsed on
215	Windows, we should not consider to be this an error here. */
216	rc = VINF_SUCCESS;
217	}
218	}
219
220	/* Save number of processes */
221	if (RT_SUCCESS(rc))
222	{
223	*pcProcs = cProcesses;
224	*ppaProcs = paProcs;
225	}
226	else
227	RTMemFree(paProcs);
228	}
229	else
230	rc = VERR_NO_MEMORY;
231	}
232
233	RTMemFree(paPids);
234	return rc;
235	}
236
237	/**
238	* Frees the process structures returned by
239	* VBoxServiceVMInfoWinProcessesEnumerate() before.
240	*
241	* @param paProcs What
242	*/
243	void VBoxServiceVMInfoWinProcessesFree(PVBOXSERVICEVMINFOPROC paProcs)
244	{
245	RTMemFree(paProcs);
246	}
247
248	/**
249	* Determins whether the specified session has processes on the system.
250	*
251	* @returns true if it has, false if it doesn't.
252	* @param pSession The session.
253	* @param paProcs The process snapshot.
254	* @param cProcs The number of processes in the snaphot.
255	*/
256	bool VBoxServiceVMInfoWinSessionHasProcesses(PLUID pSession, VBOXSERVICEVMINFOPROC const *paProcs, DWORD cProcs)
257	{
258	AssertPtr(pSession);
259
260	if (!cProcs) /* To be on the safe side. */
261	return false;
262	AssertPtr(paProcs);
263
264	PSECURITY_LOGON_SESSION_DATA pSessionData = NULL;
265	NTSTATUS rcNt = LsaGetLogonSessionData(pSession, &pSessionData);
266	if (rcNt != STATUS_SUCCESS)
267	{
268	VBoxServiceError("Could not get logon session data! rcNt=%#x", rcNt);
269	return false;
270	}
271	AssertPtrReturn(pSessionData, false);
272
273	/*
274	* Even if a user seems to be logged in, it could be a stale/orphaned logon
275	* session. So check if we have some processes bound to it by comparing the
276	* session <-> process LUIDs.
277	*/
278	for (DWORD i = 0; i < cProcs; i++)
279	{
280	/*VBoxServiceVerbose(3, "%ld:%ld <-> %ld:%ld\n",
281	paProcs[i].luid.HighPart, paProcs[i].luid.LowPart,
282	pSessionData->LogonId.HighPart, pSessionData->LogonId.LowPart);*/
283	if ( paProcs[i].luid.HighPart == pSessionData->LogonId.HighPart
284	&& paProcs[i].luid.LowPart == pSessionData->LogonId.LowPart)
285	{
286	VBoxServiceVerbose(3, "Users: Session %ld:%ld has active processes\n",
287	pSessionData->LogonId.HighPart, pSessionData->LogonId.LowPart);
288	LsaFreeReturnBuffer(pSessionData);
289	return true;
290	}
291	}
292	LsaFreeReturnBuffer(pSessionData);
293	return false;
294	}
295
296
297	/**
298	* Save and noisy string copy.
299	*
300	* @param pwszDst Destination buffer.
301	* @param cbDst Size in bytes - not WCHAR count!
302	* @param pSrc Source string.
303	* @param pszWhat What this is. For the log.
304	*/
305	static void VBoxServiceVMInfoWinSafeCopy(PWCHAR pwszDst, size_t cbDst, LSA_UNICODE_STRING const pSrc, const char pszWhat)
306	{
307	Assert(RT_ALIGN(cbDst, sizeof(WCHAR)) == cbDst);
308
309	size_t cbCopy = pSrc->Length;
310	if (cbCopy + sizeof(WCHAR) > cbDst)
311	{
312	VBoxServiceVerbose(0, "%s is too long - %u bytes, buffer %u bytes! It will be truncated.\n",
313	pszWhat, cbCopy, cbDst);
314	cbCopy = cbDst - sizeof(WCHAR);
315	}
316	if (cbCopy)
317	memcpy(pwszDst, pSrc->Buffer, cbCopy);
318	pwszDst[cbCopy / sizeof(WCHAR)] = '\0';
319	}
320
321
322	/**
323	* Detects whether a user is logged on.
324	*
325	* @returns true if logged in, false if not (or error).
326	* @param a_pUserInfo Where to return the user information.
327	* @param a_pSession The session to check.
328	*/
329	bool VBoxServiceVMInfoWinIsLoggedIn(PVBOXSERVICEVMINFOUSER a_pUserInfo, PLUID a_pSession)
330	{
331	AssertPtr(a_pUserInfo);
332	if (!a_pSession)
333	return false;
334
335	PSECURITY_LOGON_SESSION_DATA pSessionData = NULL;
336	NTSTATUS rcNt = LsaGetLogonSessionData(a_pSession, &pSessionData);
337	if (rcNt != STATUS_SUCCESS)
338	{
339	VBoxServiceError("VMInfo/Users: LsaGetLogonSessionData failed, LSA error %#x\n", LsaNtStatusToWinError(rcNt));
340	if (pSessionData)
341	LsaFreeReturnBuffer(pSessionData);
342	return false;
343	}
344	if (!pSessionData)
345	{
346	VBoxServiceError("VMInfo/Users: Invalid logon session data!\n");
347	return false;
348	}
349
350	/*
351	* Only handle users which can login interactively or logged in
352	* remotely over native RDP.
353	*/
354	bool fFoundUser = false;
355	DWORD dwErr = NO_ERROR;
356	if ( IsValidSid(pSessionData->Sid)
357	&& ( (SECURITY_LOGON_TYPE)pSessionData->LogonType == Interactive
358	\|\| (SECURITY_LOGON_TYPE)pSessionData->LogonType == RemoteInteractive
359	\|\| (SECURITY_LOGON_TYPE)pSessionData->LogonType == CachedInteractive
360	\|\| (SECURITY_LOGON_TYPE)pSessionData->LogonType == CachedRemoteInteractive))
361	{
362	VBoxServiceVerbose(3, "VMInfo/Users: Session data: Name=%ls, Len=%d, SID=%s, LogonID=%ld,%ld\n",
363	pSessionData->UserName.Buffer,
364	pSessionData->UserName.Length,
365	pSessionData->Sid != NULL ? "1" : "0",
366	pSessionData->LogonId.HighPart, pSessionData->LogonId.LowPart);
367
368	/*
369	* Copy out relevant data.
370	*/
371	VBoxServiceVMInfoWinSafeCopy(a_pUserInfo->wszUser, sizeof(a_pUserInfo->wszUser),
372	&pSessionData->UserName, "User name");
373	VBoxServiceVMInfoWinSafeCopy(a_pUserInfo->wszAuthenticationPackage, sizeof(a_pUserInfo->wszAuthenticationPackage),
374	&pSessionData->AuthenticationPackage, "Authentication pkg name");
375	VBoxServiceVMInfoWinSafeCopy(a_pUserInfo->wszLogonDomain, sizeof(a_pUserInfo->wszLogonDomain),
376	&pSessionData->LogonDomain, "Logon domain name");
377
378	TCHAR szOwnerName[_MAX_PATH] = { 0 };
379	DWORD dwOwnerNameSize = sizeof(szOwnerName);
380	TCHAR szDomainName[_MAX_PATH] = { 0 };
381	DWORD dwDomainNameSize = sizeof(szDomainName);
382	SID_NAME_USE enmOwnerType = SidTypeInvalid;
383	if (!LookupAccountSid(NULL,
384	pSessionData->Sid,
385	szOwnerName,
386	&dwOwnerNameSize,
387	szDomainName,
388	&dwDomainNameSize,
389	&enmOwnerType))
390	{
391	VBoxServiceError("VMInfo/Users: Failed looking up account info for user '%ls': %ld!\n",
392	a_pUserInfo->wszUser, GetLastError());
393	}
394	else
395	{
396	if (enmOwnerType == SidTypeUser) /* Only recognize users; we don't care about the rest! */
397	{
398	VBoxServiceVerbose(3, "VMInfo/Users: Account User=%ls, Session=%ld, LUID=%ld,%ld, AuthPkg=%ls, Domain=%ls\n",
399	a_pUserInfo->wszUser, pSessionData->Session, pSessionData->LogonId.HighPart,
400	pSessionData->LogonId.LowPart, a_pUserInfo->wszAuthenticationPackage,
401	a_pUserInfo->wszLogonDomain);
402
403	/* Detect RDP sessions as well. */
404	LPTSTR pBuffer = NULL;
405	DWORD cbRet = 0;
406	int iState = 0;
407	if (WTSQuerySessionInformation(WTS_CURRENT_SERVER_HANDLE,
408	pSessionData->Session,
409	WTSConnectState,
410	&pBuffer,
411	&cbRet))
412	{
413	if (cbRet)
414	iState = *pBuffer;
415	VBoxServiceVerbose(3, "VMInfo/Users: Account User=%ls, WTSConnectState=%d\n",
416	a_pUserInfo->wszUser, iState);
417	if ( iState == WTSActive /* User logged on to WinStation. */
418	\|\| iState == WTSShadow /* Shadowing another WinStation. */
419	\|\| iState == WTSDisconnected) /* WinStation logged on without client. */
420	{
421	/** @todo On Vista and W2K, always "old" user name are still
422	* there. Filter out the old one! */
423	VBoxServiceVerbose(3, "VMInfo/Users: Account User=%ls is logged in via TCS/RDP. State=%d\n",
424	a_pUserInfo->wszUser, iState);
425	fFoundUser = true;
426	}
427	if (pBuffer)
428	WTSFreeMemory(pBuffer);
429	}
430	else
431	{
432	VBoxServiceVerbose(3, "VMInfo/Users: Account User=%ls, WTSConnectState returnd %ld\n",
433	a_pUserInfo->wszUser, GetLastError());
434
435	/*
436	* Terminal services don't run (for example in W2K,
437	* nothing to worry about ...). ... or is on the Vista
438	* fast user switching page!
439	*/
440	fFoundUser = true;
441	}
442	}
443	}
444	}
445
446	LsaFreeReturnBuffer(pSessionData);
447	return fFoundUser;
448	}
449
450
451	/**
452	* Retrieves the currently logged in users and stores their names along with the
453	* user count.
454	*
455	* @returns VBox status code.
456	* @param ppszUserList Where to store the user list (separated by commas).
457	* Must be freed with RTStrFree().
458	* @param pcUsersInList Where to store the number of users in the list.
459	*/
460	int VBoxServiceVMInfoWinWriteUsers(char *ppszUserList, uint32_t pcUsersInList)
461	{
462	PLUID paSessions = NULL;
463	ULONG cSession = 0;
464
465	/* This function can report stale or orphaned interactive logon sessions
466	of already logged off users (especially in Windows 2000). */
467	NTSTATUS rcNt = LsaEnumerateLogonSessions(&cSession, &paSessions);
468	VBoxServiceVerbose(3, "VMInfo/Users: Found %ld users\n", cSession);
469	if (rcNt != STATUS_SUCCESS)
470	{
471	VBoxServiceError("VMInfo/Users: LsaEnumerate failed with %lu\n", LsaNtStatusToWinError(rcNt));
472	return RTErrConvertFromWin32(LsaNtStatusToWinError(rcNt));
473	}
474
475	PVBOXSERVICEVMINFOPROC paProcs;
476	DWORD cProcs;
477	int rc = VBoxServiceVMInfoWinProcessesEnumerate(&paProcs, &cProcs);
478	if (RT_SUCCESS(rc))
479	{
480	*pcUsersInList = 0;
481	for (ULONG i = 0; i < cSession; i++)
482	{
483	VBOXSERVICEVMINFOUSER UserInfo;
484	if ( VBoxServiceVMInfoWinIsLoggedIn(&UserInfo, &paSessions[i])
485	&& VBoxServiceVMInfoWinSessionHasProcesses(&paSessions[i], paProcs, cProcs))
486	{
487	if (*pcUsersInList > 0)
488	{
489	rc = RTStrAAppend(ppszUserList, ",");
490	AssertRCBreakStmt(rc, RTStrFree(*ppszUserList));
491	}
492
493	*pcUsersInList += 1;
494
495	char *pszTemp;
496	int rc2 = RTUtf16ToUtf8(UserInfo.wszUser, &pszTemp);
497	if (RT_SUCCESS(rc2))
498	{
499	rc = RTStrAAppend(ppszUserList, pszTemp);
500	RTMemFree(pszTemp);
501	}
502	else
503	rc = RTStrAAppend(ppszUserList, "<string-convertion-error>");
504	AssertRCBreakStmt(rc, RTStrFree(*ppszUserList));
505	}
506	}
507	VBoxServiceVMInfoWinProcessesFree(paProcs);
508	}
509	LsaFreeReturnBuffer(paSessions);
510	return rc;
511	}
512
513	#endif /* TARGET_NT4 */
514
515	int VBoxServiceWinGetComponentVersions(uint32_t uClientID)
516	{
517	int rc;
518	char szSysDir[_MAX_PATH] = {0};
519	char szWinDir[_MAX_PATH] = {0};
520	char szDriversDir[_MAX_PATH + 32] = {0};
521
522	/* ASSUME: szSysDir and szWinDir and derivatives are always ASCII compatible. */
523	GetSystemDirectory(szSysDir, _MAX_PATH);
524	GetWindowsDirectory(szWinDir, _MAX_PATH);
525	RTStrPrintf(szDriversDir, sizeof(szDriversDir), "%s\\drivers", szSysDir);
526	#ifdef RT_ARCH_AMD64
527	char szSysWowDir[_MAX_PATH + 32] = {0};
528	RTStrPrintf(szSysWowDir, sizeof(szSysWowDir), "%s\\SysWow64", szWinDir);
529	#endif
530
531	/* The file information table. */
532	#ifndef TARGET_NT4
533	const VBOXSERVICEVMINFOFILE aVBoxFiles[] =
534	{
535	{ szSysDir, "VBoxControl.exe" },
536	{ szSysDir, "VBoxHook.dll" },
537	{ szSysDir, "VBoxDisp.dll" },
538	{ szSysDir, "VBoxMRXNP.dll" },
539	{ szSysDir, "VBoxService.exe" },
540	{ szSysDir, "VBoxTray.exe" },
541	{ szSysDir, "VBoxGINA.dll" },
542	{ szSysDir, "VBoxCredProv.dll" },
543
544	/* On 64-bit we don't yet have the OpenGL DLLs in native format.
545	So just enumerate the 32-bit files in the SYSWOW directory. */
546	# ifdef RT_ARCH_AMD64
547	{ szSysWowDir, "VBoxOGLarrayspu.dll" },
548	{ szSysWowDir, "VBoxOGLcrutil.dll" },
549	{ szSysWowDir, "VBoxOGLerrorspu.dll" },
550	{ szSysWowDir, "VBoxOGLpackspu.dll" },
551	{ szSysWowDir, "VBoxOGLpassthroughspu.dll" },
552	{ szSysWowDir, "VBoxOGLfeedbackspu.dll" },
553	{ szSysWowDir, "VBoxOGL.dll" },
554	# else /* !RT_ARCH_AMD64 */
555	{ szSysDir, "VBoxOGLarrayspu.dll" },
556	{ szSysDir, "VBoxOGLcrutil.dll" },
557	{ szSysDir, "VBoxOGLerrorspu.dll" },
558	{ szSysDir, "VBoxOGLpackspu.dll" },
559	{ szSysDir, "VBoxOGLpassthroughspu.dll" },
560	{ szSysDir, "VBoxOGLfeedbackspu.dll" },
561	{ szSysDir, "VBoxOGL.dll" },
562	# endif /* !RT_ARCH_AMD64 */
563
564	{ szDriversDir, "VBoxGuest.sys" },
565	{ szDriversDir, "VBoxMouse.sys" },
566	{ szDriversDir, "VBoxSF.sys" },
567	{ szDriversDir, "VBoxVideo.sys" },
568	};
569
570	#else /* TARGET_NT4 */
571	const VBOXSERVICEVMINFOFILE aVBoxFiles[] =
572	{
573	{ szSysDir, "VBoxControl.exe" },
574	{ szSysDir, "VBoxHook.dll" },
575	{ szSysDir, "VBoxDisp.dll" },
576	{ szSysDir, "VBoxServiceNT.exe" },
577	{ szSysDir, "VBoxTray.exe" },
578
579	{ szDriversDir, "VBoxGuestNT.sys" },
580	{ szDriversDir, "VBoxMouseNT.sys" },
581	{ szDriversDir, "VBoxVideo.sys" },
582	};
583	#endif /* TARGET_NT4 */
584
585	for (unsigned i = 0; i < RT_ELEMENTS(aVBoxFiles); i++)
586	{
587	char szVer[128];
588	VBoxServiceGetFileVersionString(aVBoxFiles[i].pszFilePath, aVBoxFiles[i].pszFileName, szVer, sizeof(szVer));
589	char szPropPath[256];
590	RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestAdd/Components/%s", aVBoxFiles[i].pszFileName);
591	rc = VBoxServiceWritePropF(uClientID, szPropPath, "%s", szVer);
592	}
593
594	return VINF_SUCCESS;
595	}
596

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

source: vbox/trunk/src/VBox/Additions/common/VBoxService/VBoxServiceVMInfo-win.cpp@ 31955

Download in other formats: