gpolicy.c File Reference

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

Include dependency graph for gpolicy.c:

Go to the source code of this file.

Classes
struct	_GP_NOTIFY

Macros
#define	NDEBUG

Typedefs
typedef struct _GP_NOTIFY	GP_NOTIFY
typedef struct _GP_NOTIFY *	PGP_NOTIFY

Enumerations
enum	GP_ACTION { gpaUpdate = 0 , gpaTerminate }

Functions
VOID	InitializeGPNotifications (VOID)
VOID	UninitializeGPNotifications (VOID)
static VOID	NotifyGPEvents (IN BOOL bMachine)
static DWORD WINAPI	GPNotificationThreadProc (IN LPVOID lpParameter)
static HANDLE	CreateGPEvent (IN BOOL bMachine, IN PSECURITY_DESCRIPTOR lpSecurityDescriptor)
BOOL WINAPI	RegisterGPNotification (IN HANDLE hEvent, IN BOOL bMachine)
BOOL WINAPI	UnregisterGPNotification (IN HANDLE hEvent)
BOOL WINAPI	RefreshPolicy (IN BOOL bMachine)
BOOL WINAPI	RefreshPolicyEx (IN BOOL bMachine, IN DWORD dwOptions)
HANDLE WINAPI	EnterCriticalPolicySection (IN BOOL bMachine)
BOOL WINAPI	LeaveCriticalPolicySection (IN HANDLE hSection)
BOOL WINAPI	WaitForUserPolicyForegroundProcessing (VOID)
BOOL WINAPI	WaitForMachinePolicyForegroundProcessing (VOID)
DWORD WINAPI	GetAppliedGPOListA (_In_ DWORD dwFlags, _In_ LPCSTR pMachineName, _In_ PSID pSidUser, _In_ GUID *pGuidExtension, _Out_ PGROUP_POLICY_OBJECTA *ppGPOList)
DWORD WINAPI	GetAppliedGPOListW (_In_ DWORD dwFlags, _In_ LPCWSTR pMachineName, _In_ PSID pSidUser, _In_ GUID *pGuidExtension, _Out_ PGROUP_POLICY_OBJECTW *ppGPOList)

Variables
static const WCHAR	szLocalGPApplied [] = L"userenv: User Group Policy has been applied"
static const WCHAR	szLocalGPMutex [] = L"userenv: user policy mutex"
static const WCHAR	szLocalGPRefreshEvent [] = L"userenv: user policy refresh event"
static const WCHAR	szLocalGPForceRefreshEvent [] = L"userenv: user policy force refresh event"
static const WCHAR	szLocalGPDoneEvent [] = L"userenv: User Policy Foreground Done Event"
static const WCHAR	szMachineGPApplied [] = L"Global\\userenv: Machine Group Policy has been applied"
static const WCHAR	szMachineGPMutex [] = L"Global\\userenv: machine policy mutex"
static const WCHAR	szMachineGPRefreshEvent [] = L"Global\\userenv: machine policy refresh event"
static const WCHAR	szMachineGPForceRefreshEvent [] = L"Global\\userenv: machine policy force refresh event"
static const WCHAR	szMachineGPDoneEvent [] = L"Global\\userenv: Machine Policy Foreground Done Event"
static CRITICAL_SECTION	GPNotifyLock
static PGP_NOTIFY	NotificationList = NULL
static GP_ACTION	GPNotificationAction = gpaUpdate
static HANDLE	hNotificationThread = NULL
static HANDLE	hNotificationThreadEvent = NULL
static HANDLE	hLocalGPAppliedEvent = NULL
static HANDLE	hMachineGPAppliedEvent = NULL

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 29 of file gpolicy.c.

Typedef Documentation

GP_NOTIFY

typedef struct _GP_NOTIFY GP_NOTIFY

PGP_NOTIFY

typedef struct _GP_NOTIFY * PGP_NOTIFY

Enumeration Type Documentation

GP_ACTION

enum GP_ACTION

Enumerator
gpaUpdate
gpaTerminate

Definition at line 39 of file gpolicy.c.

{
    gpaUpdate = 0,
    gpaTerminate
} GP_ACTION;

