sidcache.c File Reference

#include "precomp.h"
#include <ntsecapi.h>
#include <debug.h>

Include dependency graph for sidcache.c:

Go to the source code of this file.

Classes
struct	_SIDCACHEMGR
struct	_SIDCACHECALLBACKINFO
struct	_SIDQUEUEENTRY
struct	_SIDCACHEENTRY

Macros
#define	NDEBUG
#define	HandleToScm(Handle)   (PSIDCACHEMGR)(Handle)
#define	ScmToHandle(Scm)   (HANDLE)(Scm)

Typedefs
typedef struct _SIDCACHEMGR	SIDCACHEMGR
typedef struct _SIDCACHEMGR *	PSIDCACHEMGR
typedef struct _SIDCACHECALLBACKINFO	SIDCACHECALLBACKINFO
typedef struct _SIDCACHECALLBACKINFO *	PSIDCACHECALLBACKINFO
typedef struct _SIDQUEUEENTRY	SIDQUEUEENTRY
typedef struct _SIDQUEUEENTRY *	PSIDQUEUEENTRY
typedef struct _SIDCACHEENTRY	SIDCACHEENTRY
typedef struct _SIDCACHEENTRY *	PSIDCACHEENTRY

Functions
static VOID	FreeQueueEntry (IN PSIDCACHEMGR scm, IN PSIDQUEUEENTRY QueueEntry)
static VOID	FreeCacheEntry (IN PSIDCACHEMGR scm, IN PSIDCACHEENTRY CacheEntry)
static VOID	CleanupSidCacheMgr (IN PSIDCACHEMGR scm)
static PSIDCACHEMGR	ReferenceSidCacheMgr (IN HANDLE SidCacheMgr)
static VOID	DereferenceSidCacheMgr (IN PSIDCACHEMGR scm)
static BOOL	OpenLSAPolicyHandle (IN LPWSTR SystemName, IN ACCESS_MASK DesiredAccess, OUT PLSA_HANDLE PolicyHandle)
static BOOL	LookupSidInformation (IN PSIDCACHEMGR scm, IN PSID pSid, OUT PSIDREQRESULT *ReqResult)
static BOOL	FindSidInCache (IN PSIDCACHEMGR scm, IN PSID pSid, OUT PSIDREQRESULT *ReqResult)
static VOID	CacheLookupResults (IN PSIDCACHEMGR scm, IN PSID pSid, IN PSIDREQRESULT ReqResult)
static DWORD WINAPI	LookupThreadProc (IN LPVOID lpParameter)
HANDLE	CreateSidCacheMgr (IN HANDLE Heap, IN LPCWSTR SystemName)
VOID	DestroySidCacheMgr (IN HANDLE SidCacheMgr)
static BOOL	QueueSidLookup (IN PSIDCACHEMGR scm, IN PSID pSid, IN PSIDREQCOMPLETIONPROC CompletionProc, IN PVOID Context)
VOID	DequeueSidLookup (IN HANDLE SidCacheMgr, IN PSID pSid)
VOID	ReferenceSidReqResult (IN HANDLE SidCacheMgr, IN PSIDREQRESULT ReqResult)
VOID	DereferenceSidReqResult (IN HANDLE SidCacheMgr, IN PSIDREQRESULT ReqResult)
BOOL	LookupSidCache (IN HANDLE SidCacheMgr, IN PSID pSid, IN PSIDREQCOMPLETIONPROC CompletionProc, IN PVOID Context)

Macro Definition Documentation

HandleToScm

#define HandleToScm

(

Handle

)

(PSIDCACHEMGR)(Handle)

Definition at line 36 of file sidcache.c.

NDEBUG

#define NDEBUG

Definition at line 33 of file sidcache.c.

ScmToHandle

#define ScmToHandle

(

Scm

)

(HANDLE)(Scm)

Definition at line 37 of file sidcache.c.

Typedef Documentation

PSIDCACHECALLBACKINFO

typedef struct _SIDCACHECALLBACKINFO * PSIDCACHECALLBACKINFO

PSIDCACHEENTRY

