Changeset 26083 in vbox for trunk/src/VBox/Additions/common

Timestamp:

Jan 28, 2010 1:53:51 PM (15 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

57036

Message:

VBoxService: Improved modularity for process information lookup; rewritten a couple of things.

Location:

trunk/src/VBox/Additions/common/VBoxService

Files:

• VBoxServiceInternal.h (modified) (3 diffs)
• VBoxServiceVMInfo-win.cpp (modified) (6 diffs)
• VBoxServiceVMInfo.cpp (modified) (2 diffs)

trunk/src/VBox/Additions/common/VBoxService/VBoxServiceInternal.h

@@ -27 +27 @@
 # include <Windows.h>
 # include <process.h> /* Needed for file version information. */
+# include <Ntsecapi.h> /* Needed for process security information. */
 #endif
 
@@ -115 +116 @@
     char *pszFileName;
 } VBOXSERVICEVMINFOFILE, *PVBOXSERVICEVMINFOFILE;
+/** Structure for process information lookup. */
+typedef struct
+{
+    DWORD id; 
+    LUID luid;
+} VBOXSERVICEVMINFOPROC, *PVBOXSERVICEVMINFOPROC;
 /** Function prototypes for dynamic loading. */
 typedef DWORD (WINAPI* fnWTSGetActiveConsoleSessionId)();
@@ -152 +159 @@
 extern BOOL VBoxServiceWinSetStatus(DWORD dwStatus, DWORD dwCheckPoint);
 # ifdef VBOX_WITH_GUEST_PROPS
+/** Determines the total count of processes attach to a logon session. */
+extern DWORD VBoxServiceVMInfoWinSessionGetProcessCount(PLUID pSession,
+                                                        PVBOXSERVICEVMINFOPROC pProc, DWORD dwProcCount);
 /** Detects wheter a user is logged on based on the enumerated processes. */
-extern BOOL VBoxServiceVMInfoWinIsLoggedIn(VBOXSERVICEVMINFOUSER *a_pUserInfo,
-                                           PLUID a_pSession,
-                                           PLUID a_pLuid,
-                                           DWORD a_dwNumOfProcLUIDs);
-/** Gets logon user IDs from enumerated processes. */
-extern DWORD VBoxServiceVMInfoWinGetLUIDsFromProcesses(PLUID *ppLuid);
+extern BOOL VBoxServiceVMInfoWinIsLoggedIn(PVBOXSERVICEVMINFOUSER a_pUserInfo,
+                                           PLUID a_pSession);
+/** Gets logon user IDs from enumerated processes. ppProc needs to be freed with VBoxServiceVMInfoWinProcessesFree() afterwards. */
+extern int VBoxServiceVMInfoWinProcessesEnumerate(PVBOXSERVICEVMINFOPROC *ppProc, DWORD *pdwCount);
+/** Frees the process structure allocated by VBoxServiceVMInfoWinProcessesEnumerate() before. */
+extern void VBoxServiceVMInfoWinProcessesFree(PVBOXSERVICEVMINFOPROC pProc);
 # endif /* VBOX_WITH_GUEST_PROPS */
 #endif /* RT_OS_WINDOWS */

trunk/src/VBox/Additions/common/VBoxService/VBoxServiceVMInfo-win.cpp

@@ -25 +25 @@
 *******************************************************************************/
 #include <windows.h>
-#include <Ntsecapi.h>
 #include <wtsapi32.h>       /* For WTS* calls. */
 #include <psapi.h>          /* EnumProcesses. */
@@ -53 +52 @@
 
 #ifndef TARGET_NT4
