VirtualBox

source: vbox/trunk/src/VBox/Additions/common/VBoxService/VBoxServiceVMInfo.cpp@ 29021

Last change on this file since 29021 was 28978, checked in by vboxsync, 15 years ago

VBoxService/PropCache: Bugfixes.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 19.7 KB
Line 
1/* $Id: VBoxServiceVMInfo.cpp 28978 2010-05-03 14:22:54Z vboxsync $ */
2/** @file
3 * VBoxService - Virtual Machine Information for the Host.
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/*******************************************************************************
21* Header Files *
22*******************************************************************************/
23#ifdef RT_OS_WINDOWS
24#include <winsock2.h>
25#include <ws2tcpip.h>
26#include <windows.h>
27#include <Ntsecapi.h>
28#else
29# define __STDC_LIMIT_MACROS
30# include <arpa/inet.h>
31# include <errno.h>
32# include <netinet/in.h>
33# include <sys/ioctl.h>
34# include <sys/socket.h>
35# include <net/if.h>
36# include <unistd.h>
37# ifndef RT_OS_FREEBSD /* The header does not exist anymore since FreeBSD 9-current */
38# include <utmp.h>
39# endif
40# ifdef RT_OS_SOLARIS
41# include <sys/sockio.h>
42# endif
43#endif
44
45#include <iprt/mem.h>
46#include <iprt/thread.h>
47#include <iprt/string.h>
48#include <iprt/semaphore.h>
49#include <iprt/system.h>
50#include <iprt/time.h>
51#include <iprt/assert.h>
52#include <VBox/version.h>
53#include <VBox/VBoxGuestLib.h>
54#include "VBoxServiceInternal.h"
55#include "VBoxServiceUtils.h"
56#include "VBoxServicePropCache.h"
57
58
59/*******************************************************************************
60* Global Variables *
61*******************************************************************************/
62/** The vminfo interval (millseconds). */
63uint32_t g_VMInfoInterval = 0;
64/** The semaphore we're blocking on. */
65static RTSEMEVENTMULTI g_VMInfoEvent = NIL_RTSEMEVENTMULTI;
66/** The guest property service client ID. */
67static uint32_t g_VMInfoGuestPropSvcClientID = 0;
68/** Number of logged in users in OS. */
69static uint32_t g_cVMInfoLoggedInUsers = UINT32_MAX;
70/** The guest property cache. */
71static VBOXSERVICEVEPROPCACHE g_VMInfoPropCache;
72
73
74/** @copydoc VBOXSERVICE::pfnPreInit */
75static DECLCALLBACK(int) VBoxServiceVMInfoPreInit(void)
76{
77 return VINF_SUCCESS;
78}
79
80
81/** @copydoc VBOXSERVICE::pfnOption */
82static DECLCALLBACK(int) VBoxServiceVMInfoOption(const char **ppszShort, int argc, char **argv, int *pi)
83{
84 int rc = -1;
85 if (ppszShort)
86 /* no short options */;
87 else if (!strcmp(argv[*pi], "--vminfo-interval"))
88 rc = VBoxServiceArgUInt32(argc, argv, "", pi,
89 &g_VMInfoInterval, 1, UINT32_MAX - 1);
90 return rc;
91}
92
93
94/** @copydoc VBOXSERVICE::pfnInit */
95static DECLCALLBACK(int) VBoxServiceVMInfoInit(void)
96{
97 /*
98 * If not specified, find the right interval default.
99 * Then create the event sem to block on.
100 */
101 if (!g_VMInfoInterval)
102 g_VMInfoInterval = g_DefaultInterval * 1000;
103 if (!g_VMInfoInterval)
104 g_VMInfoInterval = 10 * 1000;
105
106 int rc = RTSemEventMultiCreate(&g_VMInfoEvent);
107 AssertRCReturn(rc, rc);
108
109#ifdef RT_OS_WINDOWS
110 /* Get function pointers. */
111 HMODULE hKernel32 = LoadLibrary("kernel32");
112 if (hKernel32 != NULL)
113 {
114 g_pfnWTSGetActiveConsoleSessionId = (PFNWTSGETACTIVECONSOLESESSIONID)GetProcAddress(hKernel32, "WTSGetActiveConsoleSessionId");
115 FreeLibrary(hKernel32);
116 }
117#endif
118
119 rc = VbglR3GuestPropConnect(&g_VMInfoGuestPropSvcClientID);
120 if (RT_SUCCESS(rc))
121 VBoxServiceVerbose(3, "Property Service Client ID: %#x\n", g_VMInfoGuestPropSvcClientID);
122 else
123 {
124 VBoxServiceError("Failed to connect to the guest property service! Error: %Rrc\n", rc);
125 RTSemEventMultiDestroy(g_VMInfoEvent);
126 g_VMInfoEvent = NIL_RTSEMEVENTMULTI;
127 }
128
129 if (RT_SUCCESS(rc))
130 {
131 VBoxServicePropCacheInit(&g_VMInfoPropCache, g_VMInfoGuestPropSvcClientID);
132
133 /*
134 * Set flags and reset values for some guest proerties that need to have that.
135 * Passing NULL as an actual value does not write the properties yet.
136 */
137 VBoxServicePropCacheUpdateEx(&g_VMInfoPropCache, "/VirtualBox/GuestInfo/OS/LoggedInUsersList",
138 VBOXSERVICEPROPCACHEFLAG_TEMPORARY, NULL /* Delete on exit */, NULL);
139 VBoxServicePropCacheUpdateEx(&g_VMInfoPropCache, "/VirtualBox/GuestInfo/OS/LoggedInUsers",
140 VBOXSERVICEPROPCACHEFLAG_TEMPORARY, "0", NULL);
141 VBoxServicePropCacheUpdateEx(&g_VMInfoPropCache, "/VirtualBox/GuestInfo/OS/NoLoggedInUsers",
142 VBOXSERVICEPROPCACHEFLAG_TEMPORARY, "true", NULL);
143 /*
144 * This property is a beacon which is _always_ written, even if the network configuration
145 * does not change. If this property is missing, the host assumes that all other GuestInfo
146 * properties are no longer valid.
147 */
148 VBoxServicePropCacheUpdateEx(&g_VMInfoPropCache, "/VirtualBox/GuestInfo/Net/Count",
149 VBOXSERVICEPROPCACHEFLAG_TEMPORARY | VBOXSERVICEPROPCACHEFLAG_ALWAYS_UPDATE, "0", NULL);
150 }
151 return rc;
152}
153
154
155/**
156 * Writes the properties that won't change while the service is running.
157 *
158 * Errors are ignored.
159 */
160static void VBoxServiceVMInfoWriteFixedProperties(void)
161{
162 /*
163 * First get OS information that won't change.
164 */
165 char szInfo[256];
166 int rc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szInfo, sizeof(szInfo));
167 VBoxServiceWritePropF(g_VMInfoGuestPropSvcClientID, "/VirtualBox/GuestInfo/OS/Product",
168 "%s", RT_FAILURE(rc) ? "" : szInfo);
169
170 rc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szInfo, sizeof(szInfo));
171 VBoxServiceWritePropF(g_VMInfoGuestPropSvcClientID, "/VirtualBox/GuestInfo/OS/Release",
172 "%s", RT_FAILURE(rc) ? "" : szInfo);
173
174 rc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szInfo, sizeof(szInfo));
175 VBoxServiceWritePropF(g_VMInfoGuestPropSvcClientID, "/VirtualBox/GuestInfo/OS/Version",
176 "%s", RT_FAILURE(rc) ? "" : szInfo);
177
178 rc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szInfo, sizeof(szInfo));
179 VBoxServiceWritePropF(g_VMInfoGuestPropSvcClientID, "/VirtualBox/GuestInfo/OS/ServicePack",
180 "%s", RT_FAILURE(rc) ? "" : szInfo);
181
182 /*
183 * Retrieve version information about Guest Additions and installed files (components).
184 */
185 char *pszAddVer;
186 char *pszAddRev;
187 rc = VbglR3GetAdditionsVersion(&pszAddVer, &pszAddRev);
188 VBoxServiceWritePropF(g_VMInfoGuestPropSvcClientID, "/VirtualBox/GuestAdd/Version",
189 "%s", RT_FAILURE(rc) ? "" : pszAddVer);
190 VBoxServiceWritePropF(g_VMInfoGuestPropSvcClientID, "/VirtualBox/GuestAdd/Revision",
191 "%s", RT_FAILURE(rc) ? "" : pszAddRev);
192 if (RT_SUCCESS(rc))
193 {
194 RTStrFree(pszAddVer);
195 RTStrFree(pszAddRev);
196 }
197
198#ifdef RT_OS_WINDOWS
199 /*
200 * Do windows specific properties.
201 */
202 char *pszInstDir;
203 rc = VbglR3GetAdditionsInstallationPath(&pszInstDir);
204 VBoxServiceWritePropF(g_VMInfoGuestPropSvcClientID, "/VirtualBox/GuestAdd/InstallDir",
205 "%s", RT_FAILURE(rc) ? "" : pszInstDir);
206 if (RT_SUCCESS(rc))
207 RTStrFree(pszInstDir);
208
209 VBoxServiceWinGetComponentVersions(g_VMInfoGuestPropSvcClientID);
210#endif
211}
212
213
214/** @copydoc VBOXSERVICE::pfnWorker */
215DECLCALLBACK(int) VBoxServiceVMInfoWorker(bool volatile *pfShutdown)
216{
217 int rc = VINF_SUCCESS;
218
219 /*
220 * Tell the control thread that it can continue
221 * spawning services.
222 */
223 RTThreadUserSignal(RTThreadSelf());
224
225#ifdef RT_OS_WINDOWS
226 /* Required for network information (must be called per thread). */
227 WSADATA wsaData;
228 if (WSAStartup(MAKEWORD(2, 2), &wsaData))
229 VBoxServiceError("WSAStartup failed! Error: %Rrc\n", RTErrConvertFromWin32(WSAGetLastError()));
230#endif /* RT_OS_WINDOWS */
231
232 /*
233 * Write the fixed properties first.
234 */
235 VBoxServiceVMInfoWriteFixedProperties();
236
237 /*
238 * Now enter the loop retrieving runtime data continuously.
239 */
240 unsigned cErrors = 0;
241 for (;;)
242 {
243/** @todo r=bird: split this code up into functions!! */
244 /* Enumerate logged in users. */
245 uint32_t cUsersInList = 0;
246 char szUserList[4096] = {0};
247
248#ifdef RT_OS_WINDOWS
249# ifndef TARGET_NT4
250 PLUID paSessions = NULL;
251 ULONG cSession = 0;
252 NTSTATUS r = 0;
253
254 /* This function can report stale or orphaned interactive logon sessions
255 of already logged off users (especially in Windows 2000). */
256 r = ::LsaEnumerateLogonSessions(&cSession, &paSessions);
257 VBoxServiceVerbose(3, "Users: Found %ld users.\n", cSession);
258 if (r != STATUS_SUCCESS)
259 {
260 VBoxServiceError("LsaEnumerate failed %lu\n", LsaNtStatusToWinError(r));
261 return 1;
262 }
263
264 PVBOXSERVICEVMINFOPROC paProcs;
265 DWORD cProcs;
266 rc = VBoxServiceVMInfoWinProcessesEnumerate(&paProcs, &cProcs);
267 if (RT_SUCCESS(rc))
268 {
269 for (ULONG i = 0; i < cSession; i++)
270 {
271 VBOXSERVICEVMINFOUSER UserInfo;
272 if ( VBoxServiceVMInfoWinIsLoggedIn(&UserInfo, &paSessions[i])
273 && VBoxServiceVMInfoWinSessionHasProcesses(&paSessions[i], paProcs, cProcs))
274 {
275 if (cUsersInList > 0)
276 strcat(szUserList, ",");
277
278 cUsersInList++;
279
280 char *pszTemp;
281 int rc2 = RTUtf16ToUtf8(UserInfo.wszUser, &pszTemp);
282 if (RT_SUCCESS(rc2))
283 {
284 strcat(szUserList, pszTemp);
285 RTMemFree(pszTemp);
286 }
287 else
288 strcat(szUserList, "<string-convertion-error>");
289 }
290 }
291 VBoxServiceVMInfoWinProcessesFree(paProcs);
292 }
293
294 ::LsaFreeReturnBuffer(paSessions);
295# endif /* TARGET_NT4 */
296#elif defined(RT_OS_FREEBSD)
297 /** @todo FreeBSD: Port logged on user info retrival. */
298#elif defined(RT_OS_OS2)
299 /** @todo OS/2: Port logged on (LAN/local/whatever) user info retrival. */
300#else
301 rc = utmpname(UTMP_FILE);
302# ifdef RT_OS_SOLARIS
303 if (rc != 1)
304# else
305 if (rc != 0)
306# endif
307 {
308 VBoxServiceError("Could not set UTMP file! Error: %ld\n", errno);
309 }
310 setutent();
311 utmp *ut_user;
312 while ((ut_user = getutent()))
313 {
314 /* Make sure we don't add user names which are not
315 * part of type USER_PROCESS and don't add same users twice. */
316 if ( ut_user->ut_type == USER_PROCESS
317 && strstr(szUserList, ut_user->ut_user) == NULL)
318 {
319 /** @todo Do we really want to filter out double user names? (Same user logged in twice)
320 * bird: If we do, then we must add checks for buffer overflows here! */
321 /** @todo r=bird: strstr will filtering out users with similar names. For
322 * example: smith, smithson, joesmith and bobsmith */
323 if (cUsersInList > 0)
324 strcat(szUserList, ",");
325 strcat(szUserList, ut_user->ut_user);
326 cUsersInList++;
327 }
328 }
329 endutent();
330#endif /* !RT_OS_WINDOWS */
331
332 if (cUsersInList > 0)
333 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, "/VirtualBox/GuestInfo/OS/LoggedInUsersList", "%s", szUserList);
334 else
335 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, "/VirtualBox/GuestInfo/OS/LoggedInUsersList", NULL);
336 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, "/VirtualBox/GuestInfo/OS/LoggedInUsers", "%u", cUsersInList);
337 if ( g_cVMInfoLoggedInUsers != cUsersInList
338 || g_cVMInfoLoggedInUsers == UINT32_MAX)
339 {
340 /*
341 * Update this property ONLY if there is a real change from no users to
342 * users or vice versa. The only exception is that the initialization
343 * forces an update, but only once. This ensures consistent property
344 * settings even if the VM aborted previously.
345 */
346 if (cUsersInList == 0)
347 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, "/VirtualBox/GuestInfo/OS/NoLoggedInUsers", "true");
348 else if (g_cVMInfoLoggedInUsers == 0)
349 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, "/VirtualBox/GuestInfo/OS/NoLoggedInUsers", "false");
350 }
351 g_cVMInfoLoggedInUsers = cUsersInList;
352
353 /*
354 * Get network configuration.
355 */
356 /** @todo Throw this code into a separate function/module? */
357 int nNumInterfaces = 0;
358#ifdef RT_OS_WINDOWS
359 SOCKET sd = WSASocket(AF_INET, SOCK_DGRAM, 0, 0, 0, 0);
360 if (sd == SOCKET_ERROR) /* Socket invalid. */
361 {
362 VBoxServiceError("Failed to get a socket: Error %d\n", WSAGetLastError());
363 return -1;
364 }
365
366 INTERFACE_INFO InterfaceList[20] = {0};
367 unsigned long nBytesReturned = 0;
368 if (WSAIoctl(sd,
369 SIO_GET_INTERFACE_LIST,
370 0,
371 0,
372 &InterfaceList,
373 sizeof(InterfaceList),
374 &nBytesReturned,
375 0,
376 0) == SOCKET_ERROR)
377 {
378 VBoxServiceError("Failed to WSAIoctl() on socket: Error: %d\n", WSAGetLastError());
379 return -1;
380 }
381 nNumInterfaces = nBytesReturned / sizeof(INTERFACE_INFO);
382#else
383 int sd = socket(AF_INET, SOCK_DGRAM, 0);
384 if (sd < 0) /* Socket invalid. */
385 {
386 VBoxServiceError("Failed to get a socket: Error %d\n", errno);
387 return -1;
388 }
389
390 ifconf ifcfg;
391 char buffer[1024] = {0};
392 ifcfg.ifc_len = sizeof(buffer);
393 ifcfg.ifc_buf = buffer;
394 if (ioctl(sd, SIOCGIFCONF, &ifcfg) < 0)
395 {
396 VBoxServiceError("Failed to ioctl(SIOCGIFCONF) on socket: Error %d\n", errno);
397 return -1;
398 }
399
400 ifreq* ifrequest = ifcfg.ifc_req;
401 ifreq *ifreqitem = NULL;
402 nNumInterfaces = ifcfg.ifc_len / sizeof(ifreq);
403#endif
404 char szPropPath [FILENAME_MAX];
405 int iCurIface = 0;
406
407 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, "/VirtualBox/GuestInfo/Net/Count", "%d",
408 nNumInterfaces > 1 ? nNumInterfaces-1 : 0);
409
410 /** @todo Use GetAdaptersInfo() and GetAdapterAddresses (IPv4 + IPv6) for more information. */
411 for (int i = 0; i < nNumInterfaces; ++i)
412 {
413 sockaddr_in *pAddress;
414 u_long nFlags = 0;
415#ifdef RT_OS_WINDOWS
416 if (InterfaceList[i].iiFlags & IFF_LOOPBACK) /* Skip loopback device. */
417 continue;
418 nFlags = InterfaceList[i].iiFlags;
419 pAddress = (sockaddr_in *)&(InterfaceList[i].iiAddress);
420#else
421 if (ioctl(sd, SIOCGIFFLAGS, &ifrequest[i]) < 0)
422 {
423 VBoxServiceError("Failed to ioctl(SIOCGIFFLAGS) on socket: Error %d\n", errno);
424 return -1;
425 }
426 if (ifrequest[i].ifr_flags & IFF_LOOPBACK) /* Skip loopback device. */
427 continue;
428 nFlags = ifrequest[i].ifr_flags;
429 pAddress = ((sockaddr_in *)&ifrequest[i].ifr_addr);
430#endif
431 Assert(pAddress);
432 RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestInfo/Net/%d/V4/IP", iCurIface);
433 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath, "%s", inet_ntoa(pAddress->sin_addr));
434
435#ifdef RT_OS_WINDOWS
436 pAddress = (sockaddr_in *) & (InterfaceList[i].iiBroadcastAddress);
437#else
438 if (ioctl(sd, SIOCGIFBRDADDR, &ifrequest[i]) < 0)
439 {
440 VBoxServiceError("Failed to ioctl(SIOCGIFBRDADDR) on socket: Error %d\n", errno);
441 return -1;
442 }
443 pAddress = (sockaddr_in *)&ifrequest[i].ifr_broadaddr;
444#endif
445 RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestInfo/Net/%d/V4/Broadcast", iCurIface);
446 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath, "%s", inet_ntoa(pAddress->sin_addr));
447
448#ifdef RT_OS_WINDOWS
449 pAddress = (sockaddr_in *)&(InterfaceList[i].iiNetmask);
450#else
451 if (ioctl(sd, SIOCGIFNETMASK, &ifrequest[i]) < 0)
452 {
453 VBoxServiceError("Failed to ioctl(SIOCGIFBRDADDR) on socket: Error %d\n", errno);
454 return -1;
455 }
456 #if defined(RT_OS_FREEBSD) || defined(RT_OS_OS2) || defined(RT_OS_SOLARIS)
457 pAddress = (sockaddr_in *)&ifrequest[i].ifr_addr;
458 #else
459 pAddress = (sockaddr_in *)&ifrequest[i].ifr_netmask;
460 #endif
461
462#endif
463 RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestInfo/Net/%d/V4/Netmask", iCurIface);
464 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath, "%s", inet_ntoa(pAddress->sin_addr));
465
466 RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestInfo/Net/%d/Status", iCurIface);
467 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath,
468 nFlags & IFF_UP ? "Up" : "Down");
469 iCurIface++;
470 }
471 if (sd >= 0)
472#ifdef RT_OS_WINDOWS
473 closesocket(sd);
474#else
475 close(sd);
476#endif
477
478 /*
479 * Block for a while.
480 *
481 * The event semaphore takes care of ignoring interruptions and it
482 * allows us to implement service wakeup later.
483 */
484 if (*pfShutdown)
485 break;
486 int rc2 = RTSemEventMultiWait(g_VMInfoEvent, g_VMInfoInterval);
487 if (*pfShutdown)
488 break;
489 if (rc2 != VERR_TIMEOUT && RT_FAILURE(rc2))
490 {
491 VBoxServiceError("RTSemEventMultiWait failed; rc2=%Rrc\n", rc2);
492 rc = rc2;
493 break;
494 }
495 }
496
497#ifdef RT_OS_WINDOWS
498 WSACleanup();
499#endif
500
501 return rc;
502}
503
504
505/** @copydoc VBOXSERVICE::pfnStop */
506static DECLCALLBACK(void) VBoxServiceVMInfoStop(void)
507{
508 RTSemEventMultiSignal(g_VMInfoEvent);
509}
510
511
512/** @copydoc VBOXSERVICE::pfnTerm */
513static DECLCALLBACK(void) VBoxServiceVMInfoTerm(void)
514{
515 int rc;
516
517 if (g_VMInfoEvent != NIL_RTSEMEVENTMULTI)
518 {
519 /* Delete the "../Net" branch. */
520 const char *apszPat[1] = { "/VirtualBox/GuestInfo/Net/*" };
521 rc = VbglR3GuestPropDelSet(g_VMInfoGuestPropSvcClientID, &apszPat[0], RT_ELEMENTS(apszPat));
522
523 /* Destroy property cache. */
524 VBoxServicePropCacheDestroy(&g_VMInfoPropCache);
525
526 /* Disconnect from guest properties service. */
527 rc = VbglR3GuestPropDisconnect(g_VMInfoGuestPropSvcClientID);
528 if (RT_FAILURE(rc))
529 VBoxServiceError("Failed to disconnect from guest property service! Error: %Rrc\n", rc);
530 g_VMInfoGuestPropSvcClientID = 0;
531
532 RTSemEventMultiDestroy(g_VMInfoEvent);
533 g_VMInfoEvent = NIL_RTSEMEVENTMULTI;
534 }
535}
536
537
538/**
539 * The 'vminfo' service description.
540 */
541VBOXSERVICE g_VMInfo =
542{
543 /* pszName. */
544 "vminfo",
545 /* pszDescription. */
546 "Virtual Machine Information",
547 /* pszUsage. */
548 "[--vminfo-interval <ms>]"
549 ,
550 /* pszOptions. */
551 " --vminfo-interval Specifies the interval at which to retrieve the\n"
552 " VM information. The default is 10000 ms.\n"
553 ,
554 /* methods */
555 VBoxServiceVMInfoPreInit,
556 VBoxServiceVMInfoOption,
557 VBoxServiceVMInfoInit,
558 VBoxServiceVMInfoWorker,
559 VBoxServiceVMInfoStop,
560 VBoxServiceVMInfoTerm
561};
562
Note: See TracBrowser for help on using the repository browser.

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