aclui.c File Reference

#include "precomp.h"
#include <sddl.h>
#include <debug.h>
#include "resource.h"

Include dependency graph for aclui.c:

Go to the source code of this file.

Classes
struct	_SIDLOOKUPNOTIFYINFO

Macros
#define	NDEBUG
#define	SIDN_LOOKUPSUCCEEDED   (0x101)

Typedefs
typedef struct _SIDLOOKUPNOTIFYINFO	SIDLOOKUPNOTIFYINFO
typedef struct _SIDLOOKUPNOTIFYINFO *	PSIDLOOKUPNOTIFYINFO

Functions
static PSID	AceHeaderToSID (IN PACE_HEADER AceHeader)
static VOID	DestroySecurityPage (IN PSECURITY_PAGE sp)
static VOID	FreePrincipalsList (IN PSECURITY_PAGE sp, IN PPRINCIPAL_LISTITEM *PrincipalsListHead)
static PACE_ENTRY	AddAceToPrincipal (IN PPRINCIPAL_LISTITEM Principal, IN PACE_HEADER AceHeader)
static PPRINCIPAL_LISTITEM	FindSidInPrincipalsListAddAce (IN PPRINCIPAL_LISTITEM PrincipalsListHead, IN PSID Sid, IN PACE_HEADER AceHeader)
static VOID	SidLookupCompletion (IN HANDLE SidCacheMgr, IN PSID Sid, IN PSIDREQRESULT SidRequestResult, IN PVOID Context)
static PPRINCIPAL_LISTITEM	AddPrincipalToList (IN PSECURITY_PAGE sp, IN PSID Sid, IN PACE_HEADER AceHeader, OUT BOOL *LookupDeferred OPTIONAL)
static LPWSTR	GetDisplayStringFromSidRequestResult (IN PSIDREQRESULT SidReqResult)
static LPWSTR	GetPrincipalDisplayString (IN PPRINCIPAL_LISTITEM PrincipalListItem)
static LPWSTR	GetPrincipalAccountNameString (IN PPRINCIPAL_LISTITEM PrincipalListItem)
static VOID	CreatePrincipalListItem (OUT LVITEM *li, IN PSECURITY_PAGE sp, IN PPRINCIPAL_LISTITEM PrincipalListItem, IN INT Index, IN BOOL Selected)
static INT	AddPrincipalListEntry (IN PSECURITY_PAGE sp, IN PPRINCIPAL_LISTITEM PrincipalListItem, IN INT Index, IN BOOL Selected)
static int CALLBACK	PrincipalCompare (IN LPARAM lParam1, IN LPARAM lParam2, IN LPARAM lParamSort)
static VOID	UpdatePrincipalListItem (IN PSECURITY_PAGE sp, IN INT PrincipalIndex, IN PPRINCIPAL_LISTITEM PrincipalListItem, IN PSIDREQRESULT SidReqResult)
static VOID	ReloadPrincipalsList (IN PSECURITY_PAGE sp)
static VOID	UpdateControlStates (IN PSECURITY_PAGE sp)
static void	UpdatePrincipalInfo (IN PSECURITY_PAGE sp, IN PSIDLOOKUPNOTIFYINFO LookupInfo)
static UINT CALLBACK	SecurityPageCallback (IN HWND hwnd, IN UINT uMsg, IN LPPROPSHEETPAGE ppsp)
static VOID	SetAceCheckListColumns (IN HWND hAceCheckList, IN UINT Button, IN HWND hLabel)
static VOID	LoadPermissionsList (IN PSECURITY_PAGE sp, IN GUID *GuidObjectType, IN DWORD dwFlags, OUT SI_ACCESS *DefaultAccess)
static VOID	ResizeControls (IN PSECURITY_PAGE sp, IN INT Width, IN INT Height)
static PACE_HEADER	BuildDefaultPrincipalAce (IN PSECURITY_PAGE sp, IN PSID pSid)
static BOOL	AddSelectedPrincipal (IN IDsObjectPicker *pDsObjectPicker, IN HWND hwndParent OPTIONAL, IN PSID pSid, IN PVOID Context OPTIONAL)
static INT_PTR CALLBACK	SecurityPageProc (IN HWND hwndDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
HPROPSHEETPAGE WINAPI	CreateSecurityPage (IN LPSECURITYINFO psi)
BOOL WINAPI	EditSecurity (IN HWND hwndOwner, IN LPSECURITYINFO psi)
BOOL WINAPI	DllMain (IN HINSTANCE hinstDLL, IN DWORD dwReason, IN LPVOID lpvReserved)

Variables
HINSTANCE	hDllInstance

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 33 of file aclui.c.

SIDN_LOOKUPSUCCEEDED

#define SIDN_LOOKUPSUCCEEDED   (0x101)

Definition at line 40 of file aclui.c.

Typedef Documentation

PSIDLOOKUPNOTIFYINFO

typedef struct _SIDLOOKUPNOTIFYINFO * PSIDLOOKUPNOTIFYINFO

SIDLOOKUPNOTIFYINFO

typedef struct _SIDLOOKUPNOTIFYINFO SIDLOOKUPNOTIFYINFO

Function Documentation

AceHeaderToSID()

static PSID AceHeaderToSID ( IN PACE_HEADER  AceHeader )

static

Definition at line 49 of file aclui.c.

{
    PSID Sid = NULL;
    switch (AceHeader->AceType)
    {
        case ACCESS_ALLOWED_ACE_TYPE:
            Sid = (PSID)&((PACCESS_ALLOWED_ACE)AceHeader)->SidStart;
            break;
#if 0
        case ACCESS_ALLOWED_CALLBACK_ACE_TYPE:
            Sid = (PSID)&((PACCESS_ALLOWED_CALLBACK_ACE)AceHeader)->SidStart;
            break;
        case ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE:
            Sid = (PSID)&((PACCESS_ALLOWED_CALLBACK_OBJECT_ACE)AceHeader)->SidStart;
            break;
#endif
        case ACCESS_ALLOWED_OBJECT_ACE_TYPE:
            Sid = (PSID)&((PACCESS_ALLOWED_OBJECT_ACE)AceHeader)->SidStart;
            break;
        case ACCESS_DENIED_ACE_TYPE:
            Sid = (PSID)&((PACCESS_DENIED_ACE)AceHeader)->SidStart;
            break;
#if 0
        case ACCESS_DENIED_CALLBACK_ACE_TYPE:
            Sid = (PSID)&((PACCESS_DENIED_CALLBACK_ACE)AceHeader)->SidStart;
            break;
        case ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE:
            Sid = (PSID)&((PACCESS_DENIED_CALLBACK_OBJECT_ACE)AceHeader)->SidStart;
            break;
#endif
        case SYSTEM_AUDIT_OBJECT_ACE_TYPE:
            Sid = (PSID)&((PACCESS_DENIED_OBJECT_ACE)AceHeader)->SidStart;
            break;
    }

    return Sid;
}

Referenced by ReloadPrincipalsList().

AddAceToPrincipal()

static PACE_ENTRY AddAceToPrincipal ( IN PPRINCIPAL_LISTITEM  Principal, IN PACE_HEADER  AceHeader  )

static

Definition at line 152 of file aclui.c.

{
    PACE_ENTRY AceEntry, *AceLink;

    AceEntry = HeapAlloc(GetProcessHeap(),
                         0,
                         sizeof(ACE_ENTRY) + AceHeader->AceSize);
    if (AceEntry != NULL)
    {
        AceEntry->Next = NULL;

        /* copy the ACE */
        CopyMemory(AceEntry + 1,
                   AceHeader,
                   AceHeader->AceSize);

        /* append it to the list */
        AceLink = &Principal->ACEs;
        while (*AceLink != NULL)
        {
            AceLink = &(*AceLink)->Next;
        }
        *AceLink = AceEntry;
    }

    return AceEntry;
}

Referenced by FindSidInPrincipalsListAddAce().

AddPrincipalListEntry()

static INT AddPrincipalListEntry ( IN PSECURITY_PAGE  sp, IN PPRINCIPAL_LISTITEM  PrincipalListItem, IN INT  Index, IN BOOL  Selected  )

static

Definition at line 419 of file aclui.c.

{
    LVITEM li;
    INT Ret;

    if (PrincipalListItem->DisplayString != NULL)
    {
        LocalFree((HLOCAL)PrincipalListItem->DisplayString);
    }
    PrincipalListItem->DisplayString = GetPrincipalDisplayString(PrincipalListItem);

    CreatePrincipalListItem(&li,
                            sp,
                            PrincipalListItem,
                            Index,
                            Selected);

    Ret = ListView_InsertItem(sp->hWndPrincipalsList,
                              &li);

    return Ret;
}

Referenced by AddSelectedPrincipal(), ReloadPrincipalsList(), and UpdatePrincipalInfo().

AddPrincipalToList()

static PPRINCIPAL_LISTITEM AddPrincipalToList ( IN PSECURITY_PAGE  sp, IN PSID  Sid, IN PACE_HEADER  AceHeader, OUT BOOL *LookupDeferred  OPTIONAL  )

static

Definition at line 239 of file aclui.c.

{
    PPRINCIPAL_LISTITEM PrincipalListItem = NULL, *PrincipalLink;
    PACE_ENTRY AceEntry;
    BOOL Deferred = FALSE;

    if (!FindSidInPrincipalsListAddAce(sp->PrincipalsListHead,
                                       Sid,
                                       AceHeader))
    {
        DWORD SidLength;

        PrincipalLink = &sp->PrincipalsListHead;
        while (*PrincipalLink != NULL)
        {
            PrincipalLink = &(*PrincipalLink)->Next;
        }

        SidLength = GetLengthSid(Sid);

        /* allocate the principal */
        PrincipalListItem = HeapAlloc(GetProcessHeap(),
                                      0,
                                      sizeof(PRINCIPAL_LISTITEM) + SidLength);
        if (PrincipalListItem != NULL)
        {
            PrincipalListItem->DisplayString = NULL;
            PrincipalListItem->SidReqResult = NULL;

            CopySid(SidLength,
                    (PSID)(PrincipalListItem + 1),
                    Sid);

            /* allocate some memory for the ACE and copy it */
            AceEntry = HeapAlloc(GetProcessHeap(),
                                 0,
                                 sizeof(ACE_ENTRY) + AceHeader->AceSize);
            if (AceEntry != NULL)
            {
                AceEntry->Next = NULL;
                CopyMemory(AceEntry + 1,
                           AceHeader,
                           AceHeader->AceSize);

                /* add the ACE to the list */
                PrincipalListItem->ACEs = AceEntry;

                PrincipalListItem->Next = NULL;

                /* append item to the principals list */
                *PrincipalLink = PrincipalListItem;

                /* lookup the SID now */
                Deferred = !LookupSidCache(sp->SidCacheMgr,
                                           Sid,
                                           SidLookupCompletion,
                                           sp);
            }
            else
            {
                HeapFree(GetProcessHeap(),
                         0,
                         PrincipalListItem);
                PrincipalListItem = NULL;
            }
        }
    }

    if (PrincipalListItem != NULL && LookupDeferred != NULL)
    {
        *LookupDeferred = Deferred;
    }

    return PrincipalListItem;
}

Referenced by AddSelectedPrincipal(), and ReloadPrincipalsList().

AddSelectedPrincipal()

static BOOL AddSelectedPrincipal ( IN IDsObjectPicker *  pDsObjectPicker, IN HWND hwndParent  OPTIONAL, IN PSID  pSid, IN PVOID Context  OPTIONAL  )

static

Definition at line 1200 of file aclui.c.

{
    PACE_HEADER AceHeader;
    PSECURITY_PAGE sp = (PSECURITY_PAGE)Context;

    AceHeader = BuildDefaultPrincipalAce(sp,
                                         pSid);
    if (AceHeader != NULL)
    {
        PPRINCIPAL_LISTITEM PrincipalListItem;
        BOOL LookupDeferred;

        PrincipalListItem = AddPrincipalToList(sp,
                                               pSid,
                                               AceHeader,
                                               &LookupDeferred);

        if (PrincipalListItem != NULL && LookupDeferred)
        {
            AddPrincipalListEntry(sp,
                                  PrincipalListItem,
                                  -1,
                                  FALSE);
        }

        HeapFree(GetProcessHeap(),
                 0,
                 AceHeader);
    }

    return TRUE;
}

Referenced by SecurityPageProc().

BuildDefaultPrincipalAce()

static PACE_HEADER BuildDefaultPrincipalAce ( IN PSECURITY_PAGE  sp, IN PSID  pSid  )

static

Definition at line 1164 of file aclui.c.

{
    PACCESS_ALLOWED_ACE Ace;
    DWORD SidLen;
    WORD AceSize;

    SidLen = GetLengthSid(pSid);
    AceSize = FIELD_OFFSET(ACCESS_ALLOWED_ACE,
                           SidStart) + (WORD)SidLen;
    Ace = HeapAlloc(GetProcessHeap(),
                    0,
                    AceSize);
    if (Ace != NULL)
    {
        Ace->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
        Ace->Header.AceFlags = 0; /* FIXME */
        Ace->Header.AceSize = AceSize;
        Ace->Mask = sp->DefaultAccess.mask;

        if (CopySid(SidLen,
                    (PSID)&Ace->SidStart,
                    pSid))
        {
            return &Ace->Header;
        }

        HeapFree(GetProcessHeap(),
                 0,
                 Ace);
    }

    return NULL;
}

Referenced by AddSelectedPrincipal().

CreatePrincipalListItem()

static VOID CreatePrincipalListItem ( OUT LVITEM *  li, IN PSECURITY_PAGE  sp, IN PPRINCIPAL_LISTITEM  PrincipalListItem, IN INT  Index, IN BOOL  Selected  )

static

Definition at line 384 of file aclui.c.

{
    INT ImageIndex = 2;

    if (PrincipalListItem->SidReqResult != NULL)
    {
        switch (PrincipalListItem->SidReqResult->SidNameUse)
        {
            case SidTypeUser:
                ImageIndex = 0;
                break;
            case SidTypeWellKnownGroup:
            case SidTypeGroup:
                ImageIndex = 1;
                break;
            default:
                break;
        }
    }

    li->mask = LVIF_IMAGE | LVIF_PARAM | LVIF_STATE | LVIF_TEXT;
    li->iItem = Index;
    li->iSubItem = 0;
    li->state = (Selected ? LVIS_SELECTED : 0);
    li->stateMask = LVIS_SELECTED;
    li->pszText = PrincipalListItem->DisplayString;
    li->iImage = ImageIndex;
    li->lParam = (LPARAM)PrincipalListItem;
}

Referenced by AddPrincipalListEntry(), and UpdatePrincipalListItem().

CreateSecurityPage()

HPROPSHEETPAGE WINAPI CreateSecurityPage

(

IN LPSECURITYINFO

psi

)

Definition at line 1491 of file aclui.c.

{
    PROPSHEETPAGE psp = {0};
    PSECURITY_PAGE sPage;
    SI_OBJECT_INFO ObjectInfo = {0};
    HANDLE SidCacheMgr;
    LPCWSTR SystemName = NULL;
    HRESULT hRet;

    if (psi == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);

        DPRINT("No ISecurityInformation class passed!\n");
        return NULL;
    }

    /* get the object information from the server. Zero the structure before
       because some applications seem to return SUCCESS but only seem to set the
       fields they care about. */
    hRet = psi->lpVtbl->GetObjectInformation(psi,
                                             &ObjectInfo);

    if (FAILED(hRet))
    {
        SetLastError(hRet);

        DPRINT("CreateSecurityPage() failed! Failed to query the object information!\n");
        return NULL;
    }

    if ((ObjectInfo.dwFlags & SI_SERVER_IS_DC) &&
         ObjectInfo.pszServerName != NULL &&
         ObjectInfo.pszServerName[0] != L'\0')
    {
        SystemName = ObjectInfo.pszServerName;
    }

    SidCacheMgr = CreateSidCacheMgr(GetProcessHeap(),
                                    SystemName);
    if (SidCacheMgr == NULL)
    {
        DPRINT("Creating the SID cache failed!\n");
        return NULL;
    }

    hRet = CoInitialize(NULL);
    if (FAILED(hRet))
    {
        DestroySidCacheMgr(SidCacheMgr);
        DPRINT("CoInitialize failed!\n");
        return NULL;
    }

    sPage = HeapAlloc(GetProcessHeap(),
                      HEAP_ZERO_MEMORY,
                      sizeof(SECURITY_PAGE));
    if (sPage == NULL)
    {
        DestroySidCacheMgr(SidCacheMgr);
        CoUninitialize();

        SetLastError(ERROR_NOT_ENOUGH_MEMORY);

        DPRINT("Not enough memory to allocate a SECURITY_PAGE!\n");
        return NULL;
    }

    ZeroMemory(sPage,
               sizeof(*sPage));

    sPage->psi = psi;
    sPage->ObjectInfo = ObjectInfo;
    sPage->ServerName = SystemName;
    sPage->SidCacheMgr = SidCacheMgr;

    psp.dwSize = sizeof(PROPSHEETPAGE);
    psp.dwFlags = PSP_USECALLBACK;
    psp.hInstance = hDllInstance;
    psp.pszTemplate = MAKEINTRESOURCE(IDD_SECPAGE);
    psp.pfnDlgProc = SecurityPageProc;
    psp.lParam = (LPARAM)sPage;
    psp.pfnCallback = SecurityPageCallback;

    if (ObjectInfo.dwFlags & SI_PAGE_TITLE)
    {
        psp.pszTitle = ObjectInfo.pszPageTitle;

        if (psp.pszTitle != NULL)
        {
            psp.dwFlags |= PSP_USETITLE;
        }
    }
    else
    {
        psp.pszTitle = NULL;
    }

    /* NOTE: the SECURITY_PAGE structure will be freed by the property page
             callback! */

    return CreatePropertySheetPage(&psp);
}