Function Documentation

CreateGPEvent()

static HANDLE CreateGPEvent ( IN BOOL  bMachine, IN PSECURITY_DESCRIPTOR  lpSecurityDescriptor  )

static

Definition at line 262 of file gpolicy.c.

{
    HANDLE hEvent;
    SECURITY_ATTRIBUTES SecurityAttributes;
 
    SecurityAttributes.nLength = sizeof(SECURITY_ATTRIBUTES);
    SecurityAttributes.lpSecurityDescriptor = lpSecurityDescriptor;
    SecurityAttributes.bInheritHandle = FALSE;
 
    hEvent = CreateEventW(&SecurityAttributes,
                          TRUE,
                          FALSE,
                          (bMachine ? szMachineGPApplied : szLocalGPApplied));
 
    return hEvent;
}

Referenced by RegisterGPNotification().

EnterCriticalPolicySection()

HANDLE WINAPI EnterCriticalPolicySection

(

IN BOOL

bMachine

)

Definition at line 482 of file gpolicy.c.

{
    SECURITY_ATTRIBUTES SecurityAttributes;
    PSECURITY_DESCRIPTOR lpSecurityDescriptor;
    HANDLE hSection;
 
    /* create or open the mutex */
    lpSecurityDescriptor = CreateDefaultSecurityDescriptor();
    if (lpSecurityDescriptor != NULL)
    {
        SecurityAttributes.nLength = sizeof(SECURITY_ATTRIBUTES);
        SecurityAttributes.lpSecurityDescriptor = lpSecurityDescriptor;
        SecurityAttributes.bInheritHandle = FALSE;
 
        hSection = CreateMutexW(&SecurityAttributes,
                                FALSE,
                                (bMachine ? szMachineGPMutex : szLocalGPMutex));
 
        LocalFree((HLOCAL)lpSecurityDescriptor);
 
        if (hSection != NULL)
        {
            /* wait up to 10 minutes */
            if (WaitForSingleObject(hSection,
                                    600000) != WAIT_FAILED)
            {
                return hSection;
            }
 
            CloseHandle(hSection);
        }
    }
 
    return NULL;
}

GetAppliedGPOListA()

DWORD WINAPI GetAppliedGPOListA	(	_In_ DWORD	dwFlags,
		_In_ LPCSTR	pMachineName,
		_In_ PSID	pSidUser,
		_In_ GUID *	pGuidExtension,
		_Out_ PGROUP_POLICY_OBJECTA *	ppGPOList
	)

Definition at line 578 of file gpolicy.c.

{
    DPRINT1("GetAppliedGPOListA is UNIMPLEMENTED!\n");
    return ERROR_CALL_NOT_IMPLEMENTED;
}

GetAppliedGPOListW()

DWORD WINAPI GetAppliedGPOListW	(	_In_ DWORD	dwFlags,
		_In_ LPCWSTR	pMachineName,
		_In_ PSID	pSidUser,
		_In_ GUID *	pGuidExtension,
		_Out_ PGROUP_POLICY_OBJECTW *	ppGPOList
	)

Definition at line 592 of file gpolicy.c.

{
    DPRINT1("GetAppliedGPOListW is UNIMPLEMENTED!\n");
    return ERROR_CALL_NOT_IMPLEMENTED;
}

GPNotificationThreadProc()

static DWORD WINAPI GPNotificationThreadProc ( IN LPVOID  lpParameter )

static

Definition at line 132 of file gpolicy.c.