-/* Function GetLUIDsFromProcesses() written by Stefan Kuhr. */
-DWORD VBoxServiceVMInfoWinGetLUIDsFromProcesses(PLUID *ppLuid)
-{
-    DWORD dwSize, dwSize2, dwIndex ;
-    LPDWORD lpdwPIDs ;
-    DWORD dwLastError = ERROR_SUCCESS;
-
-    if (!ppLuid)
-    {
-        SetLastError(ERROR_INVALID_PARAMETER);
-        return 0L;
-    }
-
-    /* Call the PSAPI function EnumProcesses to get all of the
-       ProcID's currently in the system.
-       NOTE: In the documentation, the third parameter of
-       EnumProcesses is named cbNeeded, which implies that you
-       can call the function once to find out how much space to
-       allocate for a buffer and again to fill the buffer.
-       This is not the case. The cbNeeded parameter returns
-       the number of PIDs returned, so if your buffer size is
-       zero cbNeeded returns zero.
-       NOTE: The "HeapAlloc" loop here ensures that we
-       actually allocate a buffer large enough for all the
-       PIDs in the system. */
-    dwSize2 = 256 * sizeof(DWORD);
-
-    lpdwPIDs = NULL;
+int VBoxServiceVMInfoWinProcessesGetTokenInfo(PVBOXSERVICEVMINFOPROC pProc, 
+                                              TOKEN_INFORMATION_CLASS tkClass)
+{
+    AssertPtr(pProc);
+    HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pProc->id);
+    if (h == NULL)
+        return RTErrConvertFromWin32(GetLastError());
+
+     HANDLE hToken;
+     int rc;
+     if (FALSE == OpenProcessToken(h, TOKEN_QUERY, &hToken))
+     {
+         rc = RTErrConvertFromWin32(GetLastError());
+     }
+     else
+     {
+         void *pvTokenInfo = NULL;
+         DWORD dwTokenInfoSize;
+         switch (tkClass)
+         {
+         case TokenStatistics:
+             dwTokenInfoSize = sizeof(TOKEN_STATISTICS);
+             pvTokenInfo = (TOKEN_STATISTICS*)RTMemAlloc(dwTokenInfoSize);
+             AssertPtr(pvTokenInfo);
+             break;
+
+         /** @todo Implement more token classes here. */
+
+         default:
+             VBoxServiceError("Token class not implemented: %ld", tkClass);
+             break;
+         }
+
+         if (pvTokenInfo)
+         {     
+             DWORD dwRetLength;
+             if (FALSE == GetTokenInformation(hToken, tkClass, pvTokenInfo, dwTokenInfoSize, &dwRetLength))
+             {
+                 rc = RTErrConvertFromWin32(GetLastError());
+             }
+             else
+             {
+                 switch (tkClass)
+                 {
+                 case TokenStatistics:
+                     {
+                         TOKEN_STATISTICS *pStats = (TOKEN_STATISTICS*)pvTokenInfo;
+                         AssertPtr(pStats);
+                         pProc->luid = pStats->AuthenticationId;
+                         /* @todo Add more information of TOKEN_STATISTICS as needed. */
+                         break;
+                     }
+
+                 default:
+                     /* Should never get here! */
+                     break;                
+                 }
+                 rc = VINF_SUCCESS;
+             }
+             RTMemFree(pvTokenInfo);
+         }
+         CloseHandle(hToken);
+    }   
+    CloseHandle(h);
+    return rc;
+}
+
+int VBoxServiceVMInfoWinProcessesEnumerate(PVBOXSERVICEVMINFOPROC *ppProc, DWORD *pdwCount)
+{
+    AssertPtr(ppProc);
+    AssertPtr(pdwCount);
+
+    DWORD dwSize = 256; /* Number of processes our array can hold */
+    DWORD *pdwProcIDs = (DWORD*)RTMemAlloc(dwSize * sizeof(DWORD));
+    if (pdwProcIDs == NULL)
+        return VERR_NO_MEMORY;
+
+    int rc;
+    DWORD dwNeeded;
     do
     {
-        if (lpdwPIDs)
-        {
-            HeapFree(GetProcessHeap(), 0, lpdwPIDs) ;
-            dwSize2 *= 2;
-        }
-        lpdwPIDs = (unsigned long *)HeapAlloc(GetProcessHeap(), 0, dwSize2);
-        if (lpdwPIDs == NULL)
-            return 0L; // Last error will be that of HeapAlloc
-
-        if (!EnumProcesses( lpdwPIDs, dwSize2, &dwSize))
-        {
-            DWORD dw = GetLastError();
-            HeapFree(GetProcessHeap(), 0, lpdwPIDs);
-            SetLastError(dw);
-            return 0L;
-        }
-    }
-    while (dwSize == dwSize2);
-
-    /* At this point we have an array of the PIDs at the
-       time of the last EnumProcesses invocation. We will
-       allocate an array of LUIDs passed back via the out
-       param ppLuid of exactly the number of PIDs. We will
-       only fill the first n values of this array, with n
-       being the number of unique LUIDs found in these PIDs. */
-
-    /* How many ProcIDs did we get? */
-    dwSize /= sizeof(DWORD);
-    dwSize2 = 0L; /* Our return value of found luids. */
-
-    *ppLuid = (LUID *)LocalAlloc(LPTR, dwSize*sizeof(LUID));
-    if (!(*ppLuid))
-    {
-        dwLastError = GetLastError();
-        goto CLEANUP;
-    }
-    for (dwIndex = 0; dwIndex < dwSize; dwIndex++)
-    {
-        (*ppLuid)[dwIndex].LowPart =0L;
-        (*ppLuid)[dwIndex].HighPart=0;
-
-        /* Open the process (if we can... security does not
-           permit every process in the system). */
-        HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION,FALSE, lpdwPIDs[dwIndex]);
-        if ( hProcess != NULL )
-        {
-            HANDLE hAccessToken;
-            if (OpenProcessToken(hProcess, TOKEN_QUERY, &hAccessToken))
+        if (FALSE == EnumProcesses(pdwProcIDs, dwSize * sizeof(DWORD), &dwNeeded))
+        {
+            rc = RTErrConvertFromWin32(GetLastError());
+            break;
+        }
+
+        /* Was our array big enough? Or do we need more space? */
+        if (dwNeeded >= dwSize)
+        {
+            /* Apparently not, so try next bigger size */
+            dwSize += 256;
+            pdwProcIDs = (DWORD*)RTMemRealloc(pdwProcIDs, dwSize * sizeof(DWORD));
+            if (pdwProcIDs == NULL)
             {
-                TOKEN_STATISTICS ts;
-                DWORD dwSize;
-                if (GetTokenInformation(hAccessToken, TokenStatistics, &ts, sizeof ts, &dwSize))
+                rc = VERR_NO_MEMORY;
+                break;
+            }
+        }
+        else
+        {
+            rc = VINF_SUCCESS;
+            break;
+        }
+    } while(dwNeeded >= dwSize);
+
+    if (RT_SUCCESS(rc))
+    {
+        /* Allocate our process structure */
+        *ppProc = (PVBOXSERVICEVMINFOPROC)RTMemAlloc(dwNeeded * sizeof(VBOXSERVICEVMINFOPROC));
+        if (ppProc == NULL)
+            rc = VERR_NO_MEMORY;
+
+        if (RT_SUCCESS(rc))
+        {
+            /* We now have the PIDs, fill them into the struct and lookup their LUID's */
+            PVBOXSERVICEVMINFOPROC pCur = *ppProc;
+            DWORD *pCurProcID = pdwProcIDs;
+            for (DWORD i=0; i<dwNeeded; i++)
+            {
+                RT_BZERO(pCur, sizeof(VBOXSERVICEVMINFOPROC));
+                pCur->id = *pCurProcID;
+                rc = VBoxServiceVMInfoWinProcessesGetTokenInfo(pCur, TokenStatistics);
+                if (RT_FAILURE(rc))
                 {
-                    DWORD dwTmp = 0L;
-                    BOOL bFound = FALSE;
-                    for (;dwTmp<dwSize2 && !bFound;dwTmp++)
-                        bFound = (*ppLuid)[dwTmp].HighPart == ts.AuthenticationId.HighPart &&
-                                 (*ppLuid)[dwTmp].LowPart == ts.AuthenticationId.LowPart;
-
-                    if (!bFound)
-                        (*ppLuid)[dwSize2++] = ts.AuthenticationId;
+                    /* Because some processes cannot be opened/parsed on Windows, we should not consider to
+                       be this an error here. */
+                    rc = VINF_SUCCESS;
                 }
-                CloseHandle(hAccessToken);
+                pCur++;
+                pCurProcID++;
             }
-
-            CloseHandle(hProcess);
-        }
-
-        /* We don't really care if OpenProcess or OpenProcessToken fail or succeed, because
-           there are quite a number of system processes we cannot open anyway, not even as SYSTEM. */
-    }
-
-    CLEANUP:
-
-    if (lpdwPIDs)
-        HeapFree(GetProcessHeap(), 0, lpdwPIDs);
-
-    if (ERROR_SUCCESS !=dwLastError)
-        SetLastError(dwLastError);
-
-    return dwSize2;
-}
-
-BOOL VBoxServiceVMInfoWinIsLoggedIn(VBOXSERVICEVMINFOUSER* a_pUserInfo,
-                                    PLUID a_pSession,
-                                    PLUID a_pLuid,
-                                    DWORD a_dwNumOfProcLUIDs)
-{
-    BOOL bLoggedIn = FALSE;
+            /* Save number of processes */
+            *pdwCount = dwNeeded;
+        }
+    }
+
+    RTMemFree(pdwProcIDs);
+    if (RT_FAILURE(rc))
+        VBoxServiceVMInfoWinProcessesFree(*ppProc);
+    return rc;
+}
+
+void VBoxServiceVMInfoWinProcessesFree(PVBOXSERVICEVMINFOPROC pProc)
+{
+    if (pProc != NULL)
+    {
+        RTMemFree(pProc);
+        pProc = NULL;
+    }
+}
+
+DWORD VBoxServiceVMInfoWinSessionGetProcessCount(PLUID pSession,
+                                                 PVBOXSERVICEVMINFOPROC pProc, DWORD dwProcCount)
+{
+    AssertPtr(pSession);
+
+    if (dwProcCount <= 0) /* To be on the safe side. */
+        return 0;
+    AssertPtr(pProc);
+
+    PSECURITY_LOGON_SESSION_DATA pSessionData = NULL;
+    if (STATUS_SUCCESS != LsaGetLogonSessionData (pSession, &pSessionData))
+    {
+        VBoxServiceError("Could not get logon session data! rc=%Rrc", RTErrConvertFromWin32(GetLastError()));
+        return 0;
+    }
+    AssertPtr(pSessionData);
+
+    /* Even if a user seems to be logged in, it could be a stale/orphaned logon session.
+     * So check if we have some processes bound to it by comparing the session <-> process LUIDs. */
+    PVBOXSERVICEVMINFOPROC pCur = pProc;
+    for (DWORD i=0; i<dwProcCount; i++)
+    {
+        /*VBoxServiceVerbose(3, "%ld:%ld <-> %ld:%ld\n",
+                           pCur->luid.HighPart, pCur->luid.LowPart,
+                           pSessionData->LogonId.HighPart, pSessionData->LogonId.LowPart);*/
+        if (   pCur->luid.HighPart == pSessionData->LogonId.HighPart
+            && pCur->luid.LowPart  == pSessionData->LogonId.LowPart)
+        {
+            VBoxServiceVerbose(3, "Users: Session %ld:%ld has active processes\n",
+                               pSessionData->LogonId.HighPart, pSessionData->LogonId.LowPart);
+            LsaFreeReturnBuffer(pSessionData);
+            return 1;
+        }          
+        pCur++;
+    }
+    LsaFreeReturnBuffer(pSessionData);
+    return 0;
+}
+
+BOOL VBoxServiceVMInfoWinIsLoggedIn(PVBOXSERVICEVMINFOUSER a_pUserInfo,
+                                    PLUID a_pSession)
+{
     BOOL bFoundUser = FALSE;
     PSECURITY_LOGON_SESSION_DATA sessionData = NULL;
@@ -181 +255 @@
         return FALSE;
 
-    r = LsaGetLogonSessionData (a_pSession, &sessionData);
+    r = LsaGetLogonSessionData(a_pSession, &sessionData);
     if (r != STATUS_SUCCESS)
     {
@@ -199 +273 @@
 
     VBoxServiceVerbose(3, "Users: Session data: Name = %ls, Len = %d, SID = %s, LogonID = %d,%d\n",
-        (sessionData->UserName).Buffer, (sessionData->UserName).Length, (sessionData->Sid != NULL) ? "1" : "0", sessionData->LogonId.HighPart, sessionData->LogonId.LowPart);
+        (sessionData->UserName).Buffer, 
+        (sessionData->UserName).Length, 
+        (sessionData->Sid != NULL) ? "1" : "0", sessionData->LogonId.HighPart, sessionData->LogonId.LowPart);
 
     if ((sessionData->UserName.Buffer != NULL) &&
@@ -305 +381 @@
                     if (pBuffer)
                         WTSFreeMemory(pBuffer);
-
-                    /* A user logged in, but it could be a stale/orphaned logon session. */
-                    BOOL bFoundInLUIDs = FALSE;
-                    for (DWORD dwIndex = 0; dwIndex < a_dwNumOfProcLUIDs; dwIndex++)
-                    {
-                        if (   (a_pLuid[dwIndex].HighPart == sessionData->LogonId.HighPart)
-                            && (a_pLuid[dwIndex].LowPart == sessionData->LogonId.LowPart))
-                        {
-                            bLoggedIn = TRUE;
-                            VBoxServiceVerbose(3, "User \"%ls\" is logged in!\n", a_pUserInfo->szUser);
-                            break;
-                        }
-                    }
                 }
             }
@@ -324 +387 @@
 
     LsaFreeReturnBuffer(sessionData);
-    return bLoggedIn;
-}
-
+    return bFoundUser;
+}
 #endif /* TARGET_NT4 */
 

trunk/src/VBox/Additions/common/VBoxService/VBoxServiceVMInfo.cpp

@@ -221 +221 @@
         }
 
-        PLUID pLuid = NULL;
-        DWORD dwNumOfProcLUIDs = VBoxServiceVMInfoWinGetLUIDsFromProcesses(&pLuid);
-
-        for (int i = 0; i<(int)ulCount; i++)
-        {
-            VBOXSERVICEVMINFOUSER userInfo;
-            ZeroMemory (&userInfo, sizeof(VBOXSERVICEVMINFOUSER));
-
-            if (VBoxServiceVMInfoWinIsLoggedIn(&userInfo, &pSessions[i], pLuid, dwNumOfProcLUIDs))
+        PVBOXSERVICEVMINFOPROC pProcs;
+        DWORD dwNumProcs;
+        rc = VBoxServiceVMInfoWinProcessesEnumerate(&pProcs, &dwNumProcs);
+
+        VBOXSERVICEVMINFOUSER userInfo;
+        ZeroMemory (&userInfo, sizeof(VBOXSERVICEVMINFOUSER));
+
+        for (ULONG i=0; i<ulCount; i++)
+        {
+            if (   VBoxServiceVMInfoWinIsLoggedIn(&userInfo, &pSessions[i])
+                && VBoxServiceVMInfoWinSessionGetProcessCount(&pSessions[i], pProcs, dwNumProcs) > 0)
             {
                 if (uiUserCount > 0)
@@ -242 +244 @@
         }
 
-        if (NULL != pLuid)
-            ::LocalFree (pLuid);
-
+        VBoxServiceVMInfoWinProcessesFree(pProcs);
         ::LsaFreeReturnBuffer(pSessions);
 # endif /* TARGET_NT4 */