typedef struct _SIDCACHEENTRY * PSIDCACHEENTRY

PSIDCACHEMGR

typedef struct _SIDCACHEMGR * PSIDCACHEMGR

PSIDQUEUEENTRY

typedef struct _SIDQUEUEENTRY * PSIDQUEUEENTRY

SIDCACHECALLBACKINFO

typedef struct _SIDCACHECALLBACKINFO SIDCACHECALLBACKINFO

SIDCACHEENTRY

typedef struct _SIDCACHEENTRY SIDCACHEENTRY

SIDCACHEMGR

typedef struct _SIDCACHEMGR SIDCACHEMGR

SIDQUEUEENTRY

typedef struct _SIDQUEUEENTRY SIDQUEUEENTRY

Function Documentation

CacheLookupResults()

static VOID CacheLookupResults ( IN PSIDCACHEMGR  scm, IN PSID  pSid, IN PSIDREQRESULT  ReqResult  )

static

Definition at line 401 of file sidcache.c.

{
    PSIDCACHEENTRY CacheEntry;
    DWORD SidLen;
    SIZE_T AccountNameLen = 0;
    SIZE_T DomainNameLen = 0;
    SIZE_T CacheEntrySize = sizeof(SIDCACHEENTRY);
 
    /* NOTE: assumes the lists are locked! */
 
    SidLen = GetLengthSid(pSid);
    CacheEntrySize += SidLen;
 
    AccountNameLen = wcslen(ReqResult->AccountName);
    CacheEntrySize += (AccountNameLen + 1) * sizeof(WCHAR);
 
    DomainNameLen = wcslen(ReqResult->DomainName);
    CacheEntrySize += (wcslen(ReqResult->DomainName) + 1) * sizeof(WCHAR);
 
    CacheEntry = HeapAlloc(scm->Heap,
                           0,
                           CacheEntrySize);
    if (CacheEntry != NULL)
    {
        PWSTR lpBuf = (PWSTR)((ULONG_PTR)(CacheEntry + 1) + SidLen);
 
        CacheEntry->SidNameUse = ReqResult->SidNameUse;
 
        /* append the SID */
        CopySid(SidLen,
                (PSID)(CacheEntry + 1),
                pSid);
 
        /* append the strings */
        CacheEntry->AccountName = lpBuf;
        wcscpy(lpBuf,
               ReqResult->AccountName);
        lpBuf += AccountNameLen + 1;
 
        CacheEntry->DomainName = lpBuf;
        wcscpy(lpBuf,
               ReqResult->DomainName);
        lpBuf += DomainNameLen + 1;
 
        /* add the entry to the cache list */
        InsertTailList(&scm->CacheListHead,
                       &CacheEntry->ListEntry);
    }
}

Referenced by LookupSidCache(), and LookupThreadProc().

CleanupSidCacheMgr()

static VOID CleanupSidCacheMgr ( IN PSIDCACHEMGR  scm )

static

Definition at line 112 of file sidcache.c.

{
    LsaClose(scm->LsaHandle);
    CloseHandle(scm->LookupEvent);
    CloseHandle(scm->LookupThread);
 
    /* delete the queue */
    while (!IsListEmpty(&scm->QueueListHead))
    {
        PSIDQUEUEENTRY QueueEntry;
 
        QueueEntry = CONTAINING_RECORD(scm->QueueListHead.Flink,
                                       SIDQUEUEENTRY,
                                       ListEntry);
        FreeQueueEntry(scm,
                       QueueEntry);
    }
 
    /* delete the cache */
    while (!IsListEmpty(&scm->CacheListHead))
    {
        PSIDCACHEENTRY CacheEntry;
 
        CacheEntry = CONTAINING_RECORD(scm->CacheListHead.Flink,
                                       SIDCACHEENTRY,
                                       ListEntry);
        FreeCacheEntry(scm,
                       CacheEntry);
    }
 
    DeleteCriticalSection(&scm->Lock);
}

Referenced by LookupThreadProc().

CreateSidCacheMgr()