Referenced by EditSecurity().

DestroySecurityPage()

static VOID DestroySecurityPage ( IN PSECURITY_PAGE  sp )

static

Definition at line 88 of file aclui.c.

{
    if(sp->hiPrincipals != NULL)
    {
        ImageList_Destroy(sp->hiPrincipals);
    }

    DestroySidCacheMgr(sp->SidCacheMgr);

    if (sp->OwnerSid != NULL)
        LocalFree((HLOCAL)sp->OwnerSid);

    HeapFree(GetProcessHeap(),
             0,
             sp);

    CoUninitialize();
}

Referenced by SecurityPageCallback().

DllMain()

BOOL WINAPI DllMain	(	IN HINSTANCE	hinstDLL,
		IN DWORD	dwReason,
		IN LPVOID	lpvReserved
	)

Definition at line 1679 of file aclui.c.

{
    switch (dwReason)
    {
        case DLL_PROCESS_ATTACH:
            hDllInstance = hinstDLL;

            DisableThreadLibraryCalls(hinstDLL);

            if (!RegisterCheckListControl(hinstDLL))
            {
                DPRINT("Registering the CHECKLIST_ACLUI class failed!\n");
                return FALSE;
            }
            break;

        case DLL_PROCESS_DETACH:
            UnregisterCheckListControl(hinstDLL);
            break;
    }

    return TRUE;
}

