VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxLA.cpp@ 63311

Last change on this file since 63311 was 63104, checked in by vboxsync, 8 years ago

GA/NT/VBoxTray: warnings
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 40.8 KB
Line 
1/* $Id: VBoxLA.cpp 63104 2016-08-06 16:00:44Z vboxsync $ */
2/** @file
3 * VBoxLA - VBox Location Awareness notifications.
4 */
5
6/*
7 * Copyright (C) 2014-2016 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#define _WIN32_WINNT 0x0501
18#include <iprt/win/windows.h>
19
20#include "VBoxTray.h"
21#include "VBoxLA.h"
22
23#include <iprt/assert.h>
24#include <iprt/alloc.h>
25#include <iprt/list.h>
26#include <iprt/ldr.h>
27
28#ifdef DEBUG
29# define LOG_ENABLED
30# define LOG_GROUP LOG_GROUP_DEFAULT
31#endif
32#include <VBox/log.h>
33
34
35
36#define REG_KEY_LEN 1024
37#define MAX_CLIENT_NAME_CHARS 1024
38
39#define LA_DO_NOTHING 0
40#define LA_DO_ATTACH 1
41#define LA_DO_DETACH 2
42#define LA_DO_DETACH_AND_ATTACH 3
43#define LA_DO_ATTACH_AND_DETACH 4
44
45
46#define LA_UTCINFO_CLIENT_NAME 0
47#define LA_UTCINFO_CLIENT_IPADDR 1
48#define LA_UTCINFO_CLIENT_LOCATION 2
49#define LA_UTCINFO_CLIENT_OTHERINFO 3
50#define LA_UTCINFO_CLIENT_INFO_LAST 3
51
52#define LA_UTCINFO_PROP_NAME 0
53#define LA_UTCINFO_PROP_VALUE 1
54
55
56typedef struct _VBOXLACONTEXT
57{
58 const VBOXSERVICEENV *pEnv;
59
60 bool fLogEnabled;
61 bool fDetachOnDisconnect;
62
63 uint32_t u32GuestPropHandle; /* The client identifier of the guest property system. */
64
65 RTLISTANCHOR listAttachActions;
66 RTLISTANCHOR listDetachActions;
67
68 uint64_t u64LastQuery; /* The timestamp of the last query of the properties. */
69
70 uint32_t u32Action; /* Which action to do: LA_DO_*. */
71 uint32_t u32PrevAction; /* Which action were done last time. */
72
73 struct /* Information about the client, which properties are monitored. */
74 {
75 uint32_t u32ClientId; /* The RDP client identifier. 0 if none. */
76
77 uint32_t u32LastAttach;
78 uint64_t u64LastAttachTimestamp;
79
80 char *pszLastName;
81 uint64_t u64LastNameTimestamp;
82
83 char *pszPropName; /* The actual Client/%ID%/Name property name with client id. */
84 char *pszPropIPAddr; /* The actual Client/%ID%/IPAddr property name with client id. */
85 char *pszPropLocation; /* The actual Client/%ID%/Location property name with client id. */
86 char *pszPropOtherInfo; /* The actual Client/%ID%/OtherInfo property name with client id. */
87
88 char *pszPropAttach; /* The actual Client/%ID%/Attach property name with client id. */
89
90 char *pszPropWaitPattern; /* Which properties are monitored. */
91 } activeClient;
92
93 BOOL (WINAPI * pfnProcessIdToSessionId)(DWORD dwProcessId, DWORD *pSessionId);
94} VBOXLACONTEXT, *PVBOXLACONTEXT;
95
96typedef struct _ACTIONENTRY
97{
98 RTLISTNODE nodeActionEntry;
99 uint32_t u32Index;
100 WCHAR wszCommandLine[1];
101} ACTIONENTRY, *PACTIONENTRY;
102
103
104static VBOXLACONTEXT g_Ctx = { 0 };
105
106static const char *g_pszPropActiveClient = "/VirtualBox/HostInfo/VRDP/ActiveClient";
107
108static const char *g_pszPropAttachTemplate = "/VirtualBox/HostInfo/VRDP/Client/%u/Attach";
109
110static const char *g_pszVolatileEnvironment = "Volatile Environment";
111
112static const WCHAR *g_pwszClientName = L"CLIENTNAME";
113
114static const WCHAR *g_pwszUTCINFOClientInfo[] = {
115 L"UTCINFO_CLIENTNAME",
116 L"UTCINFO_CLIENTIPA",
117 L"UTCINFO_CLIENTLOCATION",
118 L"UTCINFO_CLIENTOTHERINFO"
119 };
120
121static const char *g_pszPropInfoTemplates[] = {
122 "/VirtualBox/HostInfo/VRDP/Client/%u/Name",
123 "/VirtualBox/HostInfo/VRDP/Client/%u/IPAddr",
124 "/VirtualBox/HostInfo/VRDP/Client/%u/Location",
125 "/VirtualBox/HostInfo/VRDP/Client/%u/OtherInfo"
126 };
127
128#ifdef RT_ARCH_AMD64
129const WCHAR *g_pwszRegKeyDisconnectActions = L"Software\\Wow6432Node\\Oracle\\Sun Ray\\ClientInfoAgent\\DisconnectActions";
130const WCHAR *g_pwszRegKeyReconnectActions = L"Software\\Wow6432Node\\Oracle\\Sun Ray\\ClientInfoAgent\\ReconnectActions";
131#else
132const WCHAR *g_pwszRegKeyDisconnectActions = L"Software\\Oracle\\Sun Ray\\ClientInfoAgent\\DisconnectActions";
133const WCHAR *g_pwszRegKeyReconnectActions = L"Software\\Oracle\\Sun Ray\\ClientInfoAgent\\ReconnectActions";
134#endif /* !RT_ARCH_AMD64 */
135
136const char g_szCommandPrefix[] = "Command";
137
138static BOOL laGetRegistryDWORD(WCHAR *pwszRegKey, WCHAR *pwszName, DWORD *pdwValue)
139{
140 LONG lErr;
141
142 HKEY hKey;
143 lErr = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
144 pwszRegKey,
145 0,
146 KEY_QUERY_VALUE,
147 &hKey);
148
149 if (lErr != ERROR_SUCCESS)
150 {
151 LogRel(("LA: RegOpenKeyExW: failed [%ls]\n",
152 pwszRegKey));
153 return FALSE;
154 }
155
156 DWORD nRegData = sizeof(DWORD);
157 DWORD dwType = 0;
158 lErr = RegQueryValueExW(hKey,
159 pwszName,
160 NULL,
161 &dwType,
162 (BYTE *)pdwValue,
163 &nRegData);
164
165 if (lErr != ERROR_SUCCESS)
166 {
167 LogRel(("LA: RegQueryValueExW: failed [%ls/%ls]\n",
168 pwszRegKey, pwszName));
169 RegCloseKey(hKey);
170 return FALSE;
171 }
172
173 if (nRegData != sizeof(DWORD))
174 {
175 LogRel(("LA: buffer overflow reg %d, [%ls]\n",
176 nRegData, pwszRegKey));
177 RegCloseKey(hKey);
178 return FALSE;
179 }
180
181 if (dwType != REG_DWORD)
182 {
183 LogRel(("LA: wrong type %d, [%ls/%ls]\n",
184 dwType, pwszRegKey, pwszName));
185 RegCloseKey(hKey);
186 return FALSE;
187 }
188
189 RegCloseKey(hKey);
190
191 if (lErr != ERROR_SUCCESS)
192 {
193 return FALSE;
194 }
195
196 return TRUE;
197}
198
199static void ActionExecutorDeleteActions(RTLISTANCHOR *listActions)
200{
201 ACTIONENTRY *pIter = NULL;
202 ACTIONENTRY *pIterNext = NULL;
203 RTListForEachSafe(listActions, pIter, pIterNext, ACTIONENTRY, nodeActionEntry)
204 {
205 RTListNodeRemove(&pIter->nodeActionEntry);
206 RTMemFree(pIter);
207 }
208}
209
210static BOOL ActionExecutorEnumerateRegistryKey(const WCHAR *pwszRegKey,
211 RTLISTANCHOR *listActions)
212{
213 BOOL bRet = TRUE;
214 HKEY hKey;
215 DWORD dwErr;
216
217 dwErr = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
218 pwszRegKey,
219 0,
220 KEY_QUERY_VALUE,
221 &hKey);
222
223 if (dwErr != ERROR_SUCCESS)
224 {
225 LogFlowFunc(("Can't open registry key [%ls], error %d\n",
226 pwszRegKey, dwErr));
227 return FALSE;
228 }
229
230 DWORD dwIndex = 0;
231
232 for (;;)
233 {
234 DWORD dwRet;
235
236 WCHAR wszValueName[256];
237 DWORD cchValueName = RT_ELEMENTS(wszValueName);
238 DWORD type;
239 BYTE abData[1024];
240 DWORD cbData = sizeof(abData);
241
242 dwRet = RegEnumValueW(hKey,
243 dwIndex++,
244 wszValueName,
245 &cchValueName,
246 NULL,
247 &type,
248 abData,
249 &cbData);
250
251 if (dwRet == ERROR_NO_MORE_ITEMS)
252 {
253 LogFlowFunc(("Enumeration exhausted\n"));
254 bRet = TRUE;
255 break;
256 }
257 else if (dwRet != ERROR_SUCCESS)
258 {
259 LogFlowFunc(("Enumeration failed, error %d\n",
260 dwRet));
261 bRet = FALSE;
262 break;
263 }
264
265 if ((type != REG_SZ) && (type != REG_EXPAND_SZ))
266 {
267 LogFlowFunc(("skipped type %d\n",
268 type));
269 continue;
270 }
271
272 char szName[256];
273 char *pszName = &szName[0];
274 int rc = RTUtf16ToUtf8Ex(wszValueName,
275 RT_ELEMENTS(wszValueName),
276 &pszName, sizeof(szName), NULL);
277 if (RT_FAILURE(rc))
278 {
279 LogFlowFunc(("RTUtf16ToUtf8Ex for [%ls] rc %Rrc\n",
280 wszValueName, rc));
281 continue;
282 }
283
284 /* Check if the name starts with "Command" */
285 if (RTStrNICmp(szName, g_szCommandPrefix, RT_ELEMENTS(g_szCommandPrefix) - 1) != 0)
286 {
287 LogFlowFunc(("skipped prefix %s\n",
288 szName));
289 continue;
290 }
291
292 char *pszIndex = &szName[RT_ELEMENTS(g_szCommandPrefix) - 1];
293
294 uint32_t nIndex = RTStrToUInt32(pszIndex);
295 if (nIndex == 0)
296 {
297 LogFlowFunc(("skipped index %s\n",
298 szName));
299 continue;
300 }
301
302 /* Allocate with terminating nul after data. */
303 ACTIONENTRY *pEntry = (ACTIONENTRY *)RTMemAlloc(sizeof(ACTIONENTRY) + cbData);
304 if (!pEntry)
305 {
306 LogFlowFunc(("RTMemAlloc failed\n"));
307 bRet = FALSE;
308 break;
309 }
310
311 RT_ZERO(pEntry->nodeActionEntry);
312 pEntry->u32Index = nIndex;
313 memcpy(pEntry->wszCommandLine, abData, cbData);
314 pEntry->wszCommandLine[cbData / sizeof(WCHAR)] = 0;
315
316 /* Insert the new entry to the list. Sort by index. */
317 if (RTListIsEmpty(listActions))
318 {
319 RTListAppend(listActions, &pEntry->nodeActionEntry);
320 }
321 else
322 {
323 bool fAdded = false;
324 ACTIONENTRY *pIter = NULL;
325 RTListForEach(listActions, pIter, ACTIONENTRY, nodeActionEntry)
326 {
327 if (pIter->u32Index > nIndex)
328 {
329 RTListNodeInsertBefore(&pIter->nodeActionEntry, &pEntry->nodeActionEntry);
330 fAdded = true;
331 break;
332 }
333 }
334 if (!fAdded)
335 {
336 RTListAppend(listActions, &pEntry->nodeActionEntry);
337 }
338 }
339
340 LogFlowFunc(("added %d %ls\n",
341 pEntry->u32Index, pEntry->wszCommandLine));
342 }
343
344 RegCloseKey(hKey);
345
346#ifdef LOG_ENABLED
347 ACTIONENTRY *pIter = NULL;
348 RTListForEach(listActions, pIter, ACTIONENTRY, nodeActionEntry)
349 {
350 LogFlowFunc(("[%u]: [%ls]\n",
351 pIter->u32Index, pIter->wszCommandLine));
352 }
353#endif
354
355 if (!bRet)
356 {
357 ActionExecutorDeleteActions(listActions);
358 }
359
360 LogFlowFunc(("action enum %d\n",
361 bRet));
362
363 return bRet;
364}
365
366static void ActionExecutorExecuteActions(RTLISTANCHOR *listActions)
367{
368 LogFlowFunc(("ExecuteActions\n"));
369
370 ACTIONENTRY *pIter = NULL;
371 RTListForEach(listActions, pIter, ACTIONENTRY, nodeActionEntry)
372 {
373 LogFlowFunc(("[%u]: [%ls]\n",
374 pIter->u32Index, pIter->wszCommandLine));
375
376 STARTUPINFOW si;
377 PROCESS_INFORMATION pi;
378
379 GetStartupInfoW(&si);
380
381 if (!CreateProcessW(NULL, // lpApplicationName
382 pIter->wszCommandLine, // lpCommandLine
383 NULL, // lpProcessAttributes
384 NULL, // lpThreadAttributes
385 FALSE, // bInheritHandles
386 0, // dwCreationFlags
387 NULL, // lpEnvironment
388 NULL, // lpCurrentDirectory
389 &si, // lpStartupInfo
390 &pi)) // lpProcessInformation
391 {
392 LogFlowFunc(("Executing [%ls] failed, error %d\n",
393 pIter->wszCommandLine, GetLastError()));
394 }
395 else
396 {
397 LogFlowFunc(("Executing [%ls] succeeded\n",
398 pIter->wszCommandLine));
399
400 /* Don't care about waiting on the new process, so close these. */
401 CloseHandle(pi.hProcess);
402 CloseHandle(pi.hThread);
403 }
404 }
405
406 LogFlowFunc(("ExecuteActions leave\n"));
407}
408
409static BOOL GetVolatileEnvironmentKey(PVBOXLACONTEXT pCtx, WCHAR *pwszRegKey, DWORD cbRegKey)
410{
411 BOOL fFound = FALSE;
412
413 DWORD nSessionID;
414 LONG lErr;
415 HKEY hKey;
416 char szRegKey[REG_KEY_LEN];
417
418 /* Attempt to open HKCU\Volatile Environment\<session ID> first. */
419 if ( pCtx->pfnProcessIdToSessionId
420 && pCtx->pfnProcessIdToSessionId(GetCurrentProcessId(), &nSessionID))
421 {
422 RTStrPrintf(szRegKey, sizeof(szRegKey),
423 "%s\\%d",
424 g_pszVolatileEnvironment, nSessionID);
425
426 lErr = RegOpenKeyExA(HKEY_CURRENT_USER,
427 szRegKey,
428 0,
429 KEY_SET_VALUE,
430 &hKey);
431
432 if (lErr == ERROR_SUCCESS)
433 {
434 RegCloseKey(hKey);
435 fFound = TRUE;
436 }
437 }
438
439 if (!fFound)
440 {
441 /* Fall back to HKCU\Volatile Environment. */
442 RTStrPrintf(szRegKey, sizeof(szRegKey),
443 "%s",
444 g_pszVolatileEnvironment);
445
446 lErr = RegOpenKeyExA(HKEY_CURRENT_USER,
447 szRegKey,
448 0,
449 KEY_SET_VALUE,
450 &hKey);
451
452 if (lErr == ERROR_SUCCESS)
453 {
454 RegCloseKey(hKey);
455 fFound = TRUE;
456 }
457 }
458
459 if (fFound)
460 {
461 LogFlowFunc(("GetVolatileEnvironmentKey: [%s]\n", szRegKey));
462
463 /* Convert szRegKey to Utf16 string. */
464 PRTUTF16 putf16Unicode = pwszRegKey;
465 size_t cchUnicode = cbRegKey / sizeof(WCHAR);
466
467 int rc = RTStrToUtf16Ex(szRegKey, RTSTR_MAX,
468 &putf16Unicode, cchUnicode, NULL);
469 if (RT_FAILURE(rc))
470 {
471 LogFlowFunc(("RTStrToUtf16Ex failed %Rrc\n", rc));
472 fFound = FALSE;
473 }
474 else
475 {
476 LogFlowFunc(("unicode [%ls]\n", putf16Unicode));
477 }
478 }
479 else
480 {
481 LogFlowFunc(("GetVolatileEnvironmentKey: not found\n"));
482 }
483
484 return fFound;
485}
486
487static BOOL laGetUtcInfoClientName(PVBOXLACONTEXT pCtx, WCHAR *pwszClientName, DWORD cbClientName)
488{
489 LONG lErr;
490
491 WCHAR wszRegKey[REG_KEY_LEN];
492 if (!GetVolatileEnvironmentKey(pCtx, wszRegKey, sizeof(wszRegKey)))
493 {
494 return FALSE;
495 }
496
497 HKEY hKey;
498 lErr = RegOpenKeyExW(HKEY_CURRENT_USER,
499 wszRegKey,
500 0,
501 KEY_QUERY_VALUE,
502 &hKey);
503
504 if (lErr != ERROR_SUCCESS)
505 {
506 LogFlowFunc(("RegOpenKeyExW: failed [%ls]\n",
507 wszRegKey));
508 return FALSE;
509 }
510
511 DWORD nRegData;
512 DWORD dwType;
513 lErr = RegQueryValueExW(hKey,
514 g_pwszUTCINFOClientInfo[LA_UTCINFO_CLIENT_NAME],
515 NULL,
516 &dwType,
517 NULL,
518 &nRegData);
519
520 if (lErr != ERROR_SUCCESS)
521 {
522 LogFlowFunc(("RegQueryValueExW: failed [%ls]\n",
523 wszRegKey));
524 RegCloseKey(hKey);
525 return FALSE;
526 }
527
528 if (nRegData >= cbClientName)
529 {
530 LogFlowFunc(("buffer overflow reg %d, buffer %d, [%ls]\n",
531 nRegData, cbClientName, wszRegKey));
532 RegCloseKey(hKey);
533 return FALSE;
534 }
535
536 if (dwType != REG_SZ)
537 {
538 LogFlowFunc(("wrong type %d, [%ls]\n",
539 dwType, wszRegKey));
540 RegCloseKey(hKey);
541 return FALSE;
542 }
543
544 ZeroMemory(pwszClientName, cbClientName);
545
546 lErr = RegQueryValueExW(hKey,
547 g_pwszUTCINFOClientInfo[LA_UTCINFO_CLIENT_NAME],
548 NULL,
549 NULL,
550 (BYTE *)pwszClientName,
551 &nRegData);
552
553 RegCloseKey(hKey);
554
555 if (lErr != ERROR_SUCCESS)
556 {
557 return FALSE;
558 }
559
560 return TRUE;
561}
562
563static BOOL laSetClientName(PVBOXLACONTEXT pCtx, const WCHAR *pwszClientName)
564{
565 LONG lErr;
566
567 WCHAR wszRegKey[REG_KEY_LEN];
568 if (!GetVolatileEnvironmentKey(pCtx, wszRegKey, sizeof(wszRegKey)))
569 {
570 return FALSE;
571 }
572
573 HKEY hKey;
574 lErr = RegOpenKeyExW(HKEY_CURRENT_USER,
575 wszRegKey,
576 0,
577 KEY_SET_VALUE,
578 &hKey);
579
580 if (lErr != ERROR_SUCCESS)
581 {
582 return FALSE;
583 }
584
585 DWORD nClientName = (lstrlenW(pwszClientName) + 1) * sizeof(WCHAR);
586 lErr = RegSetValueExW(hKey,
587 g_pwszClientName,
588 0,
589 REG_SZ,
590 (BYTE*)pwszClientName,
591 nClientName);
592
593 RegCloseKey(hKey);
594
595 if (lErr != ERROR_SUCCESS)
596 {
597 return FALSE;
598 }
599
600 return TRUE;
601}
602
603static void laBroadcastSettingChange(void)
604{
605 DWORD_PTR dwResult;
606
607 if (SendMessageTimeoutA(HWND_BROADCAST,
608 WM_SETTINGCHANGE,
609 NULL,
610 (LPARAM)"Environment",
611 SMTO_ABORTIFHUNG,
612 5000,
613 &dwResult) == 0)
614 {
615 LogFlowFunc(("SendMessageTimeout failed, error %ld\n", GetLastError()));
616 }
617}
618
619static void laUpdateClientName(PVBOXLACONTEXT pCtx)
620{
621 WCHAR wszUtcInfoClientName[MAX_CLIENT_NAME_CHARS];
622
623 if (laGetUtcInfoClientName(pCtx, wszUtcInfoClientName, sizeof(wszUtcInfoClientName)))
624 {
625 if (laSetClientName(pCtx, wszUtcInfoClientName))
626 laBroadcastSettingChange();
627 }
628}
629
630static void laOnClientLocationInfo(PVBOXLACONTEXT pCtx, char *pszClientInfo[][2])
631{
632 /*
633 * Write the client location info to:
634 * HKCU\Volatile Environment\<CLIENT_LOCATION_INFO> or
635 * HKCU\Volatile Environment\<SessionID>\<CLIENT_LOCATION_INFO>
636 * depending on whether this is a Terminal Services or desktop session
637 * respectively.
638 * The client location info are: Name, IPAddr, Location, OtherInfo
639 */
640 unsigned int idx;
641 WCHAR wszRegKey[REG_KEY_LEN];
642 if (!GetVolatileEnvironmentKey(pCtx, wszRegKey, sizeof(wszRegKey)))
643 {
644 LogFlowFunc(("Failed to get 'Volatile Environment' registry key\n"));
645 return;
646 }
647
648 /* Now write the client name under the appropriate key. */
649 LONG lRet;
650 HKEY hKey;
651
652 lRet = RegOpenKeyExW(HKEY_CURRENT_USER,
653 wszRegKey,
654 0,
655 KEY_SET_VALUE,
656 &hKey);
657
658 if (lRet != ERROR_SUCCESS)
659 {
660 LogFlowFunc(("Failed to open key [%ls], error %lu\n", wszRegKey, lRet));
661 return;
662 }
663
664 PRTUTF16 putf16UnicodeClientInfo[LA_UTCINFO_CLIENT_INFO_LAST + 1] = {NULL};
665 for (idx = 0; idx <= LA_UTCINFO_CLIENT_INFO_LAST; idx++)
666 {
667 if (pszClientInfo[idx][LA_UTCINFO_PROP_VALUE] == NULL)
668 break;
669
670 /* pszClientInfo is UTF8, make an Unicode copy for registry. */
671 size_t cchUnicodeClientInfo = 0;
672
673 int rc = RTStrToUtf16Ex(pszClientInfo[idx][LA_UTCINFO_PROP_VALUE], MAX_CLIENT_NAME_CHARS,
674 &putf16UnicodeClientInfo[idx], 0, &cchUnicodeClientInfo);
675
676 if (RT_FAILURE(rc))
677 {
678 LogFlowFunc(("RTStrToUniEx failed %Rrc\n", rc));
679 break;
680 }
681
682 DWORD nDataLength = (DWORD)((cchUnicodeClientInfo + 1) * sizeof(WCHAR));
683 lRet = RegSetValueExW(hKey,
684 g_pwszUTCINFOClientInfo[idx],
685 0,
686 REG_SZ,
687 (BYTE *)putf16UnicodeClientInfo[idx],
688 nDataLength);
689
690 if (lRet != ERROR_SUCCESS)
691 {
692 LogFlowFunc(("RegSetValueExW failed error %lu for %s \n", lRet, g_pwszUTCINFOClientInfo[idx]));
693 }
694 }
695
696 RegCloseKey(hKey);
697
698 laBroadcastSettingChange();
699
700 /* Also, write these info (Name, IPAddr, Location and Other Info) to the environment of this process, as it
701 * doesn't listen for WM_SETTINGCHANGE messages.
702 */
703
704 for (idx = 0; idx <= LA_UTCINFO_CLIENT_INFO_LAST; idx++)
705 {
706 if (putf16UnicodeClientInfo[idx] == NULL)
707 break;
708
709 SetEnvironmentVariableW(g_pwszUTCINFOClientInfo[idx], putf16UnicodeClientInfo[idx]);
710
711 RTUtf16Free(putf16UnicodeClientInfo[idx]);
712 }
713}
714
715static void laDoAttach(PVBOXLACONTEXT pCtx)
716{
717 LogFlowFunc(("laDoAttach\n"));
718
719 /* Hardcoded action. */
720 laUpdateClientName(pCtx);
721
722 /* Process configured actions. */
723 ActionExecutorExecuteActions(&pCtx->listAttachActions);
724}
725
726static void laDoDetach(PVBOXLACONTEXT pCtx)
727{
728 LogFlowFunc(("laDoDetach\n"));
729
730 /* Process configured actions. */
731 ActionExecutorExecuteActions(&pCtx->listDetachActions);
732}
733
734static int laGetProperty(uint32_t u32GuestPropHandle, const char *pszName, uint64_t *pu64Timestamp, char **ppszValue)
735{
736 int rc = VINF_SUCCESS;
737
738 /* The buffer for storing the data and its initial size. We leave a bit
739 * of space here in case the maximum values are raised.
740 */
741 uint32_t cbBuf = 1024;
742 void *pvBuf = NULL;
743
744 /* Because there is a race condition between our reading the size of a
745 * property and the guest updating it, we loop a few times here and
746 * hope. Actually this should never go wrong, as we are generous
747 * enough with buffer space.
748 */
749 unsigned i;
750 for (i = 0; i < 3; ++i)
751 {
752 void *pvTmpBuf = RTMemRealloc(pvBuf, cbBuf);
753 if (pvTmpBuf == NULL)
754 {
755 rc = VERR_NO_MEMORY;
756 break;
757 }
758
759 pvBuf = pvTmpBuf;
760
761 rc = VbglR3GuestPropRead(u32GuestPropHandle, pszName, pvBuf, cbBuf,
762 NULL, pu64Timestamp, NULL,
763 &cbBuf);
764 if (rc != VERR_BUFFER_OVERFLOW)
765 {
766 break;
767 }
768
769 cbBuf += 1024;
770 }
771
772 if (RT_SUCCESS(rc))
773 {
774 LogFlowFunc(("laGetProperty: [%s]\n"
775 " value: [%s]\n"
776 " timestamp: %lld ns\n",
777 pszName, (char *)pvBuf, *pu64Timestamp));
778
779 *ppszValue = (char *)pvBuf;
780 }
781 else if (rc == VERR_NOT_FOUND)
782 {
783 LogFlowFunc(("laGetProperty: not found [%s]\n", pszName));
784 RTMemFree(pvBuf);
785 }
786 else
787 {
788 LogFlowFunc(("Failed to retrieve the property value, error %Rrc\n", rc));
789 RTMemFree(pvBuf);
790 }
791
792 return rc;
793}
794
795static int laWaitProperties(uint32_t u32GuestPropHandle,
796 const char *pszPatterns,
797 uint64_t u64LastTimestamp,
798 uint64_t *pu64Timestamp,
799 uint32_t u32Timeout)
800{
801 int rc = VINF_SUCCESS;
802
803 /* The buffer for storing the data and its initial size. We leave a bit
804 * of space here in case the maximum values are raised.
805 */
806 void *pvBuf = NULL;
807 uint32_t cbBuf = 4096;
808
809 /* Because there is a race condition between our reading the size of a
810 * property and the guest updating it, we loop a few times here and
811 * hope. Actually this should never go wrong, as we are generous
812 * enough with buffer space.
813 */
814 unsigned i;
815 for (i = 0; i < 3; ++i)
816 {
817 void *pvTmpBuf = RTMemRealloc(pvBuf, cbBuf);
818 if (NULL == pvTmpBuf)
819 {
820 rc = VERR_NO_MEMORY;
821 break;
822 }
823
824 pvBuf = pvTmpBuf;
825
826 rc = VbglR3GuestPropWait(u32GuestPropHandle, pszPatterns, pvBuf, cbBuf,
827 u64LastTimestamp, u32Timeout,
828 NULL /* ppszName */,
829 NULL /* ppszValue */,
830 pu64Timestamp,
831 NULL /* ppszFlags */,
832 &cbBuf);
833
834 if (rc != VERR_BUFFER_OVERFLOW)
835 break;
836
837 cbBuf += 1024;
838 }
839
840 RTMemFree(pvBuf);
841
842 return rc;
843}
844
845static int laGetUint32(uint32_t u32GuestPropHandle, const char *pszName, uint64_t *pu64Timestamp, uint32_t *pu32Value)
846{
847 uint64_t u64Timestamp = 0;
848 char *pszValue = NULL;
849
850 int rc = laGetProperty(u32GuestPropHandle,
851 pszName,
852 &u64Timestamp,
853 &pszValue);
854 if (RT_SUCCESS(rc))
855 {
856 if (pszValue && *pszValue)
857 {
858 uint32_t u32 = 0;
859 rc = RTStrToUInt32Full(pszValue, 10, &u32);
860
861 if (RT_SUCCESS(rc))
862 {
863 *pu64Timestamp = u64Timestamp;
864 *pu32Value = u32;
865 }
866 }
867 else
868 {
869 rc = VERR_NOT_SUPPORTED;
870 }
871 }
872
873 if (pszValue)
874 RTMemFree(pszValue);
875
876 LogFlowFunc(("laGetUint32: rc = %Rrc, [%s]\n", rc, pszName));
877 return rc;
878}
879
880static int laGetString(uint32_t u32GuestPropHandle, const char *pszName, uint64_t *pu64Timestamp, char **ppszValue)
881{
882 int rc = laGetProperty(u32GuestPropHandle,
883 pszName,
884 pu64Timestamp,
885 ppszValue);
886
887 LogFlowFunc(("laGetString: rc = %Rrc, [%s]\n", rc, pszName));
888 return rc;
889}
890
891static int laGetActiveClient(PVBOXLACONTEXT pCtx, uint64_t *pu64Timestamp, uint32_t *pu32Value)
892{
893 int rc = laGetUint32(pCtx->u32GuestPropHandle,
894 g_pszPropActiveClient,
895 pu64Timestamp,
896 pu32Value);
897
898 LogFlowFunc(("laGetActiveClient: rc %Rrc, %RU32, %RU64\n", rc, *pu32Value, *pu64Timestamp));
899 return rc;
900}
901
902static int laUpdateCurrentState(PVBOXLACONTEXT pCtx, uint32_t u32ActiveClientId, uint64_t u64ActiveClientTS)
903{
904 /* Prepare the current state for the active client.
905 * If u32ActiveClientId is 0, then there is no connected clients.
906 */
907 LogFlowFunc(("laUpdateCurrentState: %RU32 %RU64\n", u32ActiveClientId, u64ActiveClientTS));
908
909 int rc = VINF_SUCCESS;
910
911 int l;
912
913 char **pClientInfoMap[LA_UTCINFO_CLIENT_INFO_LAST + 1] =
914 {
915 &pCtx->activeClient.pszPropName,
916 &pCtx->activeClient.pszPropIPAddr,
917 &pCtx->activeClient.pszPropLocation,
918 &pCtx->activeClient.pszPropOtherInfo,
919 };
920
921 pCtx->activeClient.u32LastAttach = UINT32_MAX;
922 pCtx->activeClient.u64LastAttachTimestamp = u64ActiveClientTS;
923
924 if (pCtx->activeClient.pszLastName)
925 {
926 RTMemFree(pCtx->activeClient.pszLastName);
927 }
928 pCtx->activeClient.pszLastName = NULL;
929 pCtx->activeClient.u64LastNameTimestamp = u64ActiveClientTS;
930
931 unsigned int idx;
932
933 for (idx = 0; idx <= LA_UTCINFO_CLIENT_INFO_LAST; idx++)
934 {
935 if (*pClientInfoMap[idx])
936 {
937 RTMemFree(*pClientInfoMap[idx]);
938 *pClientInfoMap[idx] = NULL;
939 }
940
941 if (u32ActiveClientId != 0)
942 {
943 l = RTStrAPrintf(pClientInfoMap[idx],
944 g_pszPropInfoTemplates[idx],
945 u32ActiveClientId);
946
947 if (l == -1)
948 {
949 *pClientInfoMap[idx] = NULL;
950 rc = VERR_NO_MEMORY;
951 break;
952 }
953 }
954 }
955
956 if (RT_SUCCESS(rc))
957 {
958 if (pCtx->activeClient.pszPropAttach)
959 {
960 RTMemFree(pCtx->activeClient.pszPropAttach);
961 pCtx->activeClient.pszPropAttach = NULL;
962 }
963 if (u32ActiveClientId != 0)
964 {
965 l = RTStrAPrintf(&pCtx->activeClient.pszPropAttach,
966 g_pszPropAttachTemplate,
967 u32ActiveClientId);
968 if (l == -1)
969 {
970 pCtx->activeClient.pszPropAttach = NULL;
971 rc = VERR_NO_MEMORY;
972 }
973 }
974 }
975
976 if (RT_SUCCESS(rc))
977 {
978 if (pCtx->activeClient.pszPropWaitPattern)
979 {
980 RTMemFree(pCtx->activeClient.pszPropWaitPattern);
981 pCtx->activeClient.pszPropWaitPattern = NULL;
982 }
983 if (u32ActiveClientId != 0)
984 {
985 l = RTStrAPrintf(&pCtx->activeClient.pszPropWaitPattern,
986 "%s|%s|%s|%s|%s",
987 pCtx->activeClient.pszPropName,
988 pCtx->activeClient.pszPropAttach,
989 pCtx->activeClient.pszPropIPAddr,
990 pCtx->activeClient.pszPropLocation,
991 pCtx->activeClient.pszPropOtherInfo);
992 if (l == -1)
993 {
994 pCtx->activeClient.pszPropWaitPattern = NULL;
995 rc = VERR_NO_MEMORY;
996 }
997 }
998 }
999
1000 if (RT_SUCCESS(rc))
1001 {
1002 pCtx->activeClient.u32ClientId = u32ActiveClientId;
1003 }
1004 else
1005 {
1006 pCtx->activeClient.u32ClientId = 0;
1007 }
1008
1009 LogFlowFunc(("laUpdateCurrentState rc = %Rrc\n", rc));
1010 return rc;
1011}
1012
1013static int laWait(PVBOXLACONTEXT pCtx, uint64_t *pu64Timestamp, uint32_t u32Timeout)
1014{
1015 LogFlowFunc(("laWait [%s]\n", pCtx->activeClient.pszPropWaitPattern));
1016
1017 int rc = laWaitProperties(pCtx->u32GuestPropHandle,
1018 pCtx->activeClient.pszPropWaitPattern,
1019 pCtx->u64LastQuery,
1020 pu64Timestamp,
1021 u32Timeout);
1022
1023 LogFlowFunc(("laWait rc %Rrc\n", rc));
1024 return rc;
1025}
1026
1027static void laProcessClientInfo(PVBOXLACONTEXT pCtx)
1028{
1029 /* Check if the name was changed. */
1030 /* Get the name string and check if it was changed since last time.
1031 * Write Client name, IPAddr, Location and Other Info to the registry if the name has changed.
1032 */
1033 uint64_t u64Timestamp = 0;
1034 int rc = VINF_SUCCESS;
1035 unsigned int idx;
1036
1037 char *pClientInfoMap[][2] = {
1038 {pCtx->activeClient.pszPropName, NULL},
1039 {pCtx->activeClient.pszPropIPAddr, NULL},
1040 {pCtx->activeClient.pszPropLocation, NULL},
1041 {pCtx->activeClient.pszPropOtherInfo, NULL}
1042 };
1043
1044 for (idx = 0; idx <= LA_UTCINFO_CLIENT_INFO_LAST; idx++)
1045 {
1046 rc = laGetString(pCtx->u32GuestPropHandle,
1047 pClientInfoMap[idx][LA_UTCINFO_PROP_NAME],
1048 &u64Timestamp,
1049 &pClientInfoMap[idx][LA_UTCINFO_PROP_VALUE]);
1050
1051 LogFlowFunc(("laProcessClientInfo: read [%s], at %RU64\n",
1052 pClientInfoMap[idx][LA_UTCINFO_PROP_VALUE], u64Timestamp));
1053
1054 if (RT_FAILURE(rc))
1055 {
1056 LogFlowFunc(("laProcessClientInfo failed at %s\n", pClientInfoMap[idx][LA_UTCINFO_PROP_NAME]));
1057 break;
1058 }
1059 }
1060
1061 if (pClientInfoMap[LA_UTCINFO_CLIENT_NAME][LA_UTCINFO_PROP_VALUE] != NULL)
1062 {
1063 if (u64Timestamp != pCtx->activeClient.u64LastNameTimestamp)
1064 {
1065 laOnClientLocationInfo(pCtx, pClientInfoMap);
1066
1067 pCtx->activeClient.u64LastNameTimestamp = u64Timestamp;
1068 }
1069 }
1070
1071 for (idx = 0; idx <= LA_UTCINFO_CLIENT_INFO_LAST; idx++)
1072 {
1073 if (pClientInfoMap[idx][LA_UTCINFO_PROP_VALUE])
1074 {
1075 RTMemFree(pClientInfoMap[idx][LA_UTCINFO_PROP_VALUE]);
1076 }
1077 }
1078}
1079
1080static void laProcessAttach(PVBOXLACONTEXT pCtx)
1081{
1082 /* Check if the attach was changed. */
1083 pCtx->u32Action = LA_DO_NOTHING;
1084
1085 uint64_t u64Timestamp = 0;
1086 uint32_t u32Attach = UINT32_MAX;
1087
1088 int rc = laGetUint32(pCtx->u32GuestPropHandle,
1089 pCtx->activeClient.pszPropAttach,
1090 &u64Timestamp,
1091 &u32Attach);
1092
1093 if (RT_SUCCESS(rc))
1094 {
1095 LogFlowFunc(("laProcessAttach: read %RU32, at %RU64\n", u32Attach, u64Timestamp));
1096 if (u64Timestamp != pCtx->activeClient.u64LastAttachTimestamp)
1097 {
1098 if (u32Attach != pCtx->activeClient.u32LastAttach)
1099 {
1100 LogFlowFunc(("laProcessAttach: changed\n"));
1101
1102 /* Just do the last action. */
1103 pCtx->u32Action = u32Attach
1104 ? LA_DO_ATTACH : LA_DO_DETACH;
1105
1106 pCtx->activeClient.u32LastAttach = u32Attach;
1107 }
1108 else
1109 {
1110 LogFlowFunc(("laProcessAttach: same\n"));
1111
1112 /* The property has changed but the value is the same,
1113 * which means that it was changed and restored.
1114 */
1115 pCtx->u32Action = u32Attach
1116 ? LA_DO_DETACH_AND_ATTACH : LA_DO_ATTACH_AND_DETACH;
1117 }
1118
1119 pCtx->activeClient.u64LastAttachTimestamp = u64Timestamp;
1120 }
1121
1122 }
1123
1124 LogFlowFunc(("laProcessAttach: action %RU32\n", pCtx->u32Action));
1125}
1126
1127static void laDoActions(PVBOXLACONTEXT pCtx)
1128{
1129 /*
1130 * Check if the attach was changed.
1131 *
1132 * Caller assumes that this function will filter double actions.
1133 * That is two or more LA_DO_ATTACH will do just one LA_DO_ATTACH.
1134 */
1135 LogFlowFunc(("laDoActions: action %RU32, prev %RU32\n", pCtx->u32Action, pCtx->u32PrevAction));
1136
1137 switch(pCtx->u32Action)
1138 {
1139 case LA_DO_ATTACH:
1140 {
1141 if (pCtx->u32PrevAction != LA_DO_ATTACH)
1142 {
1143 pCtx->u32PrevAction = LA_DO_ATTACH;
1144 laDoAttach(pCtx);
1145 }
1146 } break;
1147
1148 case LA_DO_DETACH:
1149 {
1150 if (pCtx->u32PrevAction != LA_DO_DETACH)
1151 {
1152 pCtx->u32PrevAction = LA_DO_DETACH;
1153 laDoDetach(pCtx);
1154 }
1155 } break;
1156
1157 case LA_DO_DETACH_AND_ATTACH:
1158 {
1159 if (pCtx->u32PrevAction != LA_DO_DETACH)
1160 {
1161 pCtx->u32PrevAction = LA_DO_DETACH;
1162 laDoDetach(pCtx);
1163 }
1164 pCtx->u32PrevAction = LA_DO_ATTACH;
1165 laDoAttach(pCtx);
1166 } break;
1167
1168 case LA_DO_ATTACH_AND_DETACH:
1169 {
1170 if (pCtx->u32PrevAction != LA_DO_ATTACH)
1171 {
1172 pCtx->u32PrevAction = LA_DO_ATTACH;
1173 laDoAttach(pCtx);
1174 }
1175 pCtx->u32PrevAction = LA_DO_DETACH;
1176 laDoDetach(pCtx);
1177 } break;
1178
1179 case LA_DO_NOTHING:
1180 default:
1181 break;
1182 }
1183
1184 pCtx->u32Action = LA_DO_NOTHING;
1185
1186 LogFlowFunc(("laDoActions: leave\n"));
1187}
1188
1189DECLCALLBACK(int) VBoxLAInit(const PVBOXSERVICEENV pEnv, void **ppInstance)
1190{
1191 AssertPtrReturn(pEnv, VERR_INVALID_POINTER);
1192 AssertPtrReturn(ppInstance, VERR_INVALID_POINTER);
1193
1194 LogFlowFuncEnter();
1195
1196 PVBOXLACONTEXT pCtx = &g_Ctx; /* Only one instance at the moment. */
1197 AssertPtr(pCtx);
1198
1199 pCtx->pEnv = pEnv;
1200
1201 DWORD dwValue = 0;
1202 if ( laGetRegistryDWORD(L"SOFTWARE\\Oracle\\VirtualBox Guest Additions", L"VBoxTrayLog", &dwValue)
1203 && (dwValue & 0x10) != 0)
1204 {
1205 pCtx->fLogEnabled = true;
1206 }
1207 else
1208 {
1209 pCtx->fLogEnabled = false;
1210 }
1211
1212 /* DetachOnDisconnect is enabled by default. */
1213 dwValue = 0x02;
1214 if ( laGetRegistryDWORD(L"SOFTWARE\\Oracle\\VirtualBox Guest Additions", L"VBoxTrayLA", &dwValue)
1215 && (dwValue & 0x02) == 0)
1216 {
1217 pCtx->fDetachOnDisconnect = false;
1218 }
1219 else
1220 {
1221 pCtx->fDetachOnDisconnect = true;
1222 }
1223
1224 LogRel(("LA: DetachOnDisconnect=%RTbool\n", pCtx->fDetachOnDisconnect));
1225
1226 int rc = VbglR3GuestPropConnect(&pCtx->u32GuestPropHandle);
1227 if (RT_FAILURE(rc))
1228 return rc;
1229
1230 RTListInit(&pCtx->listAttachActions);
1231 RTListInit(&pCtx->listDetachActions);
1232
1233 RT_ZERO(pCtx->activeClient);
1234
1235 *(void **)&pCtx->pfnProcessIdToSessionId = RTLdrGetSystemSymbol("kernel32.dll", "ProcessIdToSessionId");
1236
1237 *ppInstance = pCtx;
1238 LogFlowFuncLeaveRC(VINF_SUCCESS);
1239 return VINF_SUCCESS;
1240}
1241
1242DECLCALLBACK(void) VBoxLADestroy(void *pInstance)
1243{
1244 AssertPtrReturnVoid(pInstance);
1245
1246 LogFlowFunc(("Destroying pInstance=%p\n", pInstance));
1247
1248 PVBOXLACONTEXT pCtx = (PVBOXLACONTEXT)pInstance;
1249 AssertPtr(pCtx);
1250
1251 if (pCtx->u32GuestPropHandle != 0)
1252 {
1253 VbglR3GuestPropDisconnect(pCtx->u32GuestPropHandle);
1254 }
1255
1256 ActionExecutorDeleteActions(&pCtx->listAttachActions);
1257 ActionExecutorDeleteActions(&pCtx->listDetachActions);
1258
1259 pCtx->pfnProcessIdToSessionId = NULL;
1260}
1261
1262/*
1263 * Thread function to wait for and process property changes
1264 */
1265DECLCALLBACK(int) VBoxLAWorker(void *pInstance, bool volatile *pfShutdown)
1266{
1267 AssertPtr(pInstance);
1268 LogFlowFunc(("pInstance=%p\n", pInstance));
1269
1270 /*
1271 * Tell the control thread that it can continue
1272 * spawning services.
1273 */
1274 RTThreadUserSignal(RTThreadSelf());
1275
1276 PVBOXLACONTEXT pCtx = (PVBOXLACONTEXT)pInstance;
1277
1278 /*
1279 * On name change event (/VirtualBox/HostInfo/VRDP/Client/%ID%/Name)
1280 * Store the name in the registry (HKCU\Volatile Environment\UTCINFO_CLIENTNAME).
1281 * On a client attach event (/VirtualBox/HostInfo/VRDP/Client/%ID%/Attach -> 1):
1282 * Execute ReconnectActions
1283 * On a client detach event (/VirtualBox/HostInfo/VRDP/Client/%ID%/Attach -> 0):
1284 * Execute DisconnectActions
1285 *
1286 * The active connected client id is /VirtualBox/HostInfo/VRDP/ActiveClientClient.
1287 */
1288
1289 if (!ActionExecutorEnumerateRegistryKey(g_pwszRegKeyReconnectActions, &pCtx->listAttachActions))
1290 {
1291 LogFlowFunc(("Can't enumerate registry key %ls\n", g_pwszRegKeyReconnectActions));
1292 }
1293 if (!ActionExecutorEnumerateRegistryKey(g_pwszRegKeyDisconnectActions, &pCtx->listDetachActions))
1294 {
1295 LogFlowFunc(("Can't enumerate registry key %ls\n", g_pwszRegKeyDisconnectActions));
1296 }
1297
1298 /* A non zero timestamp in the past. */
1299 pCtx->u64LastQuery = 1;
1300 /* Start at Detached state. */
1301 pCtx->u32PrevAction = LA_DO_DETACH;
1302
1303 int rc;
1304
1305 for (;;)
1306 {
1307 /* Query current ActiveClient.
1308 * if it differs from the current active client
1309 * rebuild the context;
1310 * wait with timeout for properties change since the active client was changed;
1311 * if 'Name' was changed
1312 * update the name;
1313 * if 'Attach' was changed
1314 * do respective actions.
1315 * remember the query timestamp;
1316 */
1317 uint64_t u64Timestamp = 0;
1318 uint32_t u32ActiveClientId = 0;
1319 rc = laGetActiveClient(pCtx, &u64Timestamp, &u32ActiveClientId);
1320
1321 if (RT_SUCCESS(rc))
1322 {
1323 bool fClientIdChanged = pCtx->activeClient.u32ClientId != u32ActiveClientId;
1324
1325 if (fClientIdChanged)
1326 {
1327 rc = laUpdateCurrentState(pCtx, u32ActiveClientId, u64Timestamp);
1328 }
1329
1330 if (RT_SUCCESS(rc))
1331 {
1332 if (pCtx->activeClient.u32ClientId != 0)
1333 {
1334 rc = laWait(pCtx, &u64Timestamp, 1000);
1335
1336 if (RT_SUCCESS(rc))
1337 {
1338 laProcessAttach(pCtx);
1339
1340 laProcessClientInfo(pCtx);
1341
1342 laDoActions(pCtx);
1343
1344 pCtx->u64LastQuery = u64Timestamp;
1345 }
1346 }
1347 else
1348 {
1349 /* If the client has been disconnected, do the detach actions. */
1350 if ( pCtx->fDetachOnDisconnect
1351 && fClientIdChanged)
1352 {
1353 LogFlowFunc(("Client disconnected\n"));
1354
1355 /* laDoActions will prevent a repeated detach action. So if there
1356 * was a detach already, then this detach will be ignored.
1357 */
1358 pCtx->u32Action = LA_DO_DETACH;
1359
1360 laDoActions(pCtx);
1361
1362 pCtx->u64LastQuery = u64Timestamp;
1363 }
1364 }
1365 }
1366 }
1367
1368 /*
1369 * Check if it is time to exit.
1370 * If the code above failed, wait a bit until repeating to avoid a loop.
1371 * Otherwise just check if the stop event was signalled.
1372 */
1373 RTMSINTERVAL msWait;
1374 if ( rc == VERR_NOT_FOUND
1375 || pCtx->activeClient.u32ClientId == 0)
1376 {
1377 /* No connections, wait longer. */
1378 msWait = 5000;
1379 rc = VINF_SUCCESS;
1380 }
1381 else if (RT_FAILURE(rc))
1382 {
1383 static int s_iBitchedAboutFailedGetActiveClient = 0;
1384 if (s_iBitchedAboutFailedGetActiveClient++ < 32)
1385 LogRel(("LA: Retrieving current client(s) failed with %Rrc\n", rc));
1386
1387 msWait = 10000;
1388 }
1389 else
1390 msWait = 0;
1391
1392 if (*pfShutdown)
1393 break;
1394
1395 if (msWait)
1396 RTThreadSleep(msWait);
1397 }
1398
1399 LogFlowFuncLeaveRC(rc);
1400 return rc;
1401}
1402
1403/**
1404 * The service description.
1405 */
1406VBOXSERVICEDESC g_SvcDescLA =
1407{
1408 /* pszName. */
1409 "LA",
1410 /* pszDescription. */
1411 "Location Awareness",
1412 /* methods */
1413 VBoxLAInit,
1414 VBoxLAWorker,
1415 NULL /* pfnStop */,
1416 VBoxLADestroy
1417};
1418
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