HANDLE CreateSidCacheMgr	(	IN HANDLE	Heap,
		IN LPCWSTR	SystemName
	)

Definition at line 596 of file sidcache.c.

{
    PSIDCACHEMGR scm;
 
    if (SystemName == NULL)
        SystemName = L"";
 
    scm = HeapAlloc(Heap,
                    0,
                    FIELD_OFFSET(SIDCACHEMGR,
                                 SystemName[wcslen(SystemName) + 1]));
    if (scm != NULL)
    {
        /* zero the static part of the structure */
        ZeroMemory(scm,
                   FIELD_OFFSET(SIDCACHEMGR,
                                SystemName));
 
        scm->RefCount = 1;
        scm->Heap = Heap;
 
        wcscpy(scm->SystemName,
               SystemName);
 
        InitializeCriticalSection(&scm->Lock);
        InitializeListHead(&scm->QueueListHead);
        InitializeListHead(&scm->CacheListHead);
 
        scm->LookupEvent = CreateEvent(NULL,
                                       FALSE,
                                       FALSE,
                                       NULL);
        if (scm->LookupEvent == NULL)
        {
            goto Cleanup;
        }
 
        if (!OpenLSAPolicyHandle(scm->SystemName,
                                 POLICY_LOOKUP_NAMES | POLICY_VIEW_LOCAL_INFORMATION,
                                 &scm->LsaHandle))
        {
            goto Cleanup;
        }
 
        scm->LookupThread = CreateThread(NULL,
                                         0,
                                         LookupThreadProc,
                                         scm,
                                         0,
                                         NULL);
        if (scm->LookupThread == NULL)
        {
Cleanup:
            if (scm->LookupEvent != NULL)
            {
                CloseHandle(scm->LookupEvent);
            }
 
            if (scm->LsaHandle != NULL)
            {
                LsaClose(scm->LsaHandle);
            }
 
            HeapFree(Heap,
                     0,
                     scm);
            scm = NULL;
        }
    }
    else
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
    }
 
    return (HANDLE)scm;
}

Referenced by CreateSecurityPage().

DequeueSidLookup()

VOID DequeueSidLookup	(	IN HANDLE	SidCacheMgr,
		IN PSID	pSid
	)

Definition at line 791 of file sidcache.c.

{
    PLIST_ENTRY CurrentEntry;
    PSIDQUEUEENTRY QueueEntry;
    PSIDCACHEMGR scm;
 
    scm = ReferenceSidCacheMgr(SidCacheMgr);
    if (scm != NULL)
    {
        EnterCriticalSection(&scm->Lock);
 
        if (scm->QueueLookingUp != NULL &&
            EqualSid(pSid,
                     (PSID)(scm->QueueLookingUp + 1)))
        {
            /* don't free the queue lookup item! this will be
               done in the lookup thread */
            scm->QueueLookingUp = NULL;
        }
        else
        {
            for (CurrentEntry = scm->QueueListHead.Flink;
                 CurrentEntry != &scm->QueueListHead;
                 CurrentEntry = CurrentEntry->Flink)
            {
                QueueEntry = CONTAINING_RECORD(CurrentEntry,
                                               SIDQUEUEENTRY,
                                               ListEntry);
 
                if (EqualSid(pSid,
                             (PSID)(QueueEntry + 1)))
                {
                    FreeQueueEntry(scm,
                                   QueueEntry);
                    break;
                }
            }
        }
 
        LeaveCriticalSection(&scm->Lock);
 
        DereferenceSidCacheMgr(scm);
    }
}

DereferenceSidCacheMgr()

static VOID DereferenceSidCacheMgr ( IN PSIDCACHEMGR  scm )

static

Definition at line 161 of file sidcache.c.

{
    if (InterlockedDecrement(&scm->RefCount) == 0)
    {
        /* Signal the lookup thread so it can terminate */
        SetEvent(scm->LookupEvent);
    }
}

Referenced by DequeueSidLookup(), DereferenceSidReqResult(), DestroySidCacheMgr(), LookupSidCache(), and ReferenceSidReqResult().

DereferenceSidReqResult()