EditSecurity()

BOOL WINAPI EditSecurity	(	IN HWND	hwndOwner,
		IN LPSECURITYINFO	psi
	)

Definition at line 1603 of file aclui.c.

{
    HRESULT hRet;
    SI_OBJECT_INFO ObjectInfo = {0};
    PROPSHEETHEADER psh;
    HPROPSHEETPAGE hPages[1];
    LPWSTR lpCaption = NULL;
    BOOL Ret;

    if (psi == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);

        DPRINT("No ISecurityInformation class passed!\n");
        return FALSE;
    }

    /* get the object information from the server. Zero the structure before
       because some applications seem to return SUCCESS but only seem to set the
       fields they care about. */
    hRet = psi->lpVtbl->GetObjectInformation(psi,
                                             &ObjectInfo);

    if (FAILED(hRet))
    {
        SetLastError(hRet);

        DPRINT("GetObjectInformation() failed!\n");
        return FALSE;
    }

    /* create the page */
    hPages[0] = CreateSecurityPage(psi);
    if (hPages[0] == NULL)
    {
        DPRINT("CreateSecurityPage(), couldn't create property sheet!\n");
        return FALSE;
    }

    psh.dwSize = sizeof(PROPSHEETHEADER);
    psh.dwFlags = PSH_DEFAULT;
    psh.hwndParent = hwndOwner;
    psh.hInstance = hDllInstance;

    /* Set the page title to the object name, make sure the format string
       has "%1" NOT "%s" because it uses FormatMessage() to automatically
       allocate the right amount of memory. */
    if (LoadAndFormatString(hDllInstance,
                            IDS_PSP_TITLE,
                            &lpCaption,
                            ObjectInfo.pszObjectName))
    {
        psh.pszCaption = lpCaption;
    }
    else
    {
        psh.pszCaption = ObjectInfo.pszObjectName;
    }

    psh.nPages = sizeof(hPages) / sizeof(HPROPSHEETPAGE);
    psh.nStartPage = 0;
    psh.phpage = hPages;

    Ret = (PropertySheet(&psh) != -1);

    if (lpCaption != NULL)
    {
        LocalFree((HLOCAL)lpCaption);
    }

    return Ret;
}

FindSidInPrincipalsListAddAce()

static PPRINCIPAL_LISTITEM FindSidInPrincipalsListAddAce ( IN PPRINCIPAL_LISTITEM  PrincipalsListHead, IN PSID  Sid, IN PACE_HEADER  AceHeader  )

static

Definition at line 182 of file aclui.c.

{
    PPRINCIPAL_LISTITEM CurItem;

    for (CurItem = PrincipalsListHead;
         CurItem != NULL;
         CurItem = CurItem->Next)
    {
        if (EqualSid((PSID)(CurItem + 1),
                     Sid))
        {
            if (AddAceToPrincipal(CurItem,
                                  AceHeader) != NULL)
            {
                return CurItem;
            }

            /* unable to add the ACE to the principal */
            break;
        }
    }

    return NULL;
}