{
    HMODULE hModule;
    DWORD WaitResult, WaitCount;
    HANDLE WaitHandles[3];
 
    /* reference the library so we don't screw up if the application
       causes the DLL to unload while this thread is still running */
    if (GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
                           (LPCWSTR)hInstance,
                           &hModule))
    {
        ASSERT(hModule == hInstance);
 
        EnterCriticalSection(&GPNotifyLock);
 
        ASSERT(hNotificationThreadEvent != NULL);
        WaitHandles[0] = hNotificationThreadEvent;
        for (;;)
        {
            ASSERT(hMachineGPAppliedEvent != NULL);
 
            if (NotificationList == NULL)
                break;
 
            WaitCount = 2;
            WaitHandles[1] = hMachineGPAppliedEvent;
 
            if (hLocalGPAppliedEvent != NULL)
            {
                WaitHandles[2] = hLocalGPAppliedEvent;
                WaitCount++;
            }
 
            LeaveCriticalSection(&GPNotifyLock);
 
            WaitResult = WaitForMultipleObjects(WaitCount,
                                                WaitHandles,
                                                FALSE,
                                                INFINITE);
 
            EnterCriticalSection(&GPNotifyLock);
 
            if (WaitResult != WAIT_FAILED)
            {
                if (WaitResult == WAIT_OBJECT_0)
                {
                    ResetEvent(hNotificationThreadEvent);
 
                    if (GPNotificationAction == gpaTerminate)
                    {
                        /* terminate the thread */
                        break;
                    }
                }
                else if (WaitResult == WAIT_OBJECT_0 + 1 || WaitResult == WAIT_OBJECT_0 + 2)
                {
                    /* group policies have been applied */
                    if (NotificationList != NULL)
                    {
                        NotifyGPEvents((WaitResult == WAIT_OBJECT_0 + 1));
                    }
                }
                else if (WaitResult == WAIT_ABANDONED_0 + 2)
                {
                    /* In case the local group policies event was abandoned, keep watching!
                       But close the handle as it's no longer of any use. */
                    if (hLocalGPAppliedEvent != NULL)
                    {
                        CloseHandle(hLocalGPAppliedEvent);
                        hLocalGPAppliedEvent = NULL;
                    }
                }
                else if (WaitResult == WAIT_ABANDONED_0 || WaitResult == WAIT_ABANDONED_0 + 1)
                {
                    /* terminate the thread if the machine group policies event was abandoned
                       or for some reason the rundown event got abandoned. */
                    break;
                }
                else
                {
                    DPRINT("Unexpected wait result watching the group policy events: 0x%x\n", WaitResult);
                    ASSERT(FALSE);
                    break;
                }
 
                if (NotificationList == NULL)
                    break;
            }
            else
                break;
 
        }
 
        /* cleanup handles no longer used */
        ASSERT(hNotificationThread != NULL);
        ASSERT(hNotificationThreadEvent != NULL);
 
        CloseHandle(hNotificationThread);
        CloseHandle(hNotificationThreadEvent);
        hNotificationThread = NULL;
        hNotificationThreadEvent = NULL;
 
        if (hLocalGPAppliedEvent != NULL)
        {
            CloseHandle(hLocalGPAppliedEvent);
            hLocalGPAppliedEvent = NULL;
        }
        if (hMachineGPAppliedEvent != NULL)
        {
            CloseHandle(hMachineGPAppliedEvent);
            hMachineGPAppliedEvent = NULL;
        }
 
        LeaveCriticalSection(&GPNotifyLock);
 
        /* dereference the library and exit */
        FreeLibraryAndExitThread(hModule,
                                 0);
    }
    else
    {
        DPRINT1("Referencing the library failed!\n");
    }
 
    return 1;
}

Referenced by RegisterGPNotification().

InitializeGPNotifications()

VOID InitializeGPNotifications

(

VOID

)

Definition at line 65 of file gpolicy.c.

{
    InitializeCriticalSection(&GPNotifyLock);
}

Referenced by DllMain().

LeaveCriticalPolicySection()

BOOL WINAPI LeaveCriticalPolicySection

(

IN HANDLE

hSection

)

Definition at line 520 of file gpolicy.c.

{
    BOOL Ret;
 
    if (hSection == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    Ret = ReleaseMutex(hSection);
    CloseHandle(hSection);
 
    return Ret;
}

NotifyGPEvents()

static VOID NotifyGPEvents ( IN BOOL  bMachine )

static

Definition at line 114 of file gpolicy.c.

{
    PGP_NOTIFY Notify = NotificationList;
 
    while (Notify != NULL)
    {
        if (Notify->bMachine == bMachine)
        {
            SetEvent(Notify->hEvent);
        }
 
        Notify = Notify->Next;
    }
}

Referenced by GPNotificationThreadProc().

RefreshPolicy()

BOOL WINAPI RefreshPolicy

(

IN BOOL

bMachine

)

Definition at line 428 of file gpolicy.c.

{
    HANDLE hEvent;
    BOOL Ret = TRUE;
 
    hEvent = OpenEventW(EVENT_MODIFY_STATE,
                        FALSE,
                        (bMachine ? szMachineGPRefreshEvent : szLocalGPRefreshEvent));
    if (hEvent != NULL)
    {
        Ret = SetEvent(hEvent);
        CloseHandle(hEvent);
    }
 
    /* return TRUE even if the mutex doesn't exist! */
    return Ret;
}

Referenced by RefreshPolicyEx().

RefreshPolicyEx()

BOOL WINAPI RefreshPolicyEx	(	IN BOOL	bMachine,
		IN DWORD	dwOptions
	)

Definition at line 448 of file gpolicy.c.

{
    if (dwOptions & ~RP_FORCE)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (dwOptions & RP_FORCE)
    {
        HANDLE hEvent;
        BOOL Ret = TRUE;
 
        hEvent = OpenEventW(EVENT_MODIFY_STATE,
                            FALSE,
                            (bMachine ? szMachineGPForceRefreshEvent : szLocalGPForceRefreshEvent));
        if (hEvent != NULL)
        {
            Ret = SetEvent(hEvent);
            CloseHandle(hEvent);
        }
 
        /* return TRUE even if the mutex doesn't exist! */
        return Ret;
    }
    else
    {
        return RefreshPolicy(bMachine);
    }
}

RegisterGPNotification()

BOOL WINAPI RegisterGPNotification	(	IN HANDLE	hEvent,
		IN BOOL	bMachine
	)

Definition at line 282 of file gpolicy.c.

{
    PGP_NOTIFY Notify;
    PSECURITY_DESCRIPTOR lpSecurityDescriptor = NULL;
    BOOL Ret = FALSE;
 
    EnterCriticalSection(&GPNotifyLock);
 
    /* create the thread notification event */
    if (hNotificationThreadEvent == NULL)
    {
        hNotificationThreadEvent = CreateEvent(NULL,
                                               TRUE,
                                               FALSE,
                                               NULL);
        if (hNotificationThreadEvent == NULL)
        {
            goto Cleanup;
        }
    }
 
    /* create or open the machine group policy event */
    if (hMachineGPAppliedEvent == NULL)
    {
        lpSecurityDescriptor = CreateDefaultSecurityDescriptor();
        if (lpSecurityDescriptor == NULL)
        {
            goto Cleanup;
        }
 
        hMachineGPAppliedEvent = CreateGPEvent(TRUE,
                                               lpSecurityDescriptor);
        if (hMachineGPAppliedEvent == NULL)
        {
            goto Cleanup;
        }
    }
 
    /* create or open the local group policy event only if necessary */
    if (!bMachine && hLocalGPAppliedEvent == NULL)
    {
        if (lpSecurityDescriptor == NULL)
        {
            lpSecurityDescriptor = CreateDefaultSecurityDescriptor();
            if (lpSecurityDescriptor == NULL)
            {
                goto Cleanup;
            }
        }
 
        hLocalGPAppliedEvent = CreateGPEvent(FALSE,
                                             lpSecurityDescriptor);
        if (hLocalGPAppliedEvent == NULL)
        {
            goto Cleanup;
        }
    }
 
    if (hNotificationThread == NULL)
    {
        hNotificationThread = CreateThread(NULL,
                                           0,
                                           GPNotificationThreadProc,
                                           NULL,
                                           0,
                                           NULL);
    }
 
    if (hNotificationThread != NULL)
    {
        Notify = (PGP_NOTIFY)LocalAlloc(LMEM_FIXED,
                                        sizeof(GP_NOTIFY));
        if (Notify != NULL)
        {
            /* add the item to the beginning of the list */
            Notify->Next = NotificationList;
            Notify->hEvent = hEvent;
            Notify->bMachine = bMachine;
 
            NotificationList = Notify;
 
            /* notify the thread */
            GPNotificationAction = gpaUpdate;
            SetEvent(hNotificationThreadEvent);
 
            Ret = TRUE;
        }
    }
 
Cleanup:
    LeaveCriticalSection(&GPNotifyLock);
 
    if (lpSecurityDescriptor != NULL)
    {
        LocalFree((HLOCAL)lpSecurityDescriptor);
    }
 
    /* NOTE: don't delete the events or close the handles created */
 
    return Ret;
}

UninitializeGPNotifications()

VOID UninitializeGPNotifications

(

VOID

)

Definition at line 71 of file gpolicy.c.

{
    EnterCriticalSection(&GPNotifyLock);
 
    /* rundown the notification thread */
    if (hNotificationThread != NULL)
    {
        ASSERT(hNotificationThreadEvent != NULL);
 
        /* notify the thread */
        GPNotificationAction = gpaTerminate;
        SetEvent(hNotificationThreadEvent);
 
        LeaveCriticalSection(&GPNotifyLock);
 
        /* wait for the thread to terminate itself */
        WaitForSingleObject(hNotificationThread,
                            INFINITE);
 
        EnterCriticalSection(&GPNotifyLock);
 
        if (hNotificationThread != NULL)
        {
            /* the handle should be closed by the thread,
               just in case that didn't happen for an unknown reason */
            CloseHandle(hNotificationThread);
            hNotificationThread = NULL;
        }
    }
 
    if (hNotificationThreadEvent != NULL)
    {
        CloseHandle(hNotificationThreadEvent);
        hNotificationThreadEvent = NULL;
    }
 
    LeaveCriticalSection(&GPNotifyLock);
 
    DeleteCriticalSection(&GPNotifyLock);
}

Referenced by DllMain().

UnregisterGPNotification()

BOOL WINAPI UnregisterGPNotification

(

IN HANDLE

hEvent

)

Definition at line 387 of file gpolicy.c.

{
    PGP_NOTIFY Notify = NULL, *NotifyLink;
    BOOL Ret = FALSE;
 
    EnterCriticalSection(&GPNotifyLock);
 
    Notify = NotificationList;
    NotifyLink = &NotificationList;
 
    while (Notify != NULL)
    {
        if (Notify->hEvent == hEvent)
        {
            /* remove and free the item */
            *NotifyLink = Notify->Next;
            LocalFree((HLOCAL)Notify);
 
            /* notify the thread */
            if (hNotificationThread != NULL &&
                hNotificationThreadEvent != NULL)
            {
                GPNotificationAction = gpaUpdate;
                SetEvent(hNotificationThreadEvent);
            }
 
            Ret = TRUE;
            break;
        }
 
        NotifyLink = &Notify->Next;
        Notify = Notify->Next;
    }
 
    LeaveCriticalSection(&GPNotifyLock);
 
    return Ret;
}

WaitForMachinePolicyForegroundProcessing()

BOOL WINAPI WaitForMachinePolicyForegroundProcessing

(

VOID

)

Definition at line 558 of file gpolicy.c.

{
    HANDLE hEvent;
    BOOL Ret = FALSE;
 
    hEvent = OpenEventW(SYNCHRONIZE,
                        FALSE,
                        szMachineGPDoneEvent);
    if (hEvent != NULL)
    {
        Ret = WaitForSingleObject(hEvent,
                                  INFINITE) != WAIT_FAILED;
        CloseHandle(hEvent);
    }
 
    return Ret;
}

WaitForUserPolicyForegroundProcessing()

BOOL WINAPI WaitForUserPolicyForegroundProcessing

(

VOID

)

Definition at line 538 of file gpolicy.c.

{
    HANDLE hEvent;
    BOOL Ret = FALSE;
 
    hEvent = OpenEventW(SYNCHRONIZE,
                        FALSE,
                        szLocalGPDoneEvent);
    if (hEvent != NULL)
    {
        Ret = WaitForSingleObject(hEvent,
                                  INFINITE) != WAIT_FAILED;
        CloseHandle(hEvent);
    }
 
    return Ret;
}

Variable Documentation

GPNotificationAction

GP_ACTION GPNotificationAction = gpaUpdate

static

Definition at line 58 of file gpolicy.c.

Referenced by GPNotificationThreadProc(), RegisterGPNotification(), UninitializeGPNotifications(), and UnregisterGPNotification().

GPNotifyLock

CRITICAL_SECTION GPNotifyLock

static

Definition at line 56 of file gpolicy.c.

Referenced by GPNotificationThreadProc(), InitializeGPNotifications(), RegisterGPNotification(), UninitializeGPNotifications(), and UnregisterGPNotification().

hLocalGPAppliedEvent

HANDLE hLocalGPAppliedEvent = NULL

static

Definition at line 61 of file gpolicy.c.

Referenced by GPNotificationThreadProc(), and RegisterGPNotification().

hMachineGPAppliedEvent

HANDLE hMachineGPAppliedEvent = NULL

static

Definition at line 62 of file gpolicy.c.

Referenced by GPNotificationThreadProc(), and RegisterGPNotification().

hNotificationThread

HANDLE hNotificationThread = NULL

static

Definition at line 59 of file gpolicy.c.

Referenced by GPNotificationThreadProc(), RegisterGPNotification(), UninitializeGPNotifications(), and UnregisterGPNotification().

hNotificationThreadEvent

HANDLE hNotificationThreadEvent = NULL

static

Definition at line 60 of file gpolicy.c.

Referenced by GPNotificationThreadProc(), RegisterGPNotification(), UninitializeGPNotifications(), and UnregisterGPNotification().

NotificationList

PGP_NOTIFY NotificationList = NULL

static

Definition at line 57 of file gpolicy.c.

Referenced by GPNotificationThreadProc(), NotifyGPEvents(), RegisterGPNotification(), and UnregisterGPNotification().

szLocalGPApplied

const WCHAR szLocalGPApplied[] = L"userenv: User Group Policy has been applied"

static

Definition at line 45 of file gpolicy.c.

Referenced by CreateGPEvent().

szLocalGPDoneEvent

const WCHAR szLocalGPDoneEvent[] = L"userenv: User Policy Foreground Done Event"

static

Definition at line 49 of file gpolicy.c.

Referenced by WaitForUserPolicyForegroundProcessing().

szLocalGPForceRefreshEvent

const WCHAR szLocalGPForceRefreshEvent[] = L"userenv: user policy force refresh event"

static

Definition at line 48 of file gpolicy.c.

Referenced by RefreshPolicyEx().

szLocalGPMutex

const WCHAR szLocalGPMutex[] = L"userenv: user policy mutex"

static

Definition at line 46 of file gpolicy.c.

Referenced by EnterCriticalPolicySection().

szLocalGPRefreshEvent

const WCHAR szLocalGPRefreshEvent[] = L"userenv: user policy refresh event"

static

Definition at line 47 of file gpolicy.c.

Referenced by RefreshPolicy().

szMachineGPApplied

const WCHAR szMachineGPApplied[] = L"Global\\userenv: Machine Group Policy has been applied"

static

Definition at line 50 of file gpolicy.c.

Referenced by CreateGPEvent().

szMachineGPDoneEvent

const WCHAR szMachineGPDoneEvent[] = L"Global\\userenv: Machine Policy Foreground Done Event"

static

Definition at line 54 of file gpolicy.c.

Referenced by WaitForMachinePolicyForegroundProcessing().

szMachineGPForceRefreshEvent

const WCHAR szMachineGPForceRefreshEvent[] = L"Global\\userenv: machine policy force refresh event"

static

Definition at line 53 of file gpolicy.c.

Referenced by RefreshPolicyEx().

szMachineGPMutex

const WCHAR szMachineGPMutex[] = L"Global\\userenv: machine policy mutex"

static

Definition at line 51 of file gpolicy.c.

Referenced by EnterCriticalPolicySection().

szMachineGPRefreshEvent

const WCHAR szMachineGPRefreshEvent[] = L"Global\\userenv: machine policy refresh event"

static

Definition at line 52 of file gpolicy.c.

Referenced by RefreshPolicy().