VOID DereferenceSidReqResult	(	IN HANDLE	SidCacheMgr,
		IN PSIDREQRESULT	ReqResult
	)

Definition at line 855 of file sidcache.c.

{
    PSIDCACHEMGR scm;
 
    scm = ReferenceSidCacheMgr(SidCacheMgr);
    if (scm != NULL)
    {
        if (InterlockedDecrement(&ReqResult->RefCount) == 0)
        {
            HeapFree(scm->Heap,
                     0,
                     ReqResult);
        }
 
        DereferenceSidCacheMgr(scm);
    }
}

Referenced by FreePrincipalsList(), LookupSidCache(), LookupThreadProc(), and UpdatePrincipalListItem().

DestroySidCacheMgr()

VOID DestroySidCacheMgr

(

IN HANDLE

SidCacheMgr

)

Definition at line 676 of file sidcache.c.

{
    PSIDCACHEMGR scm = HandleToScm(SidCacheMgr);
 
    if (scm != NULL)
    {
        /* remove the keep-alive reference */
        DereferenceSidCacheMgr(scm);
    }
}

Referenced by CreateSecurityPage(), and DestroySecurityPage().

FindSidInCache()

static BOOL FindSidInCache ( IN PSIDCACHEMGR  scm, IN PSID  pSid, OUT PSIDREQRESULT *  ReqResult  )

static

Definition at line 336 of file sidcache.c.

{
    PSIDCACHEENTRY CacheEntry;
    PLIST_ENTRY CurrentEntry;
    PSIDREQRESULT ReqRes;
    BOOL Ret = FALSE;
 
    /* NOTE: assumes the lists are locked! */
 
    for (CurrentEntry = scm->CacheListHead.Flink;
         CurrentEntry != &scm->CacheListHead;
         CurrentEntry = CurrentEntry->Flink)
    {
        CacheEntry = CONTAINING_RECORD(CurrentEntry,
                                       SIDCACHEENTRY,
                                       ListEntry);
 
        if (EqualSid(pSid,
                     (PSID)(CacheEntry + 1)))
        {
            SIZE_T ReqResultSize;
            ULONG AccountNameLen, DomainNameLen;
 
            Ret = TRUE;
 
            AccountNameLen = wcslen(CacheEntry->AccountName);
            DomainNameLen = wcslen(CacheEntry->DomainName);
 
            ReqResultSize = sizeof(SIDREQRESULT) +
                                (((AccountNameLen + 1) +
                                  (DomainNameLen + 1)) * sizeof(WCHAR));
 
            ReqRes = HeapAlloc(scm->Heap,
                               0,
                               ReqResultSize);
            if (ReqRes != NULL)
            {
                PWSTR Buffer = (PWSTR)(ReqRes + 1);
 
                ReqRes->RefCount = 1;
 
                ReqRes->AccountName = Buffer;
                wcscpy(ReqRes->AccountName,
                       CacheEntry->AccountName);
                Buffer += AccountNameLen + 1;
 
                ReqRes->DomainName = Buffer;
                wcscpy(ReqRes->DomainName,
                       CacheEntry->DomainName);
            }
 
            /* return the result, even if we weren't unable to
               allocate enough memory! */
            *ReqResult = ReqRes;
            break;
        }
    }
 
    return Ret;
}

Referenced by LookupSidCache(), and LookupThreadProc().

FreeCacheEntry()

static VOID FreeCacheEntry ( IN PSIDCACHEMGR  scm, IN PSIDCACHEENTRY  CacheEntry  )

static

Definition at line 100 of file sidcache.c.

{
    RemoveEntryList(&CacheEntry->ListEntry);
 
    HeapFree(scm->Heap,
             0,
             CacheEntry);
}

Referenced by CleanupSidCacheMgr().

FreeQueueEntry()

static VOID FreeQueueEntry ( IN PSIDCACHEMGR  scm, IN PSIDQUEUEENTRY  QueueEntry  )

static

Definition at line 81 of file sidcache.c.

{
    if (QueueEntry->ListEntry.Flink != NULL)
    {
        RemoveEntryList(&QueueEntry->ListEntry);
    }
 
    HeapFree(scm->Heap,
             0,
             QueueEntry->Callbacks);
 
    HeapFree(scm->Heap,
             0,
             QueueEntry);
}

Referenced by CleanupSidCacheMgr(), DequeueSidLookup(), and LookupThreadProc().

LookupSidCache()

BOOL LookupSidCache	(	IN HANDLE	SidCacheMgr,
		IN PSID	pSid,
		IN PSIDREQCOMPLETIONPROC	CompletionProc,
		IN PVOID	Context
	)

Definition at line 876 of file sidcache.c.

{
    BOOL Found = FALSE;
    PSIDREQRESULT ReqResult = NULL;
    PSIDCACHEMGR scm;
 
    scm = ReferenceSidCacheMgr(SidCacheMgr);
    if (scm != NULL)
    {
        EnterCriticalSection(&scm->Lock);
 
        /* search the cache */
        Found = FindSidInCache(scm,
                               pSid,
                               &ReqResult);
 
        if (!Found)
        {
            /* the sid is not in the cache, queue it if not already queued */
            if (!QueueSidLookup(scm,
                                pSid,
                                CompletionProc,
                                Context))
            {
                PSIDREQRESULT FoundReqResult = NULL;
 
                /* unable to queue it, look it up now */
 
                LeaveCriticalSection(&scm->Lock);
 
                /* lookup everything we need */
                if (!LookupSidInformation(scm,
                                          pSid,
                                          &ReqResult))
                {
                    ReqResult = NULL;
                }
 
                EnterCriticalSection(&scm->Lock);
 
                /* see if the SID was added to the cache in the meanwhile */
                if (!FindSidInCache(scm,
                                    pSid,
                                    &FoundReqResult))
                {
                    if (ReqResult != NULL)
                    {
                        /* cache the results */
                        CacheLookupResults(scm,
                                           pSid,
                                           ReqResult);
                    }
                }
                else
                {
                    if (ReqResult != NULL)
                    {
                        /* free the information of our lookup and use the cached
                           information*/
                        DereferenceSidReqResult(scm,
                                                ReqResult);
                    }
 
                    ReqResult = FoundReqResult;
                }
 
                Found = (ReqResult != NULL);
            }
        }
 
        LeaveCriticalSection(&scm->Lock);
 
        /* call the completion callback */
        if (Found)
        {
            CompletionProc(SidCacheMgr,
                           pSid,
                           ReqResult,
                           Context);
 
            if (ReqResult != NULL)
            {
                HeapFree(scm->Heap,
                         0,
                         ReqResult);
            }
        }
 
        DereferenceSidCacheMgr(scm);
    }
 
    return Found;
}

Referenced by AddPrincipalToList(), and ReloadPrincipalsList().

LookupSidInformation()

static BOOL LookupSidInformation ( IN PSIDCACHEMGR  scm, IN PSID  pSid, OUT PSIDREQRESULT *  ReqResult  )

static

Definition at line 214 of file sidcache.c.

{
    PLSA_REFERENCED_DOMAIN_LIST ReferencedDomain;
    PLSA_TRANSLATED_NAME Names;
    PLSA_TRUST_INFORMATION Domain;
    PLSA_UNICODE_STRING DomainName;
    SID_NAME_USE SidNameUse = SidTypeUnknown;
    PPOLICY_ACCOUNT_DOMAIN_INFO PolicyAccountDomainInfo = NULL;
    NTSTATUS Status;
    DWORD AccountNameSize, DomainNameSize = 0;
    PSIDREQRESULT ReqRet = NULL;
    BOOL Ret = FALSE;
 
    Status = LsaLookupSids(scm->LsaHandle,
                           1,
                           &pSid,
                           &ReferencedDomain,
                           &Names);
    if (NT_SUCCESS(Status))
    {
        SidNameUse = Names->Use;
 
        if (ReferencedDomain != NULL &&
            Names->DomainIndex >= 0)
        {
            Domain = &ReferencedDomain->Domains[Names->DomainIndex];
            DomainName = &Domain->Name;
        }
        else
        {
            Domain = NULL;
            DomainName = NULL;
        }
 
        switch (SidNameUse)
        {
            case SidTypeAlias:
            {
                if (Domain != NULL)
                {
                    /* query the domain name for BUILTIN accounts */
                    Status = LsaQueryInformationPolicy(scm->LsaHandle,
                                                       PolicyAccountDomainInformation,
                                                       (PVOID*)&PolicyAccountDomainInfo);
                    if (NT_SUCCESS(Status))
                    {
                        DomainName = &PolicyAccountDomainInfo->DomainName;
 
                        /* make the user believe this is a group */
                        SidNameUse = (PolicyAccountDomainInfo != NULL ? SidTypeGroup : SidTypeUser);
                    }
                }
                break;
            }
 
            default:
            {
                DPRINT("Unhandled SID type: 0x%x\n", Names->Use);
                break;
            }
        }
 
        AccountNameSize = Names->Name.Length;
        if (DomainName != NULL)
        {
            DomainNameSize = DomainName->Length;
        }
 
        ReqRet = HeapAlloc(scm->Heap,
                           0,
                           sizeof(SIDREQRESULT) +
                               (((AccountNameSize + DomainNameSize) + 2) * sizeof(WCHAR)));
        if (ReqRet != NULL)
        {
            ReqRet->RefCount = 1;
            ReqRet->AccountName = (LPWSTR)(ReqRet + 1);
            ReqRet->DomainName = ReqRet->AccountName + (AccountNameSize / sizeof(WCHAR)) + 1;
 
            CopyMemory(ReqRet->AccountName,
                       Names->Name.Buffer,
                       Names->Name.Length);
 
            if (DomainName != NULL)
            {
                CopyMemory(ReqRet->DomainName,
                           DomainName->Buffer,
                           DomainName->Length);
            }
 
            ReqRet->AccountName[AccountNameSize / sizeof(WCHAR)] = L'\0';
            ReqRet->DomainName[DomainNameSize / sizeof(WCHAR)] = L'\0';
 
            ReqRet->SidNameUse = SidNameUse;
        }
 
        if (PolicyAccountDomainInfo != NULL)
        {
            LsaFreeMemory(PolicyAccountDomainInfo);
        }
 
        LsaFreeMemory(ReferencedDomain);
        LsaFreeMemory(Names);
 
        Ret = TRUE;
    }
    else if (Status == STATUS_NONE_MAPPED)
    {
        Ret = TRUE;
    }
 
    if (Ret)
    {
        *ReqResult = ReqRet;
    }
 
    return Ret;
}

Referenced by LookupSidCache(), and LookupThreadProc().

LookupThreadProc()

static DWORD WINAPI LookupThreadProc ( IN LPVOID  lpParameter )

static

Definition at line 455 of file sidcache.c.

{
    HMODULE hModule;
    PSIDCACHEMGR scm = (PSIDCACHEMGR)lpParameter;
 
    /* Reference the dll to avoid problems in case of accidental
       FreeLibrary calls... */
    if (!GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
                            (LPCWSTR)hDllInstance,
                            &hModule))
    {
        hModule = NULL;
    }
 
    while (scm->RefCount != 0)
    {
        PSIDQUEUEENTRY QueueEntry = NULL;
 
        EnterCriticalSection(&scm->Lock);
 
        /* get the first item of the queue */
        if (scm->QueueListHead.Flink != &scm->QueueListHead)
        {
            QueueEntry = CONTAINING_RECORD(scm->QueueListHead.Flink,
                                           SIDQUEUEENTRY,
                                           ListEntry);
            RemoveEntryList(&QueueEntry->ListEntry);
            QueueEntry->ListEntry.Flink = NULL;
        }
        else
        {
            LeaveCriticalSection(&scm->Lock);
 
            /* wait for the next asynchronous lookup queued */
            WaitForSingleObject(scm->LookupEvent,
                                INFINITE);
            continue;
        }
 
        scm->QueueLookingUp = QueueEntry;
 
        LeaveCriticalSection(&scm->Lock);
 
        if (QueueEntry != NULL)
        {
            PSIDREQRESULT ReqResult, FoundReqResult;
            PSID pSid = (PSID)(QueueEntry + 1);
 
            /* lookup the SID information */
            if (!LookupSidInformation(scm,
                                      pSid,
                                      &ReqResult))
            {
                ReqResult = NULL;
            }
 
            EnterCriticalSection(&scm->Lock);
 
            /* see if the SID was added to the cache in the meanwhile */
            if (!FindSidInCache(scm,
                                pSid,
                                &FoundReqResult))
            {
                if (ReqResult != NULL)
                {
                    /* cache the results */
                    CacheLookupResults(scm,
                                       pSid,
                                       ReqResult);
                }
            }
            else
            {
                if (ReqResult != NULL)
                {
                    /* free the information of our lookup and use the cached
                       information*/
                    DereferenceSidReqResult(scm,
                                            ReqResult);
                }
 
                ReqResult = FoundReqResult;
            }
 
            /* notify the callers unless the lookup was cancelled */
            if (scm->QueueLookingUp != NULL)
            {
                ULONG i = 0;
 
                while (scm->QueueLookingUp != NULL &&
                       i < QueueEntry->CallbackCount)
                {
                    PVOID Context;
                    PSIDREQCOMPLETIONPROC CompletionProc;
 
                    Context = QueueEntry->Callbacks[i].Context;
                    CompletionProc = QueueEntry->Callbacks[i].CompletionProc;
 
                    LeaveCriticalSection(&scm->Lock);
 
                    /* call the completion proc without holding the lock! */
                    CompletionProc(ScmToHandle(scm),
                                   pSid,
                                   ReqResult,
                                   Context);
 
                    EnterCriticalSection(&scm->Lock);
 
                    i++;
                }
 
                scm->QueueLookingUp = NULL;
            }
 
            LeaveCriticalSection(&scm->Lock);
 
            /* free the queue item */
            FreeQueueEntry(scm,
                           QueueEntry);
        }
    }
 
    CleanupSidCacheMgr(scm);
 
    HeapFree(scm->Heap,
             0,
             scm);
 
    if (hModule != NULL)
    {
        /* dereference the library and exit */
        FreeLibraryAndExitThread(hModule,
                                 0);
    }
 
    return 0;
}

Referenced by CreateSidCacheMgr().

OpenLSAPolicyHandle()

static BOOL OpenLSAPolicyHandle ( IN LPWSTR  SystemName, IN ACCESS_MASK  DesiredAccess, OUT PLSA_HANDLE  PolicyHandle  )

static

Definition at line 172 of file sidcache.c.

{
    LSA_OBJECT_ATTRIBUTES LsaObjectAttributes = {0};
    LSA_UNICODE_STRING LsaSystemName, *psn;
    NTSTATUS Status;
    SIZE_T NameLength;
 
    if (SystemName != NULL && SystemName[0] != L'\0')
    {
        NameLength = wcslen(SystemName);
        if (NameLength > UNICODE_STRING_MAX_CHARS)
        {
            return FALSE;
        }
 
        LsaSystemName.Buffer = SystemName;
        LsaSystemName.Length = NameLength * sizeof(WCHAR);
        LsaSystemName.MaximumLength = LsaSystemName.Length + sizeof(WCHAR);
        psn = &LsaSystemName;
    }
    else
    {
        psn = NULL;
    }
 
    Status = LsaOpenPolicy(psn,
                           &LsaObjectAttributes,
                           DesiredAccess,
                           PolicyHandle);
    if (!NT_SUCCESS(Status))
    {
        SetLastError(LsaNtStatusToWinError(Status));
        return FALSE;
    }
 
    return TRUE;
}

Referenced by CreateSidCacheMgr().

QueueSidLookup()

static BOOL QueueSidLookup ( IN PSIDCACHEMGR  scm, IN PSID  pSid, IN PSIDREQCOMPLETIONPROC  CompletionProc, IN PVOID  Context  )

static

Definition at line 689 of file sidcache.c.

{
    PLIST_ENTRY CurrentEntry;
    PSIDQUEUEENTRY QueueEntry, FoundEntry = NULL;
    BOOL Ret = FALSE;
 
    /* NOTE: assumes the lists are locked! */
 
    if (scm->QueueLookingUp != NULL &&
        EqualSid(pSid,
                 (PSID)(scm->QueueLookingUp + 1)))
    {
        FoundEntry = scm->QueueLookingUp;
    }
    else
    {
        for (CurrentEntry = scm->QueueListHead.Flink;
             CurrentEntry != &scm->QueueListHead;
             CurrentEntry = CurrentEntry->Flink)
        {
            QueueEntry = CONTAINING_RECORD(CurrentEntry,
                                           SIDQUEUEENTRY,
                                           ListEntry);
 
            if (EqualSid(pSid,
                         (PSID)(QueueEntry + 1)))
            {
                FoundEntry = QueueEntry;
                break;
            }
        }
    }
 
    if (FoundEntry == NULL)
    {
        DWORD SidLength = GetLengthSid(pSid);
 
        FoundEntry = HeapAlloc(scm->Heap,
                               0,
                               sizeof(SIDQUEUEENTRY) + SidLength);
        if (FoundEntry != NULL)
        {
            CopySid(SidLength,
                    (PSID)(FoundEntry + 1),
                    pSid);
 
            FoundEntry->CallbackCount = 1;
            FoundEntry->Callbacks = HeapAlloc(scm->Heap,
                                              0,
                                              sizeof(SIDCACHECALLBACKINFO));
 
            if (FoundEntry->Callbacks != NULL)
            {
                FoundEntry->Callbacks[0].CompletionProc = CompletionProc;
                FoundEntry->Callbacks[0].Context = Context;
 
                /* append it to the queue */
                InsertTailList(&scm->QueueListHead,
                               &FoundEntry->ListEntry);
 
                /* signal the lookup event */
                SetEvent(scm->LookupEvent);
 
                Ret = TRUE;
            }
            else
            {
                /* unable to queue it because we couldn't allocate the callbacks
                   array, free the memory and return */
                HeapFree(scm->Heap,
                         0,
                         FoundEntry);
            }
        }
    }
    else
    {
        PSIDCACHECALLBACKINFO Sidccb;
 
        /* add the callback */
        Sidccb = HeapReAlloc(scm->Heap,
                             0,
                             FoundEntry->Callbacks,
                             (FoundEntry->CallbackCount + 1) * sizeof(SIDCACHECALLBACKINFO));
        if (Sidccb != NULL)
        {
            FoundEntry->Callbacks = Sidccb;
            FoundEntry->Callbacks[FoundEntry->CallbackCount].CompletionProc = CompletionProc;
            FoundEntry->Callbacks[FoundEntry->CallbackCount++].Context = Context;
 
            Ret = TRUE;
        }
    }
 
    return Ret;
}

Referenced by LookupSidCache().

ReferenceSidCacheMgr()

static PSIDCACHEMGR ReferenceSidCacheMgr ( IN HANDLE  SidCacheMgr )

static

Definition at line 147 of file sidcache.c.

{
    PSIDCACHEMGR scm = HandleToScm(SidCacheMgr);
 
    if (InterlockedIncrement(&scm->RefCount) != 1)
    {
        return scm;
    }
 
    return NULL;
}

Referenced by DequeueSidLookup(), DereferenceSidReqResult(), LookupSidCache(), and ReferenceSidReqResult().

ReferenceSidReqResult()

VOID ReferenceSidReqResult	(	IN HANDLE	SidCacheMgr,
		IN PSIDREQRESULT	ReqResult
	)

Definition at line 839 of file sidcache.c.

{
    PSIDCACHEMGR scm;
 
    scm = ReferenceSidCacheMgr(SidCacheMgr);
    if (scm != NULL)
    {
        InterlockedIncrement(&ReqResult->RefCount);
 
        DereferenceSidCacheMgr(scm);
    }
}

Referenced by UpdatePrincipalListItem().