Referenced by AddPrincipalToList().

FreePrincipalsList()

static VOID FreePrincipalsList ( IN PSECURITY_PAGE  sp, IN PPRINCIPAL_LISTITEM *  PrincipalsListHead  )

static

Definition at line 108 of file aclui.c.

{
    PPRINCIPAL_LISTITEM CurItem, NextItem;
    PACE_ENTRY AceEntry, NextAceEntry;

    CurItem = *PrincipalsListHead;
    while (CurItem != NULL)
    {
        /* Free all ACEs */
        AceEntry = CurItem->ACEs;
        while (AceEntry != NULL)
        {
            NextAceEntry = AceEntry->Next;
            HeapFree(GetProcessHeap(),
                     0,
                     AceEntry);
            AceEntry = NextAceEntry;
        }

        /* free the SID string if present */
        if (CurItem->SidReqResult != NULL)
        {
            DereferenceSidReqResult(sp->SidCacheMgr,
                                    CurItem->SidReqResult);
        }

        if (CurItem->DisplayString != NULL)
        {
            LocalFree((HLOCAL)CurItem->DisplayString);
        }

        /* free the ACE list item */
        NextItem = CurItem->Next;
        HeapFree(GetProcessHeap(),
                 0,
                 CurItem);
        CurItem = NextItem;
    }

    *PrincipalsListHead = NULL;
}

Referenced by ReloadPrincipalsList().

GetDisplayStringFromSidRequestResult()

static LPWSTR GetDisplayStringFromSidRequestResult ( IN PSIDREQRESULT  SidReqResult )

static

Definition at line 319 of file aclui.c.

{
    LPWSTR lpDisplayString = NULL;

    if (SidReqResult->SidNameUse == SidTypeUser ||
        SidReqResult->SidNameUse == SidTypeGroup)
    {
        LoadAndFormatString(hDllInstance,
                            IDS_USERDOMAINFORMAT,
                            &lpDisplayString,
                            SidReqResult->AccountName,
                            SidReqResult->DomainName,
                            SidReqResult->AccountName);
    }
    else
    {
        LoadAndFormatString(hDllInstance,
                            IDS_USERFORMAT,
                            &lpDisplayString,
                            SidReqResult->AccountName);
    }

    return lpDisplayString;
}

Referenced by GetPrincipalDisplayString(), and UpdatePrincipalInfo().

GetPrincipalAccountNameString()

static LPWSTR GetPrincipalAccountNameString ( IN PPRINCIPAL_LISTITEM  PrincipalListItem )

static

Definition at line 363 of file aclui.c.

{
    LPWSTR lpDisplayString = NULL;

    if (PrincipalListItem->SidReqResult != NULL)
    {
        LoadAndFormatString(hDllInstance,
                            IDS_USERFORMAT,
                            &lpDisplayString,
                            PrincipalListItem->SidReqResult->AccountName);
    }
    else
    {
        ConvertSidToStringSid((PSID)(PrincipalListItem + 1),
                              &lpDisplayString);
    }

    return lpDisplayString;
}

Referenced by UpdateControlStates().

GetPrincipalDisplayString()

static LPWSTR GetPrincipalDisplayString ( IN PPRINCIPAL_LISTITEM  PrincipalListItem )

static

Definition at line 345 of file aclui.c.

{
    LPWSTR lpDisplayString = NULL;

    if (PrincipalListItem->SidReqResult != NULL)
    {
        lpDisplayString = GetDisplayStringFromSidRequestResult(PrincipalListItem->SidReqResult);
    }
    else
    {
        ConvertSidToStringSidW((PSID)(PrincipalListItem + 1),
                               &lpDisplayString);
    }

    return lpDisplayString;
}

Referenced by AddPrincipalListEntry(), and UpdatePrincipalListItem().

LoadPermissionsList()

static VOID LoadPermissionsList ( IN PSECURITY_PAGE  sp, IN GUID *  GuidObjectType, IN DWORD  dwFlags, OUT SI_ACCESS *  DefaultAccess  )

static

Definition at line 797 of file aclui.c.

{
    HRESULT hRet;
    PSI_ACCESS AccessList;
    ULONG nAccessList, DefaultAccessIndex;
    WCHAR szSpecialPermissions[255];
    BOOLEAN SpecialPermissionsPresent = FALSE;
    ACCESS_MASK SpecialPermissionsMask = 0;

    /* clear the permissions list */

    SendMessage(sp->hAceCheckList,
                CLM_CLEAR,
                0,
                0);

    /* query the access rights from the server */
    hRet = sp->psi->lpVtbl->GetAccessRights(sp->psi,
                                            GuidObjectType,
                                            dwFlags, /* FIXME */
                                            &AccessList,
                                            &nAccessList,
                                            &DefaultAccessIndex);
    if (SUCCEEDED(hRet) && nAccessList != 0)
    {
        LPCWSTR NameStr;
        PSI_ACCESS CurAccess, LastAccess;
        WCHAR NameBuffer[MAX_PATH];

        /* save the default access rights to be used when adding ACEs later */
        if (DefaultAccess != NULL)
        {
            *DefaultAccess = AccessList[DefaultAccessIndex];
        }

        LastAccess = AccessList + nAccessList;
        for (CurAccess = &AccessList[0];
             CurAccess != LastAccess;
             CurAccess++)
        {
            if (CurAccess->dwFlags & dwFlags)
            {
                /* get the permission name, load it from a string table if necessary */
                if (IS_INTRESOURCE(CurAccess->pszName))
                {
                    if (!LoadString(sp->ObjectInfo.hInstance,
                                    (UINT)((ULONG_PTR)CurAccess->pszName),
                                    NameBuffer,
                                    sizeof(NameBuffer) / sizeof(NameBuffer[0])))
                    {
                        LoadString(hDllInstance,
                                   IDS_UNKNOWN,
                                   NameBuffer,
                                   sizeof(NameBuffer) / sizeof(NameBuffer[0]));
                    }
                    NameStr = NameBuffer;
                }
                else
                {
                    NameStr = CurAccess->pszName;
                }

                SendMessage(sp->hAceCheckList,
                            CLM_ADDITEM,
                            (WPARAM)CurAccess->mask,
                            (LPARAM)NameStr);
            }
            else if (CurAccess->dwFlags & SI_ACCESS_SPECIFIC)
            {
                SpecialPermissionsPresent = TRUE;
                SpecialPermissionsMask |= CurAccess->mask;
            }
        }
    }

    /* add the special permissions check item in case the specific access rights
       aren't displayed */
    if (SpecialPermissionsPresent &&
        LoadString(hDllInstance,
                   IDS_SPECIAL_PERMISSIONS,
                   szSpecialPermissions,
                   sizeof(szSpecialPermissions) / sizeof(szSpecialPermissions[0])))
    {
        /* add the special permissions check item */
        sp->SpecialPermCheckIndex = (INT)SendMessage(sp->hAceCheckList,
                                                     CLM_ADDITEM,
                                                     (WPARAM)SpecialPermissionsMask,
                                                     (LPARAM)szSpecialPermissions);
        if (sp->SpecialPermCheckIndex != -1)
        {
            SendMessage(sp->hAceCheckList,
                        CLM_SETITEMSTATE,
                        (WPARAM)sp->SpecialPermCheckIndex,
                        CIS_ALLOWDISABLED | CIS_DENYDISABLED | CIS_NONE);
        }
    }
}

Referenced by SecurityPageProc().

PrincipalCompare()

static int CALLBACK PrincipalCompare ( IN LPARAM  lParam1, IN LPARAM  lParam2, IN LPARAM  lParamSort  )

static

Definition at line 446 of file aclui.c.

{
    PPRINCIPAL_LISTITEM Item1 = (PPRINCIPAL_LISTITEM)lParam1;
    PPRINCIPAL_LISTITEM Item2 = (PPRINCIPAL_LISTITEM)lParam2;

    if (Item1->DisplayString != NULL && Item2->DisplayString != NULL)
    {
        return wcscmp(Item1->DisplayString,
                      Item2->DisplayString);
    }

    return 0;
}

Referenced by UpdatePrincipalListItem().

ReloadPrincipalsList()

static VOID ReloadPrincipalsList ( IN PSECURITY_PAGE  sp )

static

Definition at line 508 of file aclui.c.

{
    PSECURITY_DESCRIPTOR SecurityDescriptor;
    BOOL DaclPresent, DaclDefaulted, OwnerDefaulted;
    PACL Dacl = NULL;
    PSID OwnerSid = NULL;
    LPTSTR OwnerSidString;
    DWORD SidLen;
    HRESULT hRet;

    /* delete the cached ACL */
    FreePrincipalsList(sp,
                       &sp->PrincipalsListHead);

    /* query the ACL */
    hRet = sp->psi->lpVtbl->GetSecurity(sp->psi,
                                        DACL_SECURITY_INFORMATION | OWNER_SECURITY_INFORMATION,
                                        &SecurityDescriptor,
                                        FALSE);
    if (SUCCEEDED(hRet) && SecurityDescriptor != NULL)
    {
        if (GetSecurityDescriptorOwner(SecurityDescriptor,
                                       &OwnerSid,
                                       &OwnerDefaulted))
        {
            sp->OwnerDefaulted = OwnerDefaulted;
            if (sp->OwnerSid != NULL)
            {
                LocalFree((HLOCAL)sp->OwnerSid);
                sp->OwnerSid = NULL;
            }

            SidLen = GetLengthSid(OwnerSid);
            if (SidLen == 0)
                goto ClearOwner;

            sp->OwnerSid = (PSID)LocalAlloc(LMEM_FIXED,
                                            SidLen);
            if (sp->OwnerSid != NULL)
            {
                if (CopySid(SidLen,
                            sp->OwnerSid,
                            OwnerSid))
                {
                    /* Lookup the SID now */
                    if (!LookupSidCache(sp->SidCacheMgr,
                                        sp->OwnerSid,
                                        SidLookupCompletion,
                                        sp))
                    {
                        /* Lookup was deferred */
                        if (ConvertSidToStringSid(sp->OwnerSid,
                                                  &OwnerSidString))
                        {
                            SetDlgItemText(sp->hWnd,
                                           IDC_OWNER,
                                           OwnerSidString);
                            LocalFree((HLOCAL)OwnerSidString);
                        }
                        else
                            goto ClearOwner;
                    }
                }
                else
                    goto ClearOwner;
            }
            else
                goto ClearOwner;
        }
        else
        {
ClearOwner:
            SetDlgItemText(sp->hWnd,
                           IDC_OWNER,
                           NULL);
        }

        if (GetSecurityDescriptorDacl(SecurityDescriptor,
                                      &DaclPresent,
                                      &Dacl,
                                      &DaclDefaulted) &&
            DaclPresent && Dacl != NULL)
        {
            PSID Sid;
            PACE_HEADER AceHeader;
            ULONG AceIndex;

            for (AceIndex = 0;
                 AceIndex < Dacl->AceCount;
                 AceIndex++)
            {
                if (GetAce(Dacl,
                           AceIndex,
                           (LPVOID*)&AceHeader) &&
                    AceHeader != NULL)
                {
                    BOOL LookupDeferred;
                    PPRINCIPAL_LISTITEM PrincipalListItem;

                    Sid = AceHeaderToSID(AceHeader);

                    PrincipalListItem = AddPrincipalToList(sp,
                                                           Sid,
                                                           AceHeader,
                                                           &LookupDeferred);

                    if (PrincipalListItem != NULL && LookupDeferred)
                    {
                        AddPrincipalListEntry(sp,
                                              PrincipalListItem,
                                              -1,
                                              FALSE);
                    }
                }
            }
        }
        LocalFree((HLOCAL)SecurityDescriptor);
    }
}

Referenced by SecurityPageProc().

ResizeControls()

static VOID ResizeControls ( IN PSECURITY_PAGE  sp, IN INT  Width, IN INT  Height  )

static

Definition at line 899 of file aclui.c.

{
    HWND hWndAllow, hWndDeny, hWndOwnerEdit;
    RECT rcControl, rcControl2, rcControl3, rcWnd;
    INT cxWidth, cxEdge, btnSpacing;
    POINT pt, pt2;
    HDWP dwp;
    INT nControls = 8;
    LVCOLUMN lvc;

    hWndAllow = GetDlgItem(sp->hWnd,
                           IDC_LABEL_ALLOW);
    hWndDeny = GetDlgItem(sp->hWnd,
                          IDC_LABEL_DENY);

    GetWindowRect(sp->hWnd,
                  &rcWnd);

    cxEdge = GetSystemMetrics(SM_CXEDGE);

    /* use the left margin of the principal list view control for all control
       margins */
    pt.x = 0;
    pt.y = 0;
    MapWindowPoints(sp->hWndPrincipalsList,
                    sp->hWnd,
                    &pt,
                    1);
    cxWidth = Width - (2 * pt.x);

    if (sp->ObjectInfo.dwFlags & SI_ADVANCED)
    {
        nControls += 2;
    }

    if ((dwp = BeginDeferWindowPos(nControls)))
    {
        /* resize the owner edit field */
        hWndOwnerEdit = GetDlgItem(sp->hWnd,
                                   IDC_OWNER);
        GetWindowRect(hWndOwnerEdit,
                      &rcControl);
        pt2.x = 0;
        pt2.y = 0;
        MapWindowPoints(hWndOwnerEdit,
                        sp->hWnd,
                        &pt2,
                        1);
        if (!(dwp = DeferWindowPos(dwp,
                                   hWndOwnerEdit,
                                   NULL,
                                   0,
                                   0,
                                   Width - pt.x - pt2.x,
                                   rcControl.bottom - rcControl.top,
                                   SWP_NOMOVE | SWP_NOZORDER)))
        {
            goto EndDeferWnds;
        }

        /* resize the Principal list view */
        GetWindowRect(sp->hWndPrincipalsList,
                      &rcControl);
        if (!(dwp = DeferWindowPos(dwp,
                                   sp->hWndPrincipalsList,
                                   NULL,
                                   0,
                                   0,
                                   cxWidth,
                                   rcControl.bottom - rcControl.top,
                                   SWP_NOMOVE | SWP_NOZORDER)))
        {
            goto EndDeferWnds;
        }

        /* move the Add Principal button */
        GetWindowRect(sp->hBtnAdd,
                      &rcControl);
        GetWindowRect(sp->hBtnRemove,
                      &rcControl2);
        btnSpacing = rcControl2.left - rcControl.right;
        pt2.x = 0;
        pt2.y = 0;
        MapWindowPoints(sp->hBtnAdd,
                        sp->hWnd,
                        &pt2,
                        1);
        if (!(dwp = DeferWindowPos(dwp,
                                   sp->hBtnAdd,
                                   NULL,
                                   pt.x + cxWidth - (rcControl2.right - rcControl2.left) -
                                       (rcControl.right - rcControl.left) -
                                       btnSpacing - cxEdge,
                                   pt2.y,
                                   0,
                                   0,
                                   SWP_NOSIZE | SWP_NOZORDER)))
        {
            goto EndDeferWnds;
        }

        /* move the Delete Principal button */
        pt2.x = 0;
        pt2.y = 0;
        MapWindowPoints(sp->hBtnRemove,
                        sp->hWnd,
                        &pt2,
                        1);
        if (!(dwp = DeferWindowPos(dwp,
                                   sp->hBtnRemove,
                                   NULL,
                                   pt.x + cxWidth - (rcControl2.right - rcControl2.left) - cxEdge,
                                   pt2.y,
                                   0,
                                   0,
                                   SWP_NOSIZE | SWP_NOZORDER)))
        {
            goto EndDeferWnds;
        }

        /* move the Permissions For label */
        GetWindowRect(hWndAllow,
                      &rcControl);
        GetWindowRect(hWndDeny,
                      &rcControl2);
        GetWindowRect(sp->hPermissionsForLabel,
                      &rcControl3);
        pt2.x = 0;
        pt2.y = 0;
        MapWindowPoints(sp->hPermissionsForLabel,
                        sp->hWnd,
                        &pt2,
                        1);
        if (!(dwp = DeferWindowPos(dwp,
                                   sp->hPermissionsForLabel,
                                   NULL,
                                   0,
                                   0,
                                   cxWidth - (rcControl2.right - rcControl2.left) -
                                       (rcControl.right - rcControl.left) -
                                       (2 * btnSpacing) - cxEdge,
                                   rcControl3.bottom - rcControl3.top,
                                   SWP_NOMOVE | SWP_NOZORDER)))
        {
            goto EndDeferWnds;
        }

        /* move the Allow label */
        pt2.x = 0;
        pt2.y = 0;
        MapWindowPoints(hWndAllow,
                        sp->hWnd,
                        &pt2,
                        1);
        if (!(dwp = DeferWindowPos(dwp,
                                   hWndAllow,
                                   NULL,
                                   cxWidth - (rcControl2.right - rcControl2.left) -
                                       (rcControl.right - rcControl.left) -
                                       btnSpacing - cxEdge,
                                   pt2.y,
                                   0,
                                   0,
                                   SWP_NOSIZE | SWP_NOZORDER)))
        {
            goto EndDeferWnds;
        }

        /* move the Deny label */
        pt2.x = 0;
        pt2.y = 0;
        MapWindowPoints(hWndDeny,
                        sp->hWnd,
                        &pt2,
                        1);
        if (!(dwp = DeferWindowPos(dwp,
                                   hWndDeny,
                                   NULL,
                                   cxWidth - (rcControl2.right - rcControl2.left) - cxEdge,
                                   pt2.y,
                                   0,
                                   0,
                                   SWP_NOSIZE | SWP_NOZORDER)))
        {
            goto EndDeferWnds;
        }

        /* resize the Permissions check list box */
        GetWindowRect(sp->hAceCheckList,
                      &rcControl);
        GetWindowRect(sp->hBtnAdvanced,
                      &rcControl2);
        GetWindowRect(GetDlgItem(sp->hWnd,
                                 IDC_LABEL_ADVANCED),
                      &rcControl3);
        if (!(dwp = DeferWindowPos(dwp,
                                   sp->hAceCheckList,
                                   NULL,
                                   0,
                                   0,
                                   cxWidth,
                                   ((sp->ObjectInfo.dwFlags & SI_ADVANCED) ?
                                       Height - (rcControl.top - rcWnd.top) -
                                           (rcControl3.bottom - rcControl3.top) - pt.x - btnSpacing :
                                       Height - (rcControl.top - rcWnd.top) - pt.x),
                                   SWP_NOMOVE | SWP_NOZORDER)))
        {
            goto EndDeferWnds;
        }

        if (sp->ObjectInfo.dwFlags & SI_ADVANCED)
        {
            /* move and resize the Advanced label */
            if (!(dwp = DeferWindowPos(dwp,
                                       GetDlgItem(sp->hWnd,
                                                  IDC_LABEL_ADVANCED),
                                       NULL,
                                       pt.x,
                                       Height - (rcControl3.bottom - rcControl3.top) - pt.x,
                                       cxWidth - (rcControl2.right - rcControl2.left) - cxEdge,
                                       rcControl3.bottom - rcControl3.top,
                                       SWP_NOZORDER)))
            {
                goto EndDeferWnds;
            }

            /* move and resize the Advanced button */
            if (!(dwp = DeferWindowPos(dwp,
                                       sp->hBtnAdvanced,
                                       NULL,
                                       cxWidth - (rcControl2.right - rcControl2.left) + pt.x,
                                       Height - (rcControl2.bottom - rcControl2.top) - pt.x,
                                       0,
                                       0,
                                       SWP_NOSIZE | SWP_NOZORDER)))
            {
                goto EndDeferWnds;
            }
        }

        EndDeferWindowPos(dwp);
    }

EndDeferWnds:
    /* update the width of the principal list view column */
    GetClientRect(sp->hWndPrincipalsList,
                  &rcControl);
    lvc.mask = LVCF_WIDTH;
    lvc.cx = rcControl.right;
    (void)ListView_SetColumn(sp->hWndPrincipalsList,
                             0,
                             &lvc);

    /* calculate the columns of the allow/deny checkboxes */
    SetAceCheckListColumns(sp->hAceCheckList,
                           CLB_ALLOW,
                           hWndAllow);
    SetAceCheckListColumns(sp->hAceCheckList,
                           CLB_DENY,
                           hWndDeny);
}

Referenced by SecurityPageProc().

SecurityPageCallback()

static UINT CALLBACK SecurityPageCallback ( IN HWND  hwnd, IN UINT  uMsg, IN LPPROPSHEETPAGE  ppsp  )

static

Definition at line 751 of file aclui.c.

{
    PSECURITY_PAGE sp = (PSECURITY_PAGE)ppsp->lParam;

    switch (uMsg)
    {
        case PSPCB_CREATE:
        {
            return TRUE;
        }
        case PSPCB_RELEASE:
        {
            DestroySecurityPage(sp);
            return FALSE;
        }
    }

    return FALSE;
}

Referenced by CreateSecurityPage().

SecurityPageProc()

static INT_PTR CALLBACK SecurityPageProc ( IN HWND  hwndDlg, IN UINT  uMsg, IN WPARAM  wParam, IN LPARAM  lParam  )

static

Definition at line 1237 of file aclui.c.

{
    PSECURITY_PAGE sp;
    INT_PTR Ret = FALSE;

    sp = (PSECURITY_PAGE)GetWindowLongPtr(hwndDlg, DWLP_USER);
    if (sp != NULL || uMsg == WM_INITDIALOG)
    {
        switch (uMsg)
        {
            case WM_NOTIFY:
            {
                NMHDR *pnmh = (NMHDR*)lParam;

                if (pnmh->hwndFrom == sp->hWndPrincipalsList)
                {
                    switch (pnmh->code)
                    {
                        case LVN_ITEMCHANGED:
                        {
                            LPNMLISTVIEW pnmv = (LPNMLISTVIEW)lParam;

                            if ((pnmv->uChanged & LVIF_STATE) &&
                                ((pnmv->uOldState & (LVIS_FOCUSED | LVIS_SELECTED)) ||
                                 (pnmv->uNewState & (LVIS_FOCUSED | LVIS_SELECTED))))
                            {
                                UpdateControlStates(sp);
                            }
                            break;
                        }
                    }
                }
                else if (pnmh->hwndFrom == sp->hAceCheckList)
                {
                    switch (pnmh->code)
                    {
                        case CLN_CHANGINGITEMCHECKBOX:
                        {
                            PNMCHANGEITEMCHECKBOX pcicb = (PNMCHANGEITEMCHECKBOX)lParam;

                            /* make sure only one of both checkboxes is only checked
                               at the same time */
                            if (pcicb->Checked)
                            {
                                pcicb->NewState &= ~((pcicb->CheckBox != CLB_DENY) ? CIS_DENY : CIS_ALLOW);
                            }
                            break;
                        }
                    }
                }
                else if (pnmh->hwndFrom == sp->hWnd)
                {
                    switch(pnmh->code)
                    {
                        case SIDN_LOOKUPSUCCEEDED:
                        {
                            PSIDLOOKUPNOTIFYINFO LookupInfo = CONTAINING_RECORD(lParam,
                                                                                SIDLOOKUPNOTIFYINFO,
                                                                                nmh);

                            /* a SID lookup succeeded, update the information */
                            UpdatePrincipalInfo(sp,
                                                LookupInfo);
                            break;
                        }
                    }
                }
                break;
            }

            case WM_COMMAND:
            {
                switch (LOWORD(wParam))
                {
                    case IDC_ADD_PRINCIPAL:
                    {
                        HRESULT hRet;

                        hRet = InitializeObjectPicker(sp->ServerName,
                                                      &sp->ObjectInfo,
                                                      &sp->pDsObjectPicker);
                        if (SUCCEEDED(hRet))
                        {
                            hRet = InvokeObjectPickerDialog(sp->pDsObjectPicker,
                                                            hwndDlg,
                                                            AddSelectedPrincipal,
                                                            sp);
                            if (FAILED(hRet))
                            {
                                MessageBox(hwndDlg, L"InvokeObjectPickerDialog failed!\n", NULL, 0);
                            }

                            /* delete the instance */
                            FreeObjectPicker(sp->pDsObjectPicker);
                        }
                        else
                        {
                            MessageBox(hwndDlg, L"InitializeObjectPicker failed!\n", NULL, 0);
                        }
                        break;
                    }

                    case IDC_REMOVE_PRINCIPAL:
                    {
                        PPRINCIPAL_LISTITEM SelectedPrincipal;

                        SelectedPrincipal = (PPRINCIPAL_LISTITEM)ListViewGetSelectedItemData(sp->hWndPrincipalsList);
                        if (SelectedPrincipal != NULL)
                        {
                            /* FIXME */
                        }
                        break;
                    }
                }
                break;
            }

            case WM_SIZE:
            {
                ResizeControls(sp,
                               (INT)LOWORD(lParam),
                               (INT)HIWORD(lParam));
                break;
            }

            case WM_INITDIALOG:
            {
                sp = (PSECURITY_PAGE)((LPPROPSHEETPAGE)lParam)->lParam;
                if(sp != NULL)
                {
                    LV_COLUMN lvc;
                    RECT rcLvClient;

                    sp->hWnd = hwndDlg;
                    sp->hWndPrincipalsList = GetDlgItem(hwndDlg, IDC_PRINCIPALS);
                    sp->hBtnAdd = GetDlgItem(hwndDlg, IDC_ADD_PRINCIPAL);
                    sp->hBtnRemove = GetDlgItem(hwndDlg, IDC_REMOVE_PRINCIPAL);
                    sp->hBtnAdvanced = GetDlgItem(hwndDlg, IDC_ADVANCED);
                    sp->hAceCheckList = GetDlgItem(hwndDlg, IDC_ACE_CHECKLIST);
                    sp->hPermissionsForLabel = GetDlgItem(hwndDlg, IDC_LABEL_PERMISSIONS_FOR);

                    sp->SpecialPermCheckIndex = -1;

                    /* save the pointer to the structure */
                    SetWindowLongPtr(hwndDlg, DWLP_USER, (DWORD_PTR)sp);

                    (void)ListView_SetExtendedListViewStyleEx(sp->hWndPrincipalsList,
                                                              LVS_EX_FULLROWSELECT,
                                                              LVS_EX_FULLROWSELECT);

                    sp->hiPrincipals = ImageList_Create(16,
                                                        16,
                                                        ILC_COLOR32 | ILC_MASK,
                                                        0,
                                                        3);
                    if (sp->hiPrincipals != NULL)
                    {
                        HBITMAP hbmImages;

                        hbmImages = LoadBitmap(hDllInstance,
                                               MAKEINTRESOURCE(IDB_USRGRPIMAGES));
                        if (hbmImages != NULL)
                        {
                            ImageList_AddMasked(sp->hiPrincipals,
                                                hbmImages,
                                                RGB(255,
                                                    0,
                                                    255));

                            DeleteObject(hbmImages);
                        }
                    }

                    /* setup the listview control */
                    if (sp->hiPrincipals != NULL)
                    {
                        (void)ListView_SetImageList(sp->hWndPrincipalsList,
                                                    sp->hiPrincipals,
                                                    LVSIL_SMALL);
                    }

                    GetClientRect(sp->hWndPrincipalsList,
                                  &rcLvClient);

                    /* add a column to the list view */
                    lvc.mask = LVCF_FMT | LVCF_WIDTH;
                    lvc.fmt = LVCFMT_LEFT;
                    lvc.cx = rcLvClient.right;
                    (void)ListView_InsertColumn(sp->hWndPrincipalsList,
                                                0,
                                                &lvc);

                    ReloadPrincipalsList(sp);

                    ListViewSelectItem(sp->hWndPrincipalsList,
                                       0);

                    /* calculate the columns of the allow/deny checkboxes */
                    SetAceCheckListColumns(sp->hAceCheckList,
                                           CLB_ALLOW,
                                           GetDlgItem(hwndDlg, IDC_LABEL_ALLOW));
                    SetAceCheckListColumns(sp->hAceCheckList,
                                           CLB_DENY,
                                           GetDlgItem(hwndDlg, IDC_LABEL_DENY));

                    LoadPermissionsList(sp,
                                        NULL,
                                        SI_ACCESS_GENERAL |
                                        ((sp->ObjectInfo.dwFlags & SI_CONTAINER) ? SI_ACCESS_CONTAINER : 0),
                                        &sp->DefaultAccess);

                    /* hide controls in case the flags aren't present */
                    if (sp->ObjectInfo.dwFlags & SI_ADVANCED)
                    {
                        /* editing the permissions is least the user can do when
                           the advanced button is showed */
                        sp->ObjectInfo.dwFlags |= SI_EDIT_PERMS;
                    }
                    else
                    {
                        ShowWindow(sp->hBtnAdvanced,
                                   SW_HIDE);
                        ShowWindow(GetDlgItem(hwndDlg, IDC_LABEL_ADVANCED),
                                   SW_HIDE);
                    }

                    /* enable quicksearch for the permissions checklist control */
                    SendMessage(sp->hAceCheckList,
                                CLM_ENABLEQUICKSEARCH,
                                TRUE,
                                0);

                    UpdateControlStates(sp);
                }

                Ret = TRUE;
                break;
            }
        }
    }
    return Ret;
}

Referenced by CreateSecurityPage().

SetAceCheckListColumns()

static VOID SetAceCheckListColumns ( IN HWND  hAceCheckList, IN UINT  Button, IN HWND  hLabel  )

static

Definition at line 774 of file aclui.c.

{
    POINT pt;
    RECT rcLabel;

    GetWindowRect(hLabel,
                  &rcLabel);
    pt.y = 0;
    pt.x = (rcLabel.right - rcLabel.left) / 2;
    MapWindowPoints(hLabel,
                    hAceCheckList,
                    &pt,
                    1);

    SendMessage(hAceCheckList,
                CLM_SETCHECKBOXCOLUMN,
                Button,
                pt.x);
}

Referenced by ResizeControls(), and SecurityPageProc().

SidLookupCompletion()

static VOID SidLookupCompletion ( IN HANDLE  SidCacheMgr, IN PSID  Sid, IN PSIDREQRESULT  SidRequestResult, IN PVOID  Context  )

static

Definition at line 210 of file aclui.c.

{
    PSECURITY_PAGE sp = (PSECURITY_PAGE)Context;

    /* NOTE: this routine may be executed in a different thread
             than the GUI! */

    if (SidRequestResult != NULL)
    {
        SIDLOOKUPNOTIFYINFO LookupInfo;

        LookupInfo.nmh.hwndFrom = sp->hWnd;
        LookupInfo.nmh.idFrom = 0;
        LookupInfo.nmh.code = SIDN_LOOKUPSUCCEEDED;
        LookupInfo.Sid = Sid;
        LookupInfo.SidRequestResult = SidRequestResult;

        /* notify the page that the sid lookup succeeded */
        SendMessage(sp->hWnd,
                    WM_NOTIFY,
                    (WPARAM)LookupInfo.nmh.idFrom,
                    (LPARAM)&LookupInfo.nmh);
    }
}

Referenced by AddPrincipalToList(), and ReloadPrincipalsList().

UpdateControlStates()

static VOID UpdateControlStates ( IN PSECURITY_PAGE  sp )

static

Definition at line 629 of file aclui.c.

{
    PPRINCIPAL_LISTITEM Selected = (PPRINCIPAL_LISTITEM)ListViewGetSelectedItemData(sp->hWndPrincipalsList);

    EnableWindow(sp->hBtnRemove,
                 Selected != NULL);
    EnableWindow(sp->hAceCheckList,
                 Selected != NULL);

    if (Selected != NULL)
    {
        LPWSTR szLabel;
        LPWSTR szDisplayString;

        szDisplayString = GetPrincipalAccountNameString(Selected);
        if (LoadAndFormatString(hDllInstance,
                                IDS_PERMISSIONS_FOR,
                                &szLabel,
                                szDisplayString))
        {
            SetWindowText(sp->hPermissionsForLabel,
                          szLabel);

            LocalFree((HLOCAL)szLabel);
        }

        LocalFree((HLOCAL)szDisplayString);

        /* FIXME - update the checkboxes */
    }
    else
    {
        WCHAR szPermissions[255];

        if (LoadString(hDllInstance,
                       IDS_PERMISSIONS,
                       szPermissions,
                       sizeof(szPermissions) / sizeof(szPermissions[0])))
        {
            SetWindowText(sp->hPermissionsForLabel,
                          szPermissions);
        }

        SendMessage(sp->hAceCheckList,
                    CLM_CLEARCHECKBOXES,
                    0,
                    0);
    }
}

Referenced by SecurityPageProc(), and UpdatePrincipalInfo().

UpdatePrincipalInfo()

static void UpdatePrincipalInfo ( IN PSECURITY_PAGE  sp, IN PSIDLOOKUPNOTIFYINFO  LookupInfo  )

static

Definition at line 680 of file aclui.c.

{
    PPRINCIPAL_LISTITEM CurItem;
    LPWSTR DisplayName;

    if (sp->OwnerSid != NULL &&
        EqualSid(sp->OwnerSid,
                 LookupInfo->Sid))
    {
        if (LookupInfo->SidRequestResult != NULL)
            DisplayName = GetDisplayStringFromSidRequestResult(LookupInfo->SidRequestResult);
        else if (!ConvertSidToStringSidW(LookupInfo->Sid,
                                         &DisplayName))
        {
            DisplayName = NULL;
        }

        if (DisplayName != NULL)
        {
            SetDlgItemTextW(sp->hWnd,
                            IDC_OWNER,
                            DisplayName);

            LocalFree((HLOCAL)DisplayName);
        }
    }

    for (CurItem = sp->PrincipalsListHead;
         CurItem != NULL;
         CurItem = CurItem->Next)
    {
        if (EqualSid((PSID)(CurItem + 1),
                     LookupInfo->Sid))
        {
            INT PrincipalIndex;
            LVFINDINFO lvfi;

            /* find the principal in the list */
            lvfi.flags = LVFI_PARAM;
            lvfi.lParam = (LPARAM)CurItem;
            PrincipalIndex = ListView_FindItem(sp->hWndPrincipalsList,
                                               -1,
                                               &lvfi);

            if (PrincipalIndex != -1)
            {
                /* update the principal in the list view control */
                UpdatePrincipalListItem(sp,
                                        PrincipalIndex,
                                        CurItem,
                                        LookupInfo->SidRequestResult);

                if (ListViewGetSelectedItemData(sp->hWndPrincipalsList) == (LPARAM)CurItem)
                {
                    UpdateControlStates(sp);
                }
            }
            else
            {
                AddPrincipalListEntry(sp,
                                      CurItem,
                                      -1,
                                      FALSE);
            }
            break;
        }
    }
}

Referenced by SecurityPageProc().

UpdatePrincipalListItem()

static VOID UpdatePrincipalListItem ( IN PSECURITY_PAGE  sp, IN INT  PrincipalIndex, IN PPRINCIPAL_LISTITEM  PrincipalListItem, IN PSIDREQRESULT  SidReqResult  )

static

Definition at line 463 of file aclui.c.

{
    LVITEM li;

    /* replace the request result structure */
    if (PrincipalListItem->SidReqResult != NULL)
    {
        DereferenceSidReqResult(sp->SidCacheMgr,
                                PrincipalListItem->SidReqResult);
    }

    ReferenceSidReqResult(sp->SidCacheMgr,
                          SidReqResult);
    PrincipalListItem->SidReqResult = SidReqResult;

    /* update the display string */
    if (PrincipalListItem->DisplayString != NULL)
    {
        LocalFree((HLOCAL)PrincipalListItem->DisplayString);
    }
    PrincipalListItem->DisplayString = GetPrincipalDisplayString(PrincipalListItem);

    /* update the list item */
    CreatePrincipalListItem(&li,
                            sp,
                            PrincipalListItem,
                            PrincipalIndex,
                            FALSE);

    /* don't change the list item state */
    li.mask &= ~(LVIF_STATE | LVIF_PARAM);

    (void)ListView_SetItem(sp->hWndPrincipalsList,
                           &li);

    /* sort the principals list view again */
    (void)ListView_SortItems(sp->hWndPrincipalsList,
                             PrincipalCompare,
                             (LPARAM)sp);
}

Referenced by UpdatePrincipalInfo().

Variable Documentation

hDllInstance

HINSTANCE hDllInstance

Definition at line 38 of file aclui.c.

Referenced by CreateSecurityPage(), DllMain(), EditSecurity(), GetDisplayStringFromSidRequestResult(), GetPrincipalAccountNameString(), LoadPermissionsList(), SecurityPageProc(), and UpdateControlStates().