VirtualBox

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

Last change on this file since 50554 was 50554, checked in by vboxsync, 11 years ago

VBoxServiceVMInfo.cpp: Fixed interface IP address on OS/2 (probably applicable everywhere) and implemented getting the MAC address on OS/2.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 60.7 KB
Line 
1/* $Id: VBoxServiceVMInfo.cpp 50554 2014-02-24 11:38:25Z vboxsync $ */
2/** @file
3 * VBoxService - Virtual Machine Information for the Host.
4 */
5
6/*
7 * Copyright (C) 2009-2013 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# ifdef TARGET_NT4 /* HACK ALERT! PMIB_IPSTATS undefined if 0x0400 with newer SDKs. */
25# undef _WIN32_WINNT
26# define _WIN32_WINNT 0x0500
27# endif
28# include <winsock2.h>
29# include <iphlpapi.h>
30# include <ws2tcpip.h>
31# include <windows.h>
32# include <Ntsecapi.h>
33#else
34# define __STDC_LIMIT_MACROS
35# include <arpa/inet.h>
36# include <errno.h>
37# include <netinet/in.h>
38# include <sys/ioctl.h>
39# include <sys/socket.h>
40# include <net/if.h>
41# include <pwd.h> /* getpwuid */
42# include <unistd.h>
43# if !defined(RT_OS_OS2) && !defined(RT_OS_FREEBSD) && !defined(RT_OS_HAIKU)
44# include <utmpx.h> /* @todo FreeBSD 9 should have this. */
45# endif
46# ifdef RT_OS_SOLARIS
47# include <sys/sockio.h>
48# include <net/if_arp.h>
49# endif
50# if defined(RT_OS_DARWIN) || defined(RT_OS_FREEBSD)
51# include <ifaddrs.h> /* getifaddrs, freeifaddrs */
52# include <net/if_dl.h> /* LLADDR */
53# include <netdb.h> /* getnameinfo */
54# endif
55# ifdef VBOX_WITH_DBUS
56# include <VBox/dbus.h>
57# endif
58#endif
59
60#include <iprt/mem.h>
61#include <iprt/thread.h>
62#include <iprt/string.h>
63#include <iprt/semaphore.h>
64#include <iprt/system.h>
65#include <iprt/time.h>
66#include <iprt/assert.h>
67#include <VBox/version.h>
68#include <VBox/VBoxGuestLib.h>
69#include "VBoxServiceInternal.h"
70#include "VBoxServiceUtils.h"
71#include "VBoxServicePropCache.h"
72
73
74/** Structure containing information about a location awarness
75 * client provided by the host. */
76/** @todo Move this (and functions) into VbglR3. */
77typedef struct VBOXSERVICELACLIENTINFO
78{
79 uint32_t uID;
80 char *pszName;
81 char *pszLocation;
82 char *pszDomain;
83 bool fAttached;
84 uint64_t uAttachedTS;
85} VBOXSERVICELACLIENTINFO, *PVBOXSERVICELACLIENTINFO;
86
87
88/*******************************************************************************
89* Global Variables *
90*******************************************************************************/
91/** The vminfo interval (milliseconds). */
92static uint32_t g_cMsVMInfoInterval = 0;
93/** The semaphore we're blocking on. */
94static RTSEMEVENTMULTI g_hVMInfoEvent = NIL_RTSEMEVENTMULTI;
95/** The guest property service client ID. */
96static uint32_t g_uVMInfoGuestPropSvcClientID = 0;
97/** Number of currently logged in users in OS. */
98static uint32_t g_cVMInfoLoggedInUsers = 0;
99/** The guest property cache. */
100static VBOXSERVICEVEPROPCACHE g_VMInfoPropCache;
101static const char *g_pszPropCacheValLoggedInUsersList = "/VirtualBox/GuestInfo/OS/LoggedInUsersList";
102static const char *g_pszPropCacheValLoggedInUsers = "/VirtualBox/GuestInfo/OS/LoggedInUsers";
103static const char *g_pszPropCacheValNoLoggedInUsers = "/VirtualBox/GuestInfo/OS/NoLoggedInUsers";
104static const char *g_pszPropCacheValNetCount = "/VirtualBox/GuestInfo/Net/Count";
105/** A guest user's guest property root key. */
106static const char *g_pszPropCacheValUser = "/VirtualBox/GuestInfo/User/";
107/** The VM session ID. Changes whenever the VM is restored or reset. */
108static uint64_t g_idVMInfoSession;
109/** The last attached locartion awareness (LA) client timestamp. */
110static uint64_t g_LAClientAttachedTS = 0;
111/** The current LA client info. */
112static VBOXSERVICELACLIENTINFO g_LAClientInfo;
113/** User idle threshold (in ms). This specifies the minimum time a user is considered
114 * as being idle and then will be reported to the host. Default is 5s. */
115uint32_t g_uVMInfoUserIdleThresholdMS = 5 * 1000;
116
117
118/*******************************************************************************
119* Defines *
120*******************************************************************************/
121static const char *g_pszLAActiveClient = "/VirtualBox/HostInfo/VRDP/ActiveClient";
122
123#ifdef VBOX_WITH_DBUS
124/** ConsoleKit defines (taken from 0.4.5). */
125#define CK_NAME "org.freedesktop.ConsoleKit"
126#define CK_PATH "/org/freedesktop/ConsoleKit"
127#define CK_INTERFACE "org.freedesktop.ConsoleKit"
128
129#define CK_MANAGER_PATH "/org/freedesktop/ConsoleKit/Manager"
130#define CK_MANAGER_INTERFACE "org.freedesktop.ConsoleKit.Manager"
131#define CK_SEAT_INTERFACE "org.freedesktop.ConsoleKit.Seat"
132#define CK_SESSION_INTERFACE "org.freedesktop.ConsoleKit.Session"
133#endif
134
135
136
137/**
138 * Signals the event so that a re-enumeration of VM-specific
139 * information (like logged in users) can happen.
140 *
141 * @return IPRT status code.
142 */
143int VBoxServiceVMInfoSignal(void)
144{
145 /* Trigger a re-enumeration of all logged-in users by unblocking
146 * the multi event semaphore of the VMInfo thread. */
147 if (g_hVMInfoEvent)
148 return RTSemEventMultiSignal(g_hVMInfoEvent);
149
150 return VINF_SUCCESS;
151}
152
153
154/** @copydoc VBOXSERVICE::pfnPreInit */
155static DECLCALLBACK(int) VBoxServiceVMInfoPreInit(void)
156{
157 return VINF_SUCCESS;
158}
159
160
161/** @copydoc VBOXSERVICE::pfnOption */
162static DECLCALLBACK(int) VBoxServiceVMInfoOption(const char **ppszShort, int argc, char **argv, int *pi)
163{
164 /** @todo Use RTGetOpt here. */
165
166 int rc = -1;
167 if (ppszShort)
168 /* no short options */;
169 else if (!strcmp(argv[*pi], "--vminfo-interval"))
170 rc = VBoxServiceArgUInt32(argc, argv, "", pi,
171 &g_cMsVMInfoInterval, 1, UINT32_MAX - 1);
172 else if (!strcmp(argv[*pi], "--vminfo-user-idle-threshold"))
173 rc = VBoxServiceArgUInt32(argc, argv, "", pi,
174 &g_uVMInfoUserIdleThresholdMS, 1, UINT32_MAX - 1);
175 return rc;
176}
177
178
179/** @copydoc VBOXSERVICE::pfnInit */
180static DECLCALLBACK(int) VBoxServiceVMInfoInit(void)
181{
182 /*
183 * If not specified, find the right interval default.
184 * Then create the event sem to block on.
185 */
186 if (!g_cMsVMInfoInterval)
187 g_cMsVMInfoInterval = g_DefaultInterval * 1000;
188 if (!g_cMsVMInfoInterval)
189 {
190 /* Set it to 5s by default for location awareness checks. */
191 g_cMsVMInfoInterval = 5 * 1000;
192 }
193
194 int rc = RTSemEventMultiCreate(&g_hVMInfoEvent);
195 AssertRCReturn(rc, rc);
196
197 VbglR3GetSessionId(&g_idVMInfoSession);
198 /* The status code is ignored as this information is not available with VBox < 3.2.10. */
199
200 /* Initialize the LA client object. */
201 RT_ZERO(g_LAClientInfo);
202
203 rc = VbglR3GuestPropConnect(&g_uVMInfoGuestPropSvcClientID);
204 if (RT_SUCCESS(rc))
205 VBoxServiceVerbose(3, "Property Service Client ID: %#x\n", g_uVMInfoGuestPropSvcClientID);
206 else
207 {
208 /* If the service was not found, we disable this service without
209 causing VBoxService to fail. */
210 if (rc == VERR_HGCM_SERVICE_NOT_FOUND) /* Host service is not available. */
211 {
212 VBoxServiceVerbose(0, "Guest property service is not available, disabling the service\n");
213 rc = VERR_SERVICE_DISABLED;
214 }
215 else
216 VBoxServiceError("Failed to connect to the guest property service! Error: %Rrc\n", rc);
217 RTSemEventMultiDestroy(g_hVMInfoEvent);
218 g_hVMInfoEvent = NIL_RTSEMEVENTMULTI;
219 }
220
221 if (RT_SUCCESS(rc))
222 {
223 VBoxServicePropCacheCreate(&g_VMInfoPropCache, g_uVMInfoGuestPropSvcClientID);
224
225 /*
226 * Declare some guest properties with flags and reset values.
227 */
228 int rc2 = VBoxServicePropCacheUpdateEntry(&g_VMInfoPropCache, g_pszPropCacheValLoggedInUsersList,
229 VBOXSERVICEPROPCACHEFLAG_TEMPORARY | VBOXSERVICEPROPCACHEFLAG_TRANSIENT, NULL /* Delete on exit */);
230 if (RT_FAILURE(rc2))
231 VBoxServiceError("Failed to init property cache value \"%s\", rc=%Rrc\n", g_pszPropCacheValLoggedInUsersList, rc2);
232
233 rc2 = VBoxServicePropCacheUpdateEntry(&g_VMInfoPropCache, g_pszPropCacheValLoggedInUsers,
234 VBOXSERVICEPROPCACHEFLAG_TEMPORARY | VBOXSERVICEPROPCACHEFLAG_TRANSIENT, "0");
235 if (RT_FAILURE(rc2))
236 VBoxServiceError("Failed to init property cache value \"%s\", rc=%Rrc\n", g_pszPropCacheValLoggedInUsers, rc2);
237
238 rc2 = VBoxServicePropCacheUpdateEntry(&g_VMInfoPropCache, g_pszPropCacheValNoLoggedInUsers,
239 VBOXSERVICEPROPCACHEFLAG_TEMPORARY | VBOXSERVICEPROPCACHEFLAG_TRANSIENT, "true");
240 if (RT_FAILURE(rc2))
241 VBoxServiceError("Failed to init property cache value \"%s\", rc=%Rrc\n", g_pszPropCacheValNoLoggedInUsers, rc2);
242
243 rc2 = VBoxServicePropCacheUpdateEntry(&g_VMInfoPropCache, g_pszPropCacheValNetCount,
244 VBOXSERVICEPROPCACHEFLAG_TEMPORARY | VBOXSERVICEPROPCACHEFLAG_ALWAYS_UPDATE, NULL /* Delete on exit */);
245 if (RT_FAILURE(rc2))
246 VBoxServiceError("Failed to init property cache value \"%s\", rc=%Rrc\n", g_pszPropCacheValNetCount, rc2);
247
248 /*
249 * Get configuration guest properties from the host.
250 * Note: All properties should have sensible defaults in case the lookup here fails.
251 */
252 char *pszValue;
253 rc2 = VBoxServiceReadHostProp(g_uVMInfoGuestPropSvcClientID, "/VirtualBox/GuestAdd/VBoxService/--vminfo-user-idle-threshold", true /* Read only */,
254 &pszValue, NULL /* Flags */, NULL /* Timestamp */);
255 if (RT_SUCCESS(rc2))
256 {
257 AssertPtr(pszValue);
258 g_uVMInfoUserIdleThresholdMS = RT_CLAMP(RTStrToUInt32(pszValue), 1000, UINT32_MAX - 1);
259 RTStrFree(pszValue);
260 }
261 }
262 return rc;
263}
264
265
266/**
267 * Retrieves a specifiy client LA property.
268 *
269 * @return IPRT status code.
270 * @param uClientID LA client ID to retrieve property for.
271 * @param pszProperty Property (without path) to retrieve.
272 * @param ppszValue Where to store value of property.
273 * @param puTimestamp Timestamp of property to retrieve. Optional.
274 */
275static int vboxServiceGetLAClientValue(uint32_t uClientID, const char *pszProperty,
276 char **ppszValue, uint64_t *puTimestamp)
277{
278 AssertReturn(uClientID, VERR_INVALID_PARAMETER);
279 AssertPtrReturn(pszProperty, VERR_INVALID_POINTER);
280
281 int rc;
282
283 char pszClientPath[255];
284 if (RTStrPrintf(pszClientPath, sizeof(pszClientPath),
285 "/VirtualBox/HostInfo/VRDP/Client/%RU32/%s", uClientID, pszProperty))
286 {
287 rc = VBoxServiceReadHostProp(g_uVMInfoGuestPropSvcClientID, pszClientPath, true /* Read only */,
288 ppszValue, NULL /* Flags */, puTimestamp);
289 }
290 else
291 rc = VERR_NO_MEMORY;
292
293 return rc;
294}
295
296
297/**
298 * Retrieves LA client information. On success the returned structure will have allocated
299 * objects which need to be free'd with vboxServiceFreeLAClientInfo.
300 *
301 * @return IPRT status code.
302 * @param uClientID Client ID to retrieve information for.
303 * @param pClient Pointer where to store the client information.
304 */
305static int vboxServiceGetLAClientInfo(uint32_t uClientID, PVBOXSERVICELACLIENTINFO pClient)
306{
307 AssertReturn(uClientID, VERR_INVALID_PARAMETER);
308 AssertPtrReturn(pClient, VERR_INVALID_POINTER);
309
310 int rc = vboxServiceGetLAClientValue(uClientID, "Name", &pClient->pszName,
311 NULL /* Timestamp */);
312 if (RT_SUCCESS(rc))
313 {
314 char *pszAttach;
315 rc = vboxServiceGetLAClientValue(uClientID, "Attach", &pszAttach,
316 &pClient->uAttachedTS);
317 if (RT_SUCCESS(rc))
318 {
319 AssertPtr(pszAttach);
320 pClient->fAttached = !RTStrICmp(pszAttach, "1") ? true : false;
321
322 RTStrFree(pszAttach);
323 }
324 }
325 if (RT_SUCCESS(rc))
326 rc = vboxServiceGetLAClientValue(uClientID, "Location", &pClient->pszLocation,
327 NULL /* Timestamp */);
328 if (RT_SUCCESS(rc))
329 rc = vboxServiceGetLAClientValue(uClientID, "Domain", &pClient->pszDomain,
330 NULL /* Timestamp */);
331 if (RT_SUCCESS(rc))
332 pClient->uID = uClientID;
333
334 return rc;
335}
336
337
338/**
339 * Frees all allocated LA client information of a structure.
340 *
341 * @param pClient Pointer to client information structure to free.
342 */
343static void vboxServiceFreeLAClientInfo(PVBOXSERVICELACLIENTINFO pClient)
344{
345 if (pClient)
346 {
347 if (pClient->pszName)
348 {
349 RTStrFree(pClient->pszName);
350 pClient->pszName = NULL;
351 }
352 if (pClient->pszLocation)
353 {
354 RTStrFree(pClient->pszLocation);
355 pClient->pszLocation = NULL;
356 }
357 if (pClient->pszDomain)
358 {
359 RTStrFree(pClient->pszDomain);
360 pClient->pszDomain = NULL;
361 }
362 }
363}
364
365
366/**
367 * Updates a per-guest user guest property inside the given property cache.
368 *
369 * @return IPRT status code.
370 * @param pCache Pointer to guest property cache to update user in.
371 * @param pszUser Name of guest user to update.
372 * @param pszDomain Domain of guest user to update. Optional.
373 * @param pszKey Key name of guest property to update.
374 * @param pszValueFormat Guest property value to set. Pass NULL for deleting
375 * the property.
376 */
377int vboxServiceUserUpdateF(PVBOXSERVICEVEPROPCACHE pCache, const char *pszUser, const char *pszDomain,
378 const char *pszKey, const char *pszValueFormat, ...)
379{
380 AssertPtrReturn(pCache, VERR_INVALID_POINTER);
381 AssertPtrReturn(pszUser, VERR_INVALID_POINTER);
382 /* pszDomain is optional. */
383 AssertPtrReturn(pszKey, VERR_INVALID_POINTER);
384 /* pszValueFormat is optional. */
385
386 int rc = VINF_SUCCESS;
387
388 char *pszName;
389 if (pszDomain)
390 {
391 if (!RTStrAPrintf(&pszName, "%s%s@%s/%s", g_pszPropCacheValUser, pszUser, pszDomain, pszKey))
392 rc = VERR_NO_MEMORY;
393 }
394 else
395 {
396 if (!RTStrAPrintf(&pszName, "%s%s/%s", g_pszPropCacheValUser, pszUser, pszKey))
397 rc = VERR_NO_MEMORY;
398 }
399
400 char *pszValue = NULL;
401 if ( RT_SUCCESS(rc)
402 && pszValueFormat)
403 {
404 va_list va;
405 va_start(va, pszValueFormat);
406 if (RTStrAPrintfV(&pszValue, pszValueFormat, va) < 0)
407 rc = VERR_NO_MEMORY;
408 va_end(va);
409 if ( RT_SUCCESS(rc)
410 && !pszValue)
411 rc = VERR_NO_STR_MEMORY;
412 }
413
414 if (RT_SUCCESS(rc))
415 rc = VBoxServicePropCacheUpdate(pCache, pszName, pszValue);
416 if (rc == VINF_SUCCESS) /* VBoxServicePropCacheUpdate will also return VINF_NO_CHANGE. */
417 {
418 /** @todo Combine updating flags w/ updating the actual value. */
419 rc = VBoxServicePropCacheUpdateEntry(pCache, pszName,
420 VBOXSERVICEPROPCACHEFLAG_TEMPORARY | VBOXSERVICEPROPCACHEFLAG_TRANSIENT,
421 NULL /* Delete on exit */);
422 }
423
424 RTStrFree(pszValue);
425 RTStrFree(pszName);
426 return rc;
427}
428
429
430/**
431 * Writes the properties that won't change while the service is running.
432 *
433 * Errors are ignored.
434 */
435static void vboxserviceVMInfoWriteFixedProperties(void)
436{
437 /*
438 * First get OS information that won't change.
439 */
440 char szInfo[256];
441 int rc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szInfo, sizeof(szInfo));
442 VBoxServiceWritePropF(g_uVMInfoGuestPropSvcClientID, "/VirtualBox/GuestInfo/OS/Product",
443 "%s", RT_FAILURE(rc) ? "" : szInfo);
444
445 rc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szInfo, sizeof(szInfo));
446 VBoxServiceWritePropF(g_uVMInfoGuestPropSvcClientID, "/VirtualBox/GuestInfo/OS/Release",
447 "%s", RT_FAILURE(rc) ? "" : szInfo);
448
449 rc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szInfo, sizeof(szInfo));
450 VBoxServiceWritePropF(g_uVMInfoGuestPropSvcClientID, "/VirtualBox/GuestInfo/OS/Version",
451 "%s", RT_FAILURE(rc) ? "" : szInfo);
452
453 rc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szInfo, sizeof(szInfo));
454 VBoxServiceWritePropF(g_uVMInfoGuestPropSvcClientID, "/VirtualBox/GuestInfo/OS/ServicePack",
455 "%s", RT_FAILURE(rc) ? "" : szInfo);
456
457 /*
458 * Retrieve version information about Guest Additions and installed files (components).
459 */
460 char *pszAddVer;
461 char *pszAddVerExt;
462 char *pszAddRev;
463 rc = VbglR3GetAdditionsVersion(&pszAddVer, &pszAddVerExt, &pszAddRev);
464 VBoxServiceWritePropF(g_uVMInfoGuestPropSvcClientID, "/VirtualBox/GuestAdd/Version",
465 "%s", RT_FAILURE(rc) ? "" : pszAddVer);
466 VBoxServiceWritePropF(g_uVMInfoGuestPropSvcClientID, "/VirtualBox/GuestAdd/VersionExt",
467 "%s", RT_FAILURE(rc) ? "" : pszAddVerExt);
468 VBoxServiceWritePropF(g_uVMInfoGuestPropSvcClientID, "/VirtualBox/GuestAdd/Revision",
469 "%s", RT_FAILURE(rc) ? "" : pszAddRev);
470 if (RT_SUCCESS(rc))
471 {
472 RTStrFree(pszAddVer);
473 RTStrFree(pszAddVerExt);
474 RTStrFree(pszAddRev);
475 }
476
477#ifdef RT_OS_WINDOWS
478 /*
479 * Do windows specific properties.
480 */
481 char *pszInstDir;
482 rc = VbglR3GetAdditionsInstallationPath(&pszInstDir);
483 VBoxServiceWritePropF(g_uVMInfoGuestPropSvcClientID, "/VirtualBox/GuestAdd/InstallDir",
484 "%s", RT_FAILURE(rc) ? "" : pszInstDir);
485 if (RT_SUCCESS(rc))
486 RTStrFree(pszInstDir);
487
488 VBoxServiceWinGetComponentVersions(g_uVMInfoGuestPropSvcClientID);
489#endif
490}
491
492#if defined(VBOX_WITH_DBUS) && defined(RT_OS_LINUX) /* Not yet for Solaris/FreeBSB. */
493/*
494 * Simple wrapper to work around compiler-specific va_list madness.
495 */
496static dbus_bool_t vboxService_dbus_message_get_args(DBusMessage *message,
497 DBusError *error,
498 int first_arg_type,
499 ...)
500{
501 va_list va;
502 va_start(va, first_arg_type);
503 dbus_bool_t ret = dbus_message_get_args_valist(message, error,
504 first_arg_type, va);
505 va_end(va);
506 return ret;
507}
508#endif
509
510/**
511 * Provide information about active users.
512 */
513static int vboxserviceVMInfoWriteUsers(void)
514{
515 int rc = VINF_SUCCESS;
516 char *pszUserList = NULL;
517 uint32_t cUsersInList = 0;
518
519#ifdef RT_OS_WINDOWS
520# ifndef TARGET_NT4
521 rc = VBoxServiceVMInfoWinWriteUsers(&g_VMInfoPropCache,
522 &pszUserList, &cUsersInList);
523# else
524 rc = VERR_NOT_IMPLEMENTED;
525# endif
526
527#elif defined(RT_OS_FREEBSD)
528 /** @todo FreeBSD: Port logged on user info retrieval.
529 * However, FreeBSD 9 supports utmpx, so we could use the code
530 * block below (?). */
531 rc = VERR_NOT_IMPLEMENTED;
532
533#elif defined(RT_OS_HAIKU)
534 /** @todo Haiku: Port logged on user info retrieval. */
535 rc = VERR_NOT_IMPLEMENTED;
536
537#elif defined(RT_OS_OS2)
538 /** @todo OS/2: Port logged on (LAN/local/whatever) user info retrieval. */
539 rc = VERR_NOT_IMPLEMENTED;
540
541#else
542 setutxent();
543 utmpx *ut_user;
544 uint32_t cListSize = 32;
545
546 /* Allocate a first array to hold 32 users max. */
547 char **papszUsers = (char **)RTMemAllocZ(cListSize * sizeof(char *));
548 if (papszUsers == NULL)
549 rc = VERR_NO_MEMORY;
550
551 /* Process all entries in the utmp file.
552 * Note: This only handles */
553 while ( (ut_user = getutxent())
554 && RT_SUCCESS(rc))
555 {
556# ifdef RT_OS_DARWIN /* No ut_user->ut_session on Darwin */
557 VBoxServiceVerbose(4, "Found entry \"%s\" (type: %d, PID: %RU32)\n",
558 ut_user->ut_user, ut_user->ut_type, ut_user->ut_pid);
559# else
560 VBoxServiceVerbose(4, "Found entry \"%s\" (type: %d, PID: %RU32, session: %RU32)\n",
561 ut_user->ut_user, ut_user->ut_type, ut_user->ut_pid, ut_user->ut_session);
562# endif
563 if (cUsersInList > cListSize)
564 {
565 cListSize += 32;
566 void *pvNew = RTMemRealloc(papszUsers, cListSize * sizeof(char*));
567 AssertPtrBreakStmt(pvNew, cListSize -= 32);
568 papszUsers = (char **)pvNew;
569 }
570
571 /* Make sure we don't add user names which are not
572 * part of type USER_PROCES. */
573 if (ut_user->ut_type == USER_PROCESS) /* Regular user process. */
574 {
575 bool fFound = false;
576 for (uint32_t i = 0; i < cUsersInList && !fFound; i++)
577 fFound = strcmp(papszUsers[i], ut_user->ut_user) == 0;
578
579 if (!fFound)
580 {
581 VBoxServiceVerbose(4, "Adding user \"%s\" (type: %d) to list\n",
582 ut_user->ut_user, ut_user->ut_type);
583
584 rc = RTStrDupEx(&papszUsers[cUsersInList], (const char *)ut_user->ut_user);
585 if (RT_FAILURE(rc))
586 break;
587 cUsersInList++;
588 }
589 }
590 }
591
592# ifdef VBOX_WITH_DBUS
593# if defined(RT_OS_LINUX) /* Not yet for Solaris/FreeBSB. */
594 DBusError dbErr;
595 DBusConnection *pConnection = NULL;
596 int rc2 = RTDBusLoadLib();
597 if (RT_SUCCESS(rc2))
598 {
599 /* Handle desktop sessions using ConsoleKit. */
600 VBoxServiceVerbose(4, "Checking ConsoleKit sessions ...\n");
601
602 dbus_error_init(&dbErr);
603 pConnection = dbus_bus_get(DBUS_BUS_SYSTEM, &dbErr);
604 }
605
606 if ( pConnection
607 && !dbus_error_is_set(&dbErr))
608 {
609 /* Get all available sessions. */
610 DBusMessage *pMsgSessions = dbus_message_new_method_call("org.freedesktop.ConsoleKit",
611 "/org/freedesktop/ConsoleKit/Manager",
612 "org.freedesktop.ConsoleKit.Manager",
613 "GetSessions");
614 if ( pMsgSessions
615 && (dbus_message_get_type(pMsgSessions) == DBUS_MESSAGE_TYPE_METHOD_CALL))
616 {
617 DBusMessage *pReplySessions = dbus_connection_send_with_reply_and_block(pConnection,
618 pMsgSessions, 30 * 1000 /* 30s timeout */,
619 &dbErr);
620 if ( pReplySessions
621 && !dbus_error_is_set(&dbErr))
622 {
623 char **ppszSessions; int cSessions;
624 if ( (dbus_message_get_type(pMsgSessions) == DBUS_MESSAGE_TYPE_METHOD_CALL)
625 && vboxService_dbus_message_get_args(pReplySessions, &dbErr, DBUS_TYPE_ARRAY,
626 DBUS_TYPE_OBJECT_PATH, &ppszSessions, &cSessions,
627 DBUS_TYPE_INVALID /* Termination */))
628 {
629 VBoxServiceVerbose(4, "ConsoleKit: retrieved %RU16 session(s)\n", cSessions);
630
631 char **ppszCurSession = ppszSessions;
632 for (ppszCurSession;
633 ppszCurSession && *ppszCurSession; ppszCurSession++)
634 {
635 VBoxServiceVerbose(4, "ConsoleKit: processing session '%s' ...\n", *ppszCurSession);
636
637 /* Only respect active sessions .*/
638 bool fActive = false;
639 DBusMessage *pMsgSessionActive = dbus_message_new_method_call("org.freedesktop.ConsoleKit",
640 *ppszCurSession,
641 "org.freedesktop.ConsoleKit.Session",
642 "IsActive");
643 if ( pMsgSessionActive
644 && dbus_message_get_type(pMsgSessionActive) == DBUS_MESSAGE_TYPE_METHOD_CALL)
645 {
646 DBusMessage *pReplySessionActive = dbus_connection_send_with_reply_and_block(pConnection,
647 pMsgSessionActive, 30 * 1000 /* 30s timeout */,
648 &dbErr);
649 if ( pReplySessionActive
650 && !dbus_error_is_set(&dbErr))
651 {
652 DBusMessageIter itMsg;
653 if ( dbus_message_iter_init(pReplySessionActive, &itMsg)
654 && dbus_message_iter_get_arg_type(&itMsg) == DBUS_TYPE_BOOLEAN)
655 {
656 /* Get uid from message. */
657 int val;
658 dbus_message_iter_get_basic(&itMsg, &val);
659 fActive = val >= 1;
660 }
661
662 if (pReplySessionActive)
663 dbus_message_unref(pReplySessionActive);
664 }
665
666 if (pMsgSessionActive)
667 dbus_message_unref(pMsgSessionActive);
668 }
669
670 VBoxServiceVerbose(4, "ConsoleKit: session '%s' is %s\n",
671 *ppszCurSession, fActive ? "active" : "not active");
672
673 /* *ppszCurSession now contains the object path
674 * (e.g. "/org/freedesktop/ConsoleKit/Session1"). */
675 DBusMessage *pMsgUnixUser = dbus_message_new_method_call("org.freedesktop.ConsoleKit",
676 *ppszCurSession,
677 "org.freedesktop.ConsoleKit.Session",
678 "GetUnixUser");
679 if ( fActive
680 && pMsgUnixUser
681 && dbus_message_get_type(pMsgUnixUser) == DBUS_MESSAGE_TYPE_METHOD_CALL)
682 {
683 DBusMessage *pReplyUnixUser = dbus_connection_send_with_reply_and_block(pConnection,
684 pMsgUnixUser, 30 * 1000 /* 30s timeout */,
685 &dbErr);
686 if ( pReplyUnixUser
687 && !dbus_error_is_set(&dbErr))
688 {
689 DBusMessageIter itMsg;
690 if ( dbus_message_iter_init(pReplyUnixUser, &itMsg)
691 && dbus_message_iter_get_arg_type(&itMsg) == DBUS_TYPE_UINT32)
692 {
693 /* Get uid from message. */
694 uint32_t uid;
695 dbus_message_iter_get_basic(&itMsg, &uid);
696
697 /** @todo Add support for getting UID_MIN (/etc/login.defs on
698 * Debian). */
699 uint32_t uid_min = 1000;
700
701 /* Look up user name (realname) from uid. */
702 setpwent();
703 struct passwd *ppwEntry = getpwuid(uid);
704 if ( ppwEntry
705 && ppwEntry->pw_uid >= uid_min /* Only respect users, not daemons etc. */
706 && ppwEntry->pw_name)
707 {
708 VBoxServiceVerbose(4, "ConsoleKit: session '%s' -> %s (uid: %RU32)\n",
709 *ppszCurSession, ppwEntry->pw_name, uid);
710
711 bool fFound = false;
712 for (uint32_t i = 0; i < cUsersInList && !fFound; i++)
713 fFound = strcmp(papszUsers[i], ppwEntry->pw_name) == 0;
714
715 if (!fFound)
716 {
717 VBoxServiceVerbose(4, "ConsoleKit: adding user \"%s\" to list\n",
718 ppwEntry->pw_name);
719
720 rc = RTStrDupEx(&papszUsers[cUsersInList], (const char *)ppwEntry->pw_name);
721 if (RT_FAILURE(rc))
722 break;
723 cUsersInList++;
724 }
725 }
726 else
727 VBoxServiceError("ConsoleKit: unable to lookup user name for uid=%RU32\n", uid);
728 }
729 else
730 AssertMsgFailed(("ConsoleKit: GetUnixUser returned a wrong argument type\n"));
731 }
732
733 if (pReplyUnixUser)
734 dbus_message_unref(pReplyUnixUser);
735 }
736 else
737 VBoxServiceError("ConsoleKit: unable to retrieve user for session '%s' (msg type=%d): %s",
738 *ppszCurSession, dbus_message_get_type(pMsgUnixUser),
739 dbus_error_is_set(&dbErr) ? dbErr.message : "No error information available");
740
741 if (pMsgUnixUser)
742 dbus_message_unref(pMsgUnixUser);
743 }
744
745 dbus_free_string_array(ppszSessions);
746 }
747 else
748 {
749 VBoxServiceError("ConsoleKit: unable to retrieve session parameters (msg type=%d): %s",
750 dbus_message_get_type(pMsgSessions),
751 dbus_error_is_set(&dbErr) ? dbErr.message : "No error information available");
752 }
753 dbus_message_unref(pReplySessions);
754 }
755
756 if (pMsgSessions)
757 {
758 dbus_message_unref(pMsgSessions);
759 pMsgSessions = NULL;
760 }
761 }
762 else
763 {
764 static int s_iBitchedAboutConsoleKit = 0;
765 if (s_iBitchedAboutConsoleKit++ < 3)
766 VBoxServiceError("Unable to invoke ConsoleKit (%d/3) -- maybe not installed / used? Error: %s\n",
767 s_iBitchedAboutConsoleKit,
768 dbus_error_is_set(&dbErr) ? dbErr.message : "No error information available");
769 }
770
771 if (pMsgSessions)
772 dbus_message_unref(pMsgSessions);
773 }
774 else
775 {
776 static int s_iBitchedAboutDBus = 0;
777 if (s_iBitchedAboutDBus++ < 3)
778 VBoxServiceError("Unable to connect to system D-Bus (%d/3): %s\n", s_iBitchedAboutDBus,
779 pConnection && dbus_error_is_set(&dbErr) ? dbErr.message : "D-Bus not installed");
780 }
781
782 if ( pConnection
783 && dbus_error_is_set(&dbErr))
784 dbus_error_free(&dbErr);
785# endif /* RT_OS_LINUX */
786# endif /* VBOX_WITH_DBUS */
787
788 /** @todo Fedora/others: Handle systemd-loginctl. */
789
790 /* Calc the string length. */
791 size_t cchUserList = 0;
792 if (RT_SUCCESS(rc))
793 {
794 for (uint32_t i = 0; i < cUsersInList; i++)
795 cchUserList += (i != 0) + strlen(papszUsers[i]);
796 }
797
798 /* Build the user list. */
799 if (cchUserList > 0)
800 {
801 if (RT_SUCCESS(rc))
802 rc = RTStrAllocEx(&pszUserList, cchUserList + 1);
803 if (RT_SUCCESS(rc))
804 {
805 char *psz = pszUserList;
806 for (uint32_t i = 0; i < cUsersInList; i++)
807 {
808 if (i != 0)
809 *psz++ = ',';
810 size_t cch = strlen(papszUsers[i]);
811 memcpy(psz, papszUsers[i], cch);
812 psz += cch;
813 }
814 *psz = '\0';
815 }
816 }
817
818 /* Cleanup. */
819 for (uint32_t i = 0; i < cUsersInList; i++)
820 RTStrFree(papszUsers[i]);
821 RTMemFree(papszUsers);
822
823 endutxent(); /* Close utmpx file. */
824#endif /* !RT_OS_WINDOWS && !RT_OS_FREEBSD && !RT_OS_HAIKU && !RT_OS_OS2 */
825
826 Assert(RT_FAILURE(rc) || cUsersInList == 0 || (pszUserList && *pszUserList));
827
828 /* If the user enumeration above failed, reset the user count to 0 except
829 * we didn't have enough memory anymore. In that case we want to preserve
830 * the previous user count in order to not confuse third party tools which
831 * rely on that count. */
832 if (RT_FAILURE(rc))
833 {
834 if (rc == VERR_NO_MEMORY)
835 {
836 static int s_iVMInfoBitchedOOM = 0;
837 if (s_iVMInfoBitchedOOM++ < 3)
838 VBoxServiceVerbose(0, "Warning: Not enough memory available to enumerate users! Keeping old value (%RU32)\n",
839 g_cVMInfoLoggedInUsers);
840 cUsersInList = g_cVMInfoLoggedInUsers;
841 }
842 else
843 cUsersInList = 0;
844 }
845 else /* Preserve logged in users count. */
846 g_cVMInfoLoggedInUsers = cUsersInList;
847
848 VBoxServiceVerbose(4, "cUsersInList=%RU32, pszUserList=%s, rc=%Rrc\n",
849 cUsersInList, pszUserList ? pszUserList : "<NULL>", rc);
850
851 if (pszUserList)
852 {
853 AssertMsg(cUsersInList, ("pszUserList contains users whereas cUsersInList is 0\n"));
854 rc = VBoxServicePropCacheUpdate(&g_VMInfoPropCache, g_pszPropCacheValLoggedInUsersList, "%s", pszUserList);
855 }
856 else
857 rc = VBoxServicePropCacheUpdate(&g_VMInfoPropCache, g_pszPropCacheValLoggedInUsersList, NULL);
858 if (RT_FAILURE(rc))
859 VBoxServiceError("Error writing logged in users list, rc=%Rrc\n", rc);
860
861 rc = VBoxServicePropCacheUpdate(&g_VMInfoPropCache, g_pszPropCacheValLoggedInUsers, "%RU32", cUsersInList);
862 if (RT_FAILURE(rc))
863 VBoxServiceError("Error writing logged in users count, rc=%Rrc\n", rc);
864
865 rc = VBoxServicePropCacheUpdate(&g_VMInfoPropCache, g_pszPropCacheValNoLoggedInUsers,
866 cUsersInList == 0 ? "true" : "false");
867 if (RT_FAILURE(rc))
868 VBoxServiceError("Error writing no logged in users beacon, rc=%Rrc\n", rc);
869
870 if (pszUserList)
871 RTStrFree(pszUserList);
872
873 VBoxServiceVerbose(4, "Writing users returned with rc=%Rrc\n", rc);
874 return rc;
875}
876
877
878/**
879 * Provide information about the guest network.
880 */
881static int vboxserviceVMInfoWriteNetwork(void)
882{
883 int rc = VINF_SUCCESS;
884 uint32_t cIfacesReport = 0;
885 char szPropPath[256];
886
887#ifdef RT_OS_WINDOWS
888 IP_ADAPTER_INFO *pAdpInfo = NULL;
889
890# ifndef TARGET_NT4
891 ULONG cbAdpInfo = sizeof(*pAdpInfo);
892 pAdpInfo = (IP_ADAPTER_INFO *)RTMemAlloc(cbAdpInfo);
893 if (!pAdpInfo)
894 {
895 VBoxServiceError("VMInfo/Network: Failed to allocate IP_ADAPTER_INFO\n");
896 return VERR_NO_MEMORY;
897 }
898 DWORD dwRet = GetAdaptersInfo(pAdpInfo, &cbAdpInfo);
899 if (dwRet == ERROR_BUFFER_OVERFLOW)
900 {
901 IP_ADAPTER_INFO *pAdpInfoNew = (IP_ADAPTER_INFO*)RTMemRealloc(pAdpInfo, cbAdpInfo);
902 if (pAdpInfoNew)
903 {
904 pAdpInfo = pAdpInfoNew;
905 dwRet = GetAdaptersInfo(pAdpInfo, &cbAdpInfo);
906 }
907 }
908 else if (dwRet == ERROR_NO_DATA)
909 {
910 VBoxServiceVerbose(3, "VMInfo/Network: No network adapters available\n");
911
912 /* If no network adapters available / present in the
913 * system we pretend success to not bail out too early. */
914 dwRet = ERROR_SUCCESS;
915 }
916
917 if (dwRet != ERROR_SUCCESS)
918 {
919 if (pAdpInfo)
920 RTMemFree(pAdpInfo);
921 VBoxServiceError("VMInfo/Network: Failed to get adapter info: Error %d\n", dwRet);
922 return RTErrConvertFromWin32(dwRet);
923 }
924# endif /* !TARGET_NT4 */
925
926 SOCKET sd = WSASocket(AF_INET, SOCK_DGRAM, 0, 0, 0, 0);
927 if (sd == SOCKET_ERROR) /* Socket invalid. */
928 {
929 int wsaErr = WSAGetLastError();
930 /* Don't complain/bail out with an error if network stack is not up; can happen
931 * on NT4 due to start up when not connected shares dialogs pop up. */
932 if (WSAENETDOWN == wsaErr)
933 {
934 VBoxServiceVerbose(0, "VMInfo/Network: Network is not up yet.\n");
935 wsaErr = VINF_SUCCESS;
936 }
937 else
938 VBoxServiceError("VMInfo/Network: Failed to get a socket: Error %d\n", wsaErr);
939 if (pAdpInfo)
940 RTMemFree(pAdpInfo);
941 return RTErrConvertFromWin32(wsaErr);
942 }
943
944 INTERFACE_INFO InterfaceList[20] = {0};
945 unsigned long nBytesReturned = 0;
946 if (WSAIoctl(sd,
947 SIO_GET_INTERFACE_LIST,
948 0,
949 0,
950 &InterfaceList,
951 sizeof(InterfaceList),
952 &nBytesReturned,
953 0,
954 0) == SOCKET_ERROR)
955 {
956 VBoxServiceError("VMInfo/Network: Failed to WSAIoctl() on socket: Error: %d\n", WSAGetLastError());
957 if (pAdpInfo)
958 RTMemFree(pAdpInfo);
959 return RTErrConvertFromWin32(WSAGetLastError());
960 }
961 int cIfacesSystem = nBytesReturned / sizeof(INTERFACE_INFO);
962
963 /** @todo Use GetAdaptersInfo() and GetAdapterAddresses (IPv4 + IPv6) for more information. */
964 for (int i = 0; i < cIfacesSystem; ++i)
965 {
966 sockaddr_in *pAddress;
967 u_long nFlags = 0;
968 if (InterfaceList[i].iiFlags & IFF_LOOPBACK) /* Skip loopback device. */
969 continue;
970 nFlags = InterfaceList[i].iiFlags;
971 pAddress = (sockaddr_in *)&(InterfaceList[i].iiAddress);
972 Assert(pAddress);
973 char szIp[32];
974 RTStrPrintf(szIp, sizeof(szIp), "%s", inet_ntoa(pAddress->sin_addr));
975 RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestInfo/Net/%RU32/V4/IP", cIfacesReport);
976 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath, "%s", szIp);
977
978 pAddress = (sockaddr_in *) & (InterfaceList[i].iiBroadcastAddress);
979 RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestInfo/Net/%RU32/V4/Broadcast", cIfacesReport);
980 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath, "%s", inet_ntoa(pAddress->sin_addr));
981
982 pAddress = (sockaddr_in *)&(InterfaceList[i].iiNetmask);
983 RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestInfo/Net/%RU32/V4/Netmask", cIfacesReport);
984 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath, "%s", inet_ntoa(pAddress->sin_addr));
985
986 RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestInfo/Net/%RU32/Status", cIfacesReport);
987 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath, nFlags & IFF_UP ? "Up" : "Down");
988
989# ifndef TARGET_NT4
990 IP_ADAPTER_INFO *pAdp;
991 for (pAdp = pAdpInfo; pAdp; pAdp = pAdp->Next)
992 if (!strcmp(pAdp->IpAddressList.IpAddress.String, szIp))
993 break;
994
995 RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestInfo/Net/%RU32/MAC", cIfacesReport);
996 if (pAdp)
997 {
998 char szMac[32];
999 RTStrPrintf(szMac, sizeof(szMac), "%02X%02X%02X%02X%02X%02X",
1000 pAdp->Address[0], pAdp->Address[1], pAdp->Address[2],
1001 pAdp->Address[3], pAdp->Address[4], pAdp->Address[5]);
1002 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath, "%s", szMac);
1003 }
1004 else
1005 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath, NULL);
1006# endif /* !TARGET_NT4 */
1007
1008 cIfacesReport++;
1009 }
1010 if (pAdpInfo)
1011 RTMemFree(pAdpInfo);
1012 if (sd >= 0)
1013 closesocket(sd);
1014
1015#elif defined(RT_OS_HAIKU)
1016 /** @todo Haiku: implement network info. retreival */
1017 return VERR_NOT_IMPLEMENTED;
1018
1019#elif defined(RT_OS_DARWIN) || defined(RT_OS_FREEBSD)
1020 struct ifaddrs *pIfHead = NULL;
1021
1022 /* Get all available interfaces */
1023 rc = getifaddrs(&pIfHead);
1024 if (rc < 0)
1025 {
1026 rc = RTErrConvertFromErrno(errno);
1027 VBoxServiceError("VMInfo/Network: Failed to get all interfaces: Error %Rrc\n");
1028 return rc;
1029 }
1030
1031 /* Loop through all interfaces and set the data. */
1032 for (struct ifaddrs *pIfCurr = pIfHead; pIfCurr; pIfCurr = pIfCurr->ifa_next)
1033 {
1034 /*
1035 * Only AF_INET and no loopback interfaces
1036 */
1037 /** @todo: IPv6 interfaces */
1038 if ( pIfCurr->ifa_addr->sa_family == AF_INET
1039 && !(pIfCurr->ifa_flags & IFF_LOOPBACK))
1040 {
1041 char szInetAddr[NI_MAXHOST];
1042
1043 memset(szInetAddr, 0, NI_MAXHOST);
1044 getnameinfo(pIfCurr->ifa_addr, sizeof(struct sockaddr_in),
1045 szInetAddr, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
1046 RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestInfo/Net/%RU32/V4/IP", cIfacesReport);
1047 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath, "%s", szInetAddr);
1048
1049 memset(szInetAddr, 0, NI_MAXHOST);
1050 getnameinfo(pIfCurr->ifa_broadaddr, sizeof(struct sockaddr_in),
1051 szInetAddr, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
1052 RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestInfo/Net/%RU32/V4/Broadcast", cIfacesReport);
1053 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath, "%s", szInetAddr);
1054
1055 memset(szInetAddr, 0, NI_MAXHOST);
1056 getnameinfo(pIfCurr->ifa_netmask, sizeof(struct sockaddr_in),
1057 szInetAddr, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
1058 RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestInfo/Net/%RU32/V4/Netmask", cIfacesReport);
1059 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath, "%s", szInetAddr);
1060
1061 /* Search for the AF_LINK interface of the current AF_INET one and get the mac. */
1062 for (struct ifaddrs *pIfLinkCurr = pIfHead; pIfLinkCurr; pIfLinkCurr = pIfLinkCurr->ifa_next)
1063 {
1064 if ( pIfLinkCurr->ifa_addr->sa_family == AF_LINK
1065 && !strcmp(pIfCurr->ifa_name, pIfLinkCurr->ifa_name))
1066 {
1067 char szMac[32];
1068 uint8_t *pu8Mac = NULL;
1069 struct sockaddr_dl *pLinkAddress = (struct sockaddr_dl *)pIfLinkCurr->ifa_addr;
1070
1071 AssertPtr(pLinkAddress);
1072 pu8Mac = (uint8_t *)LLADDR(pLinkAddress);
1073 RTStrPrintf(szMac, sizeof(szMac), "%02X%02X%02X%02X%02X%02X",
1074 pu8Mac[0], pu8Mac[1], pu8Mac[2], pu8Mac[3], pu8Mac[4], pu8Mac[5]);
1075 RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestInfo/Net/%RU32/MAC", cIfacesReport);
1076 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath, "%s", szMac);
1077 break;
1078 }
1079 }
1080
1081 RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestInfo/Net/%RU32/Status", cIfacesReport);
1082 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath, pIfCurr->ifa_flags & IFF_UP ? "Up" : "Down");
1083
1084 cIfacesReport++;
1085 }
1086 }
1087
1088 /* Free allocated resources. */
1089 freeifaddrs(pIfHead);
1090
1091#else /* !RT_OS_WINDOWS && !RT_OS_FREEBSD */
1092 int sd = socket(AF_INET, SOCK_DGRAM, 0);
1093 if (sd < 0)
1094 {
1095 rc = RTErrConvertFromErrno(errno);
1096 VBoxServiceError("VMInfo/Network: Failed to get a socket: Error %Rrc\n", rc);
1097 return rc;
1098 }
1099
1100 ifconf ifcfg;
1101 char buffer[1024] = {0};
1102 ifcfg.ifc_len = sizeof(buffer);
1103 ifcfg.ifc_buf = buffer;
1104 if (ioctl(sd, SIOCGIFCONF, &ifcfg) < 0)
1105 {
1106 close(sd);
1107 rc = RTErrConvertFromErrno(errno);
1108 VBoxServiceError("VMInfo/Network: Failed to ioctl(SIOCGIFCONF) on socket: Error %Rrc\n", rc);
1109 return rc;
1110 }
1111
1112 ifreq *ifrequest = ifcfg.ifc_req;
1113 int cIfacesSystem = ifcfg.ifc_len / sizeof(ifreq);
1114
1115# ifdef RT_OS_OS2 /* Get the physical addresses. */
1116 struct ifmib IfStats;
1117 if (ioctl(sd, SIOSTATIF, &IfStats) < 0)
1118 {
1119 VBoxServiceError("VMInfo/Network: Failed to ioctl(SIOSTATIF): errno=%d\n", errno);
1120 RT_ZERO(IfStats);
1121 }
1122# endif
1123
1124 for (int i = 0; i < cIfacesSystem; ++i)
1125 {
1126# ifdef RT_OS_OS2
1127 ifreq IfReqCopy = ifrequest[i];
1128# endif
1129 /* Get the interface flags. */
1130 if (ioctl(sd, SIOCGIFFLAGS, &ifrequest[i]) < 0)
1131 {
1132# ifdef RT_OS_OS2 /* Ignore errors when querying flags for non-existing interfaces. */
1133 if (errno == ENXIO)
1134 continue;
1135# endif
1136 rc = RTErrConvertFromErrno(errno);
1137 VBoxServiceError("VMInfo/Network: Failed to ioctl(SIOCGIFFLAGS,#%u) on socket: Error %Rrc\n", i, rc);
1138 break;
1139 }
1140 if (ifrequest[i].ifr_flags & IFF_LOOPBACK) /* Skip the loopback device. */
1141 continue;
1142
1143 bool const fIfUp = !!(ifrequest[i].ifr_flags & IFF_UP);
1144
1145# ifdef RT_OS_OS2 /* I think this should be done everywhere. */
1146 /* Get the address. */
1147 ifrequest[i] = IfReqCopy;
1148 if (ioctl(sd, SIOCGIFADDR, &ifrequest[i]) < 0)
1149 {
1150 rc = RTErrConvertFromErrno(errno);
1151 VBoxServiceError("VMInfo/Network: Failed to ioctl(SIOCGIFADDR) on socket: Error %Rrc\n", rc);
1152 break;
1153 }
1154# endif
1155 sockaddr_in *pAddress = ((sockaddr_in *)&ifrequest[i].ifr_addr);
1156 RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestInfo/Net/%RU32/V4/IP", cIfacesReport);
1157 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath, "%s", inet_ntoa(pAddress->sin_addr));
1158
1159 /* Get the broadcast address. */
1160 if (ioctl(sd, SIOCGIFBRDADDR, &ifrequest[i]) < 0)
1161 {
1162 rc = RTErrConvertFromErrno(errno);
1163 VBoxServiceError("VMInfo/Network: Failed to ioctl(SIOCGIFBRDADDR) on socket: Error %Rrc\n", rc);
1164 break;
1165 }
1166 pAddress = (sockaddr_in *)&ifrequest[i].ifr_broadaddr;
1167 RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestInfo/Net/%RU32/V4/Broadcast", cIfacesReport);
1168 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath, "%s", inet_ntoa(pAddress->sin_addr));
1169
1170 /* Get the net mask. */
1171 if (ioctl(sd, SIOCGIFNETMASK, &ifrequest[i]) < 0)
1172 {
1173 rc = RTErrConvertFromErrno(errno);
1174 VBoxServiceError("VMInfo/Network: Failed to ioctl(SIOCGIFNETMASK) on socket: Error %Rrc\n", rc);
1175 break;
1176 }
1177# if defined(RT_OS_OS2) || defined(RT_OS_SOLARIS)
1178 pAddress = (sockaddr_in *)&ifrequest[i].ifr_addr;
1179# else
1180 pAddress = (sockaddr_in *)&ifrequest[i].ifr_netmask;
1181# endif
1182 RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestInfo/Net/%RU32/V4/Netmask", cIfacesReport);
1183 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath, "%s", inet_ntoa(pAddress->sin_addr));
1184
1185# if defined(RT_OS_SOLARIS)
1186 /*
1187 * "ifreq" is obsolete on Solaris. We use the recommended "lifreq".
1188 * We might fail if the interface has not been assigned an IP address.
1189 * That doesn't matter; as long as it's plumbed we can pick it up.
1190 * But, if it has not acquired an IP address we cannot obtain it's MAC
1191 * address this way, so we just use all zeros there.
1192 */
1193 RTMAC IfMac;
1194 RT_ZERO(IfMac);
1195 struct lifreq IfReq;
1196 RT_ZERO(IfReq);
1197 AssertCompile(sizeof(IfReq.lifr_name) >= sizeof(ifrequest[i].ifr_name));
1198 strncpy(IfReq.lifr_name, ifrequest[i].ifr_name, sizeof(ifrequest[i].ifr_name));
1199 if (ioctl(sd, SIOCGLIFADDR, &IfReq) >= 0)
1200 {
1201 struct arpreq ArpReq;
1202 RT_ZERO(ArpReq);
1203 memcpy(&ArpReq.arp_pa, &IfReq.lifr_addr, sizeof(struct sockaddr_in));
1204
1205 if (ioctl(sd, SIOCGARP, &ArpReq) >= 0)
1206 memcpy(&IfMac, ArpReq.arp_ha.sa_data, sizeof(IfMac));
1207 else
1208 {
1209 rc = RTErrConvertFromErrno(errno);
1210 VBoxServiceError("VMInfo/Network: failed to ioctl(SIOCGARP) on socket: Error %Rrc\n", rc);
1211 break;
1212 }
1213 }
1214 else
1215 {
1216 VBoxServiceVerbose(2, "VMInfo/Network: Interface %d has no assigned IP address, skipping ...\n", i);
1217 continue;
1218 }
1219# elif defined(RT_OS_OS2)
1220 RTMAC IfMac;
1221 uint32_t iIfStat = RT_MIN((unsigned)IfStats.ifNumber, IFMIB_ENTRIES); /* paranoia */
1222 while (iIfStat-- > 0) /** @todo test this code with more than one interface. */
1223 if (IfStats.iftable[iIfStat].iftIndex == i)
1224 memcpy(&IfMac, IfStats.iftable[iIfStat].iftPhysAddr, sizeof(IfMac));
1225#else
1226 if (ioctl(sd, SIOCGIFHWADDR, &ifrequest[i]) < 0)
1227 {
1228 rc = RTErrConvertFromErrno(errno);
1229 VBoxServiceError("VMInfo/Network: Failed to ioctl(SIOCGIFHWADDR) on socket: Error %Rrc\n", rc);
1230 break;
1231 }
1232 RTMAC IfMac = *(PRTMAC)&ifrequest[i].ifr_hwaddr.sa_data[0];
1233# endif
1234 RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestInfo/Net/%RU32/MAC", cIfacesReport);
1235 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath, "%02X%02X%02X%02X%02X%02X",
1236 IfMac.au8[0], IfMac.au8[1], IfMac.au8[2], IfMac.au8[3], IfMac.au8[4], IfMac.au8[5]);
1237
1238 RTStrPrintf(szPropPath, sizeof(szPropPath), "/VirtualBox/GuestInfo/Net/%RU32/Status", cIfacesReport);
1239 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, szPropPath, fIfUp ? "Up" : "Down");
1240 cIfacesReport++;
1241 } /* For all interfaces */
1242
1243 close(sd);
1244 if (RT_FAILURE(rc))
1245 VBoxServiceError("VMInfo/Network: Network enumeration for interface %RU32 failed with error %Rrc\n", cIfacesReport, rc);
1246
1247#endif /* !RT_OS_WINDOWS */
1248
1249#if 0 /* Zapping not enabled yet, needs more testing first. */
1250 /*
1251 * Zap all stale network interface data if the former (saved) network ifaces count
1252 * is bigger than the current one.
1253 */
1254
1255 /* Get former count. */
1256 uint32_t cIfacesReportOld;
1257 rc = VBoxServiceReadPropUInt32(g_uVMInfoGuestPropSvcClientID, g_pszPropCacheValNetCount, &cIfacesReportOld,
1258 0 /* Min */, UINT32_MAX /* Max */);
1259 if ( RT_SUCCESS(rc)
1260 && cIfacesReportOld > cIfacesReport) /* Are some ifaces not around anymore? */
1261 {
1262 VBoxServiceVerbose(3, "VMInfo/Network: Stale interface data detected (%RU32 old vs. %RU32 current)\n",
1263 cIfacesReportOld, cIfacesReport);
1264
1265 uint32_t uIfaceDeleteIdx = cIfacesReport;
1266 do
1267 {
1268 VBoxServiceVerbose(3, "VMInfo/Network: Deleting stale data of interface %d ...\n", uIfaceDeleteIdx);
1269 rc = VBoxServicePropCacheUpdateByPath(&g_VMInfoPropCache, NULL /* Value, delete */, 0 /* Flags */, "/VirtualBox/GuestInfo/Net/%RU32", uIfaceDeleteIdx++);
1270 } while (RT_SUCCESS(rc));
1271 }
1272 else if ( RT_FAILURE(rc)
1273 && rc != VERR_NOT_FOUND)
1274 {
1275 VBoxServiceError("VMInfo/Network: Failed retrieving old network interfaces count with error %Rrc\n", rc);
1276 }
1277#endif
1278
1279 /*
1280 * This property is a beacon which is _always_ written, even if the network configuration
1281 * does not change. If this property is missing, the host assumes that all other GuestInfo
1282 * properties are no longer valid.
1283 */
1284 VBoxServicePropCacheUpdate(&g_VMInfoPropCache, g_pszPropCacheValNetCount, "%RU32",
1285 cIfacesReport);
1286
1287 /* Don't fail here; just report everything we got. */
1288 return VINF_SUCCESS;
1289}
1290
1291
1292/** @copydoc VBOXSERVICE::pfnWorker */
1293DECLCALLBACK(int) VBoxServiceVMInfoWorker(bool volatile *pfShutdown)
1294{
1295 int rc;
1296
1297 /*
1298 * Tell the control thread that it can continue
1299 * spawning services.
1300 */
1301 RTThreadUserSignal(RTThreadSelf());
1302
1303#ifdef RT_OS_WINDOWS
1304 /* Required for network information (must be called per thread). */
1305 WSADATA wsaData;
1306 if (WSAStartup(MAKEWORD(2, 2), &wsaData))
1307 VBoxServiceError("VMInfo/Network: WSAStartup failed! Error: %Rrc\n", RTErrConvertFromWin32(WSAGetLastError()));
1308#endif /* RT_OS_WINDOWS */
1309
1310 /*
1311 * Write the fixed properties first.
1312 */
1313 vboxserviceVMInfoWriteFixedProperties();
1314
1315 /*
1316 * Now enter the loop retrieving runtime data continuously.
1317 */
1318 for (;;)
1319 {
1320 rc = vboxserviceVMInfoWriteUsers();
1321 if (RT_FAILURE(rc))
1322 break;
1323
1324 rc = vboxserviceVMInfoWriteNetwork();
1325 if (RT_FAILURE(rc))
1326 break;
1327
1328 /* Whether to wait for event semaphore or not. */
1329 bool fWait = true;
1330
1331 /* Check for location awareness. This most likely only
1332 * works with VBox (latest) 4.1 and up. */
1333
1334 /* Check for new connection. */
1335 char *pszLAClientID = NULL;
1336 int rc2 = VBoxServiceReadHostProp(g_uVMInfoGuestPropSvcClientID, g_pszLAActiveClient, true /* Read only */,
1337 &pszLAClientID, NULL /* Flags */, NULL /* Timestamp */);
1338 if (RT_SUCCESS(rc2))
1339 {
1340 AssertPtr(pszLAClientID);
1341 if (RTStrICmp(pszLAClientID, "0")) /* Is a client connected? */
1342 {
1343 uint32_t uLAClientID = RTStrToInt32(pszLAClientID);
1344 uint64_t uLAClientAttachedTS;
1345
1346 /* Peek at "Attach" value to figure out if hotdesking happened. */
1347 char *pszAttach = NULL;
1348 rc2 = vboxServiceGetLAClientValue(uLAClientID, "Attach", &pszAttach,
1349 &uLAClientAttachedTS);
1350
1351 if ( RT_SUCCESS(rc2)
1352 && ( !g_LAClientAttachedTS
1353 || (g_LAClientAttachedTS != uLAClientAttachedTS)))
1354 {
1355 vboxServiceFreeLAClientInfo(&g_LAClientInfo);
1356
1357 /* Note: There is a race between setting the guest properties by the host and getting them by
1358 * the guest. */
1359 rc2 = vboxServiceGetLAClientInfo(uLAClientID, &g_LAClientInfo);
1360 if (RT_SUCCESS(rc2))
1361 {
1362 VBoxServiceVerbose(1, "VRDP: Hotdesk client %s with ID=%RU32, Name=%s, Domain=%s\n",
1363 /* If g_LAClientAttachedTS is 0 this means there already was an active
1364 * hotdesk session when VBoxService started. */
1365 !g_LAClientAttachedTS ? "already active" : g_LAClientInfo.fAttached ? "connected" : "disconnected",
1366 uLAClientID, g_LAClientInfo.pszName, g_LAClientInfo.pszDomain);
1367
1368 g_LAClientAttachedTS = g_LAClientInfo.uAttachedTS;
1369
1370 /* Don't wait for event semaphore below anymore because we now know that the client
1371 * changed. This means we need to iterate all VM information again immediately. */
1372 fWait = false;
1373 }
1374 else
1375 {
1376 static int s_iBitchedAboutLAClientInfo = 0;
1377 if (s_iBitchedAboutLAClientInfo++ < 10)
1378 VBoxServiceError("Error getting active location awareness client info, rc=%Rrc\n", rc2);
1379 }
1380 }
1381 else if (RT_FAILURE(rc2))
1382 VBoxServiceError("Error getting attached value of location awareness client %RU32, rc=%Rrc\n",
1383 uLAClientID, rc2);
1384 if (pszAttach)
1385 RTStrFree(pszAttach);
1386 }
1387 else
1388 {
1389 VBoxServiceVerbose(1, "VRDP: UTTSC disconnected from VRDP server\n");
1390 vboxServiceFreeLAClientInfo(&g_LAClientInfo);
1391 }
1392
1393 RTStrFree(pszLAClientID);
1394 }
1395 else
1396 {
1397 static int s_iBitchedAboutLAClient = 0;
1398 if ( (rc2 != VERR_NOT_FOUND) /* No location awareness installed, skip. */
1399 && s_iBitchedAboutLAClient++ < 3)
1400 VBoxServiceError("VRDP: Querying connected location awareness client failed with rc=%Rrc\n", rc2);
1401 }
1402
1403 VBoxServiceVerbose(3, "VRDP: Handling location awareness done\n");
1404
1405 /*
1406 * Flush all properties if we were restored.
1407 */
1408 uint64_t idNewSession = g_idVMInfoSession;
1409 VbglR3GetSessionId(&idNewSession);
1410 if (idNewSession != g_idVMInfoSession)
1411 {
1412 VBoxServiceVerbose(3, "The VM session ID changed, flushing all properties\n");
1413 vboxserviceVMInfoWriteFixedProperties();
1414 VBoxServicePropCacheFlush(&g_VMInfoPropCache);
1415 g_idVMInfoSession = idNewSession;
1416 }
1417
1418 /*
1419 * Block for a while.
1420 *
1421 * The event semaphore takes care of ignoring interruptions and it
1422 * allows us to implement service wakeup later.
1423 */
1424 if (*pfShutdown)
1425 break;
1426 if (fWait)
1427 rc2 = RTSemEventMultiWait(g_hVMInfoEvent, g_cMsVMInfoInterval);
1428 if (*pfShutdown)
1429 break;
1430 if (rc2 != VERR_TIMEOUT && RT_FAILURE(rc2))
1431 {
1432 VBoxServiceError("RTSemEventMultiWait failed; rc2=%Rrc\n", rc2);
1433 rc = rc2;
1434 break;
1435 }
1436 else if (RT_LIKELY(RT_SUCCESS(rc2)))
1437 {
1438 /* Reset event semaphore if it got triggered. */
1439 rc2 = RTSemEventMultiReset(g_hVMInfoEvent);
1440 if (RT_FAILURE(rc2))
1441 rc2 = VBoxServiceError("RTSemEventMultiReset failed; rc2=%Rrc\n", rc2);
1442 }
1443 }
1444
1445#ifdef RT_OS_WINDOWS
1446 WSACleanup();
1447#endif
1448
1449 return rc;
1450}
1451
1452
1453/** @copydoc VBOXSERVICE::pfnStop */
1454static DECLCALLBACK(void) VBoxServiceVMInfoStop(void)
1455{
1456 RTSemEventMultiSignal(g_hVMInfoEvent);
1457}
1458
1459
1460/** @copydoc VBOXSERVICE::pfnTerm */
1461static DECLCALLBACK(void) VBoxServiceVMInfoTerm(void)
1462{
1463 if (g_hVMInfoEvent != NIL_RTSEMEVENTMULTI)
1464 {
1465 /** @todo temporary solution: Zap all values which are not valid
1466 * anymore when VM goes down (reboot/shutdown ). Needs to
1467 * be replaced with "temporary properties" later.
1468 *
1469 * One idea is to introduce a (HGCM-)session guest property
1470 * flag meaning that a guest property is only valid as long
1471 * as the HGCM session isn't closed (e.g. guest application
1472 * terminates). [don't remove till implemented]
1473 */
1474 /** @todo r=bird: Drop the VbglR3GuestPropDelSet call here and use the cache
1475 * since it remembers what we've written. */
1476 /* Delete the "../Net" branch. */
1477 const char *apszPat[1] = { "/VirtualBox/GuestInfo/Net/*" };
1478 int rc = VbglR3GuestPropDelSet(g_uVMInfoGuestPropSvcClientID, &apszPat[0], RT_ELEMENTS(apszPat));
1479
1480 /* Destroy LA client info. */
1481 vboxServiceFreeLAClientInfo(&g_LAClientInfo);
1482
1483 /* Destroy property cache. */
1484 VBoxServicePropCacheDestroy(&g_VMInfoPropCache);
1485
1486 /* Disconnect from guest properties service. */
1487 rc = VbglR3GuestPropDisconnect(g_uVMInfoGuestPropSvcClientID);
1488 if (RT_FAILURE(rc))
1489 VBoxServiceError("Failed to disconnect from guest property service! Error: %Rrc\n", rc);
1490 g_uVMInfoGuestPropSvcClientID = 0;
1491
1492 RTSemEventMultiDestroy(g_hVMInfoEvent);
1493 g_hVMInfoEvent = NIL_RTSEMEVENTMULTI;
1494 }
1495}
1496
1497
1498/**
1499 * The 'vminfo' service description.
1500 */
1501VBOXSERVICE g_VMInfo =
1502{
1503 /* pszName. */
1504 "vminfo",
1505 /* pszDescription. */
1506 "Virtual Machine Information",
1507 /* pszUsage. */
1508 " [--vminfo-interval <ms>] [--vminfo-user-idle-threshold <ms>]"
1509 ,
1510 /* pszOptions. */
1511 " --vminfo-interval Specifies the interval at which to retrieve the\n"
1512 " VM information. The default is 10000 ms.\n"
1513 " --vminfo-user-idle-threshold <ms>\n"
1514 " Specifies the user idle threshold (in ms) for\n"
1515 " considering a guest user as being idle. The default\n"
1516 " is 5000 (5 seconds).\n"
1517 ,
1518 /* methods */
1519 VBoxServiceVMInfoPreInit,
1520 VBoxServiceVMInfoOption,
1521 VBoxServiceVMInfoInit,
1522 VBoxServiceVMInfoWorker,
1523 VBoxServiceVMInfoStop,
1524 VBoxServiceVMInfoTerm
1525};
1526
Note: See TracBrowser for help on using the repository browser.

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