的Win32等价的getuid（）的

Question

我在的Linux移植一个C++库到Windows的过程中，我与的getuid（）有问题，这是不支持Windows。

任何想法我可以在它的地方使用？

Answer 1

可以检索与当前线程与GetUserName相关联的用户名：

// ANSI version  
string GetWindowsUserNameA() 
    { 
     char buffer[UNLEN + 1] = {0}; 
     DWORD buffer_len = UNLEN + 1; 
     if (!::GetUserNameA(buffer, & buffer_len)) 
     { 
      // error handling 
     } 

     return string(buffer); 
    } 

Answer 2

在DOTNET的

- Environment.UserName

Answer 3

退房微软对与Interix (also known as Services for UNIX 3.0)库移植建议。虽然你想要的东西过于夸张。

Answer 4

Windows的最接近一个UID当量为（可能是）一个SID。 GetUserName，然后LookupAccountName应该让你的用户的SID。

Answer 5

在Windows equivilent实际上是用户的SID。您可以通过使用“GetTokenInformation”调用并查询TokenUser信息类来获得此信息。

要调用GetTokenInformation，你需要一个句柄用户令牌，您可以通过调用OpenProcessToken（或OpenThreadToken如果你是假冒他人）获得。

Answer 6

合适的API是SHGetUID（），从壳牌

Answer 7

出口这是我想出了。

#include <stdint.h> 
#include <stdlib.h> 
#include <Windows.h> 
#include <sddl.h> 

#include <iostream> 
#include <iomanip> 
#include <memory> 

struct heap_delete 
{ 
    typedef LPVOID pointer; 
    void operator()(LPVOID p) 
    { 
     ::HeapFree(::GetProcessHeap(), 0, p); 
    } 
}; 
typedef std::unique_ptr<LPVOID, heap_delete> heap_unique_ptr; 

struct handle_delete 
{ 
    typedef HANDLE pointer; 
    void operator()(HANDLE p) 
    { 
     ::CloseHandle(p); 
    } 
}; 
typedef std::unique_ptr<HANDLE, handle_delete> handle_unique_ptr; 

typedef uint32_t uid_t; 

BOOL GetUserSID(HANDLE token, PSID* sid) 
{ 
    if (
     token == nullptr || token == INVALID_HANDLE_VALUE 
     || sid == nullptr 
     ) 
    { 
     SetLastError(ERROR_INVALID_PARAMETER); 
     return FALSE; 
    } 
    DWORD tokenInformationLength = 0; 
    ::GetTokenInformation(
     token, TokenUser, nullptr, 0, &tokenInformationLength); 
    if(GetLastError() != ERROR_INSUFFICIENT_BUFFER) 
    { 
     return FALSE; 
    } 
    heap_unique_ptr data(
     ::HeapAlloc(
      ::GetProcessHeap(), HEAP_ZERO_MEMORY,  
      tokenInformationLength)); 
    if (data.get() == nullptr) 
    { 
     return FALSE; 
    } 
    BOOL getTokenInfo = ::GetTokenInformation(
     token, TokenUser, data.get(), 
     tokenInformationLength, &tokenInformationLength); 
    if (! getTokenInfo) 
    { 
     return FALSE; 
    } 
    PTOKEN_USER pTokenUser = (PTOKEN_USER)(data.get()); 
    DWORD sidLength = ::GetLengthSid(pTokenUser->User.Sid); 
    heap_unique_ptr sidPtr(
     ::HeapAlloc(
      GetProcessHeap(), HEAP_ZERO_MEMORY, sidLength)); 
    PSID sidL = (PSID)(sidPtr.get()); 
    if (sidL == nullptr) 
    { 
     return FALSE; 
    } 
    BOOL copySid = ::CopySid(sidLength, sidL, pTokenUser->User.Sid); 
    if (! copySid) 
    { 
     return FALSE; 
    } 
    if (!IsValidSid(sidL)) 
    { 
     return FALSE; 
    } 
    *sid = sidL; 
    sidPtr.release(); 
    return TRUE; 
} 

uid_t GetUID(HANDLE token) 
{ 
    PSID sid = nullptr; 
    BOOL getSID = GetUserSID(token, &sid); 
    if (! getSID || ! sid) 
    { 
     return -1; 
    } 
    heap_unique_ptr sidPtr((LPVOID)(sid)); 
    LPWSTR stringSid = nullptr; 
    BOOL convertSid = ::ConvertSidToStringSidW(
     sid, &stringSid); 
    if (! convertSid) 
    { 
     return -1; 
    } 
    uid_t ret = -1; 
    LPCWSTR p = ::wcsrchr(stringSid, L'-'); 
    if (p && ::iswdigit(p[1])) 
    { 
     ++p; 
     ret = ::_wtoi(p); 
    } 
    ::LocalFree(stringSid); 
    return ret; 
} 

uid_t getuid() 
{ 
    HANDLE process = ::GetCurrentProcess(); 
    handle_unique_ptr processPtr(process); 
    HANDLE token = nullptr; 
    BOOL openToken = ::OpenProcessToken(
     process, TOKEN_READ|TOKEN_QUERY_SOURCE, &token); 
    if (! openToken) 
    { 
     return -1; 
    } 
    handle_unique_ptr tokenPtr(token); 
    uid_t ret = GetUID(token); 
    return ret; 
} 

uid_t geteuid() 
{ 
    HANDLE process = ::GetCurrentProcess(); 
    HANDLE thread = ::GetCurrentThread(); 
    HANDLE token = nullptr; 
    BOOL openToken = ::OpenThreadToken(
     thread, TOKEN_READ|TOKEN_QUERY_SOURCE, FALSE, &token); 
    if (! openToken && ::GetLastError() == ERROR_NO_TOKEN) 
    { 
     openToken = ::OpenThreadToken(
      thread, TOKEN_READ|TOKEN_QUERY_SOURCE, TRUE, &token); 
     if (! openToken && ::GetLastError() == ERROR_NO_TOKEN) 
     { 
      openToken = ::OpenProcessToken(
       process, TOKEN_READ|TOKEN_QUERY_SOURCE, &token); 
     } 
    } 
    if (! openToken) 
    { 
     return -1; 
    } 
    handle_unique_ptr tokenPtr(token); 
    uid_t ret = GetUID(token); 
    return ret; 
} 

int main() 
{ 
    uid_t uid = getuid(); 
    uid_t euid = geteuid(); 
    std::cout 
     << "uid: " << std::setbase(10) << uid << std::endl 
     << "euid: " << std::setbase(10) << euid << std::endl 
     << std::endl; 
    return EXIT_SUCCESS; 
} 

请注意，由Larry Osterman给出的答案是非常有帮助的。这让我开始了正确的方向。