notify.c File Reference

#include "winlogon.h"

Include dependency graph for notify.c:

Go to the source code of this file.

Classes
struct	_NOTIFICATION_ITEM

Typedefs
typedef VOID(WINAPI *	PWLX_NOTIFY_HANDLER) (PWLX_NOTIFICATION_INFO pInfo)
typedef struct _NOTIFICATION_ITEM	NOTIFICATION_ITEM
typedef struct _NOTIFICATION_ITEM *	PNOTIFICATION_ITEM

Functions
static PWLX_NOTIFY_HANDLER	GetNotificationHandler (_In_ HKEY hDllKey, _In_ HMODULE hModule, _In_ PCSTR pNotification)
	Retrieves the address of the exported notification handler, specified in the registry entry for the notification DLL.
static BOOL	LoadNotifyDll (_Inout_ PNOTIFICATION_ITEM NotificationDll)
	Loads the notification DLL and retrieves its exported notification handlers.
static VOID	DeleteNotification (_In_ PNOTIFICATION_ITEM Notification)
	Frees the resources associated to a notification.
static VOID	AddSfcNotification (VOID)
	Initializes the internal SFC notifications.
static VOID	AddNotificationDll (_In_ HKEY hNotifyKey, _In_ PCWSTR pszKeyName)
BOOL	InitNotifications (VOID)
static VOID	CallNotificationDll (_In_ PNOTIFICATION_ITEM NotificationDll, _In_ NOTIFICATION_TYPE Type, _In_ PWLX_NOTIFICATION_INFO pInfo)
VOID	CallNotificationDlls (PWLSESSION pSession, NOTIFICATION_TYPE Type)
VOID	CleanupNotifications (VOID)

Variables
static PSTR	FuncNames [LastHandler]
static LIST_ENTRY	NotificationDllListHead

Typedef Documentation

NOTIFICATION_ITEM

typedef struct _NOTIFICATION_ITEM NOTIFICATION_ITEM

PNOTIFICATION_ITEM

typedef struct _NOTIFICATION_ITEM * PNOTIFICATION_ITEM

PWLX_NOTIFY_HANDLER

typedef VOID(WINAPI * PWLX_NOTIFY_HANDLER) (PWLX_NOTIFICATION_INFO pInfo)

Definition at line 15 of file notify.c.

Function Documentation

AddNotificationDll()

static VOID AddNotificationDll ( _In_ HKEY  hNotifyKey, _In_ PCWSTR  pszKeyName  )

static

Definition at line 235 of file notify.c.

{
    HKEY hDllKey = NULL;
    PNOTIFICATION_ITEM NotificationDll;
    PWSTR pszDllName;
    DWORD dwValue, dwSize, dwType;
    LONG lError;
 
    TRACE("AddNotificationDll(0x%p, %S)\n", hNotifyKey, pszKeyName);
 
    lError = RegOpenKeyExW(hNotifyKey,
                           pszKeyName,
                           0,
                           KEY_READ,
                           &hDllKey);
    if (lError != ERROR_SUCCESS)
        return;
 
    /* In safe-boot mode, load the notification DLL only if it is enabled there */
    if (GetSystemMetrics(SM_CLEANBOOT) != 0) // TODO: Cache when Winlogon starts
    {
        BOOL bSafeMode = FALSE; // Default to NOT loading the DLL in SafeMode.
 
        dwSize = sizeof(dwValue);
        lError = RegQueryValueExW(hDllKey,
                                  L"SafeMode",
                                  NULL,
                                  &dwType,
                                  (PBYTE)&dwValue,
                                  &dwSize);
        if ((lError == ERROR_SUCCESS) && (dwType == REG_DWORD) && (dwSize == sizeof(dwValue)))
            bSafeMode = !!dwValue;
 
        /* Bail out if the DLL should not be loaded in safe-boot mode.
         * NOTE: On Win2000 and later, the value is always overridden
         * to TRUE, and the DLL is loaded unconditionally. This defeats
         * the whole purpose of this feature... In ReactOS we restore it! */
        if (!bSafeMode)
        {
            RegCloseKey(hDllKey);
            return;
        }
    }
 
    NotificationDll = RtlAllocateHeap(RtlGetProcessHeap(),
                                      HEAP_ZERO_MEMORY,
                                      sizeof(*NotificationDll));
    if (!NotificationDll)
    {
        lError = ERROR_OUTOFMEMORY;
        goto done;
    }
 
    NotificationDll->pszKeyName = WlStrDup(pszKeyName);
    if (NotificationDll->pszKeyName == NULL)
    {
        lError = ERROR_OUTOFMEMORY;
        goto done;
    }
 
    dwSize = 0;
    lError = RegQueryValueExW(hDllKey,
                              L"DllName",
                              NULL,
                              &dwType,
                              NULL,
                              &dwSize);
    if ((lError != ERROR_SUCCESS) ||
        (dwType != REG_SZ && dwType != REG_EXPAND_SZ) ||
        (dwSize == 0) || (dwSize % sizeof(WCHAR)))
    {
        lError = ERROR_FILE_NOT_FOUND;
        goto done;
    }
    /* Ensure the string can be NUL-terminated */
    dwSize += sizeof(WCHAR);
 
    pszDllName = RtlAllocateHeap(RtlGetProcessHeap(), 0, dwSize);
    if (!pszDllName)
    {
        lError = ERROR_OUTOFMEMORY;
        goto done;
    }
 
    lError = RegQueryValueExW(hDllKey,
                              L"DllName",
                              NULL,
                              &dwType,
                              (PBYTE)pszDllName,
                              &dwSize);
    if (lError != ERROR_SUCCESS)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, pszDllName);
        goto done;
    }
    /* NUL-terminate */
    pszDllName[dwSize / sizeof(WCHAR) - 1] = UNICODE_NULL;
 
    /* Expand the path if applicable. Note that Windows always does the
     * expansion, independently of the REG_SZ or REG_EXPAND_SZ type. */
    if (wcschr(pszDllName, L'%') != NULL)
    {
        dwSize = ExpandEnvironmentStringsW(pszDllName, NULL, 0);
        if (dwSize)
        {
            PWSTR pszDllPath = RtlAllocateHeap(RtlGetProcessHeap(), 0,
                                               dwSize * sizeof(WCHAR));
            if (!pszDllPath)
            {
                RtlFreeHeap(RtlGetProcessHeap(), 0, pszDllName);
                lError = ERROR_OUTOFMEMORY;
                goto done;
            }
            ExpandEnvironmentStringsW(pszDllName, pszDllPath, dwSize);
 
            /* Free the old buffer and replace it with the expanded path */
            RtlFreeHeap(RtlGetProcessHeap(), 0, pszDllName);
            pszDllName = pszDllPath;
        }
    }
 
    NotificationDll->pszDllName = pszDllName;
 
    NotificationDll->bEnabled = TRUE;
    NotificationDll->dwMaxWait = 30; /* FIXME: ??? */
 
    dwSize = sizeof(dwValue);
    lError = RegQueryValueExW(hDllKey,
                              L"Asynchronous",
                              NULL,
                              &dwType,
                              (PBYTE)&dwValue,
                              &dwSize);
    if ((lError == ERROR_SUCCESS) && (dwType == REG_DWORD) && (dwSize == sizeof(dwValue)))
        NotificationDll->bAsynchronous = !!dwValue;
 
    dwSize = sizeof(dwValue);
    lError = RegQueryValueExW(hDllKey,
                              L"Impersonate",
                              NULL,
                              &dwType,
                              (PBYTE)&dwValue,
                              &dwSize);
    if ((lError == ERROR_SUCCESS) && (dwType == REG_DWORD) && (dwSize == sizeof(dwValue)))
        NotificationDll->bImpersonate = !!dwValue;
 
    dwSize = sizeof(dwValue);
    lError = RegQueryValueExW(hDllKey,
                              L"SmartCardLogonNotify",
                              NULL,
                              &dwType,
                              (PBYTE)&dwValue,
                              &dwSize);
    if ((lError == ERROR_SUCCESS) && (dwType == REG_DWORD) && (dwSize == sizeof(dwValue)))
        NotificationDll->bSmartCardLogon = !!dwValue;
 
    dwSize = sizeof(dwValue);
    lError = RegQueryValueExW(hDllKey,
                              L"MaxWait",
                              NULL,
                              &dwType,
                              (PBYTE)&dwValue,
                              &dwSize);
    if ((lError == ERROR_SUCCESS) && (dwType == REG_DWORD) && (dwSize == sizeof(dwValue)))
        NotificationDll->dwMaxWait = dwValue;
 
    InsertHeadList(&NotificationDllListHead,
                   &NotificationDll->ListEntry);
 
    lError = ERROR_SUCCESS;
 
done:
    if (lError != ERROR_SUCCESS)
    {
        if (NotificationDll)
            DeleteNotification(NotificationDll);
    }
 
    RegCloseKey(hDllKey);
}

Referenced by InitNotifications().

AddSfcNotification()

static VOID AddSfcNotification ( VOID  )

static

Initializes the internal SFC notifications.

Definition at line 176 of file notify.c.

{
    PNOTIFICATION_ITEM NotificationDll;
    HMODULE hModule;
    DWORD dwError;
    WCHAR szSfcPath[MAX_PATH];
 
    ExpandEnvironmentStringsW(L"%SystemRoot%\\system32\\sfc.dll",
                              szSfcPath,
                              ARRAYSIZE(szSfcPath));
 
    NotificationDll = RtlAllocateHeap(RtlGetProcessHeap(),
                                      HEAP_ZERO_MEMORY,
                                      sizeof(*NotificationDll));
    if (!NotificationDll)
        return; // If needed: dwError = ERROR_OUTOFMEMORY;
 
    NotificationDll->pszDllName = WlStrDup(szSfcPath);
    if (NotificationDll->pszDllName == NULL)
    {
        dwError = ERROR_OUTOFMEMORY;
        goto done;
    }
 
    NotificationDll->bEnabled = TRUE;
    NotificationDll->dwMaxWait = 30; /* FIXME: ??? */
    NotificationDll->bSfcNotification = TRUE;
 
    /* Load sfc.dll, and also sfc_os.dll on systems where it forwards to */
    hModule = LoadLibraryW(szSfcPath);
    if (!hModule)
    {
        dwError = GetLastError();
        ERR("LoadLibraryW(%S) failed, Error %lu\n", szSfcPath, dwError);
        goto done;
    }
    NotificationDll->hModule = hModule;
 
    NotificationDll->Handler[LogonHandler]  = (PWLX_NOTIFY_HANDLER)GetProcAddress(hModule, "SfcWLEventLogon");
    NotificationDll->Handler[LogoffHandler] = (PWLX_NOTIFY_HANDLER)GetProcAddress(hModule, "SfcWLEventLogoff");
    if (!NotificationDll->Handler[LogonHandler] || !NotificationDll->Handler[LogoffHandler])
    {
        dwError = ERROR_PROC_NOT_FOUND;
        ERR("Couldn't snap SfcWLEventLogon/SfcWLEventLogoff\n");
        goto done;
    }
 
    InsertHeadList(&NotificationDllListHead,
                   &NotificationDll->ListEntry);
 
    dwError = ERROR_SUCCESS;
 
done:
    if (dwError != ERROR_SUCCESS)
        DeleteNotification(NotificationDll);
}

Referenced by InitNotifications().

CallNotificationDll()

static VOID CallNotificationDll ( _In_ PNOTIFICATION_ITEM  NotificationDll, _In_ NOTIFICATION_TYPE  Type, _In_ PWLX_NOTIFICATION_INFO  pInfo  )

static

Definition at line 473 of file notify.c.

{
    PWLX_NOTIFY_HANDLER pNotifyHandler;
    WLX_NOTIFICATION_INFO Info;
    HANDLE UserToken;
 
    /* Delay-load the DLL if needed */
    if (!NotificationDll->hModule)
    {
        if (!LoadNotifyDll(NotificationDll))
        {
            /* We failed, disable it */
            NotificationDll->bEnabled = FALSE;
            return;
        }
        ASSERT(NotificationDll->hModule);
    }
 
    /* Retrieve the notification handler; bail out if none is specified */
    pNotifyHandler = NotificationDll->Handler[Type];
    if (!pNotifyHandler)
        return;
 
    /* Capture the notification info structure, since
     * the notification handler might mess with it */
    Info = *pInfo;
 
    /* Impersonate the logged-on user if necessary */
    UserToken = (NotificationDll->bImpersonate ? Info.hToken : NULL);
    if (UserToken && !ImpersonateLoggedOnUser(UserToken))
    {
        ERR("WL: ImpersonateLoggedOnUser() failed with error %lu\n", GetLastError());
        return;
    }
 
    /* Call the notification handler in SEH to prevent any Winlogon crashes */
    _SEH2_TRY
    {
        pNotifyHandler(&Info);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ERR("WL: Exception 0x%08lx hit by notification DLL %ws while executing %s notify function\n",
            _SEH2_GetExceptionCode(), NotificationDll->pszDllName, FuncNames[Type]);
    }
    _SEH2_END;
 
    /* Revert impersonation */
    if (UserToken)
        RevertToSelf();
}

Referenced by CallNotificationDlls().

CallNotificationDlls()

VOID CallNotificationDlls	(	PWLSESSION	pSession,
		NOTIFICATION_TYPE	Type
	)

Definition at line 530 of file notify.c.

{
    PLIST_ENTRY ListEntry;
    WLX_NOTIFICATION_INFO Info;
 
    /* Check for invalid notification type */
    ASSERT(Type < LastHandler);
 
    TRACE("CallNotificationDlls(%s)\n", FuncNames[Type]);
 
    /* Set up the notification info structure template */
    Info.Size = sizeof(Info);
 
    switch (Type)
    {
        case LogoffHandler:
        case ShutdownHandler:
            Info.Flags = 3;
            break;
 
        default:
            Info.Flags = 0;
            break;
    }
 
    Info.UserName = pSession->UserName;
    Info.Domain = pSession->Domain;
    Info.WindowStation = pSession->InteractiveWindowStationName;
    Info.hToken = pSession->UserToken;
 
    switch (Type)
    {
        case LogonHandler:
        case StartShellHandler:
            Info.hDesktop = pSession->ApplicationDesktop;
            break;
 
        case StartScreenSaverHandler:
            Info.hDesktop = pSession->ApplicationDesktop;
            break;
 
        default:
            Info.hDesktop = pSession->WinlogonDesktop;
            break;
    }
 
    Info.pStatusCallback = NULL;
 
    for (ListEntry = NotificationDllListHead.Flink;
         ListEntry != &NotificationDllListHead;
         ListEntry = ListEntry->Flink)
    {
        PNOTIFICATION_ITEM Notification =
            CONTAINING_RECORD(ListEntry, NOTIFICATION_ITEM, ListEntry);
        if (Notification->bEnabled)
            CallNotificationDll(Notification, Type, &Info);
    }
}

Referenced by DoGenericAction(), HandleLogoff(), HandleLogon(), HandleShutdown(), StartScreenSaver(), and WinMain().

CleanupNotifications()

VOID CleanupNotifications

(

VOID

)

Definition at line 593 of file notify.c.

{
    while (!IsListEmpty(&NotificationDllListHead))
    {
        PLIST_ENTRY ListEntry = RemoveHeadList(&NotificationDllListHead);
        PNOTIFICATION_ITEM Notification =
            CONTAINING_RECORD(ListEntry, NOTIFICATION_ITEM, ListEntry);
        DeleteNotification(Notification);
    }
}

Referenced by WinMain().

DeleteNotification()

static VOID DeleteNotification ( _In_ PNOTIFICATION_ITEM  Notification )

static

Frees the resources associated to a notification.

Definition at line 155 of file notify.c.

{
    if (Notification->hModule)
        FreeLibrary(Notification->hModule);
 
    if (Notification->pszKeyName)
        RtlFreeHeap(RtlGetProcessHeap(), 0, Notification->pszKeyName);
 
    if (Notification->pszDllName)
        RtlFreeHeap(RtlGetProcessHeap(), 0, Notification->pszDllName);
 
    RtlFreeHeap(RtlGetProcessHeap(), 0, Notification);
}

Referenced by AddNotificationDll(), AddSfcNotification(), and CleanupNotifications().

GetNotificationHandler()

static PWLX_NOTIFY_HANDLER GetNotificationHandler ( _In_ HKEY  hDllKey, _In_ HMODULE  hModule, _In_ PCSTR  pNotification  )

static

Retrieves the address of the exported notification handler, specified in the registry entry for the notification DLL.

Definition at line 61 of file notify.c.

{
    LONG lError;
    DWORD dwType, dwSize;
    CHAR szFuncBuffer[128];
 
    dwSize = sizeof(szFuncBuffer);
    lError = RegQueryValueExA(hDllKey,
                              pNotification,
                              NULL,
                              &dwType,
                              (PBYTE)szFuncBuffer,
                              &dwSize);
    if ((lError != ERROR_SUCCESS) ||
        (dwType != REG_SZ && dwType != REG_EXPAND_SZ) || (dwSize == 0))
    {
        return NULL;
    }
 
    /* NUL-terminate */
    szFuncBuffer[dwSize / sizeof(CHAR) - 1] = ANSI_NULL;
 
    return (PWLX_NOTIFY_HANDLER)GetProcAddress(hModule, szFuncBuffer);
}

Referenced by LoadNotifyDll().

InitNotifications()

BOOL InitNotifications

(

VOID

)

Definition at line 420 of file notify.c.

{
    HKEY hNotifyKey = NULL;
    LONG lError;
    DWORD dwIndex;
    DWORD dwKeyName;
    WCHAR szKeyName[80];
 
    TRACE("InitNotifications()\n");
 
    InitializeListHead(&NotificationDllListHead);
 
    AddSfcNotification();
 
    lError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                           L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon\\Notify",
                           0,
                           KEY_READ,
                           &hNotifyKey);
    if (lError != ERROR_SUCCESS)
    {
        TRACE("RegOpenKeyExW()\n");
        return TRUE;
    }
 
    for (dwIndex = 0; ; ++dwIndex)
    {
        dwKeyName = ARRAYSIZE(szKeyName);
        lError = RegEnumKeyExW(hNotifyKey,
                               dwIndex,
                               szKeyName,
                               &dwKeyName,
                               NULL,
                               NULL,
                               NULL,
                               NULL);
        if (lError != ERROR_SUCCESS)
            break;
 
        TRACE("Notification DLL: %S\n", szKeyName);
        AddNotificationDll(hNotifyKey, szKeyName);
    }
 
    RegCloseKey(hNotifyKey);
 
    TRACE("InitNotifications() done\n");
 
    return TRUE;
}

Referenced by WinMain().

LoadNotifyDll()

static BOOL LoadNotifyDll ( _Inout_ PNOTIFICATION_ITEM  NotificationDll )

static

Loads the notification DLL and retrieves its exported notification handlers.

Definition at line 95 of file notify.c.

{
    HKEY hNotifyKey, hDllKey;
    HMODULE hModule;
    LONG lError;
    NOTIFICATION_TYPE Type;
 
    if (NotificationDll->bSfcNotification)
        return TRUE; // Already loaded.
 
    lError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                           L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon\\Notify",
                           0,
                           KEY_READ,
                           &hNotifyKey);
    if (lError != ERROR_SUCCESS)
    {
        ERR("RegOpenKeyExW(Winlogon\\Notify) failed, Error %lu\n", lError);
        return FALSE;
    }
 
    lError = RegOpenKeyExW(hNotifyKey,
                           NotificationDll->pszKeyName,
                           0,
                           KEY_READ,
                           &hDllKey);
    RegCloseKey(hNotifyKey);
 
    if (lError != ERROR_SUCCESS)
    {
        ERR("RegOpenKeyExW(%S) failed, Error %lu\n", NotificationDll->pszKeyName, lError);
        return FALSE;
    }
 
    hModule = LoadLibraryW(NotificationDll->pszDllName);
    if (!hModule)
    {
        ERR("LoadLibraryW(%S) failed, Error %lu\n", NotificationDll->pszDllName, GetLastError());
        RegCloseKey(hDllKey);
        return FALSE;
    }
    NotificationDll->hModule = hModule;
 
    for (Type = LogonHandler; Type < LastHandler; ++Type)
    {
        NotificationDll->Handler[Type] = GetNotificationHandler(hDllKey, hModule, FuncNames[Type]);
        TRACE("%s: %p\n", FuncNames[Type], NotificationDll->Handler[Type]);
    }
 
    RegCloseKey(hDllKey);
    return TRUE;
}

Referenced by CallNotificationDll().

Variable Documentation

FuncNames

PSTR FuncNames[LastHandler]

static

Initial value:

=
{
    "Logon",
    "Logoff",
    "Lock",
    "Unlock",
    "Startup",
    "Shutdown",
    "StartScreenSaver",
    "StopScreenSaver",
    "Disconnect",
    "Reconnect",
    "StartShell",
    "PostShell"
}

Definition at line 17 of file notify.c.

Referenced by CallNotificationDll(), CallNotificationDlls(), and LoadNotifyDll().

NotificationDllListHead

LIST_ENTRY NotificationDllListHead

static

Definition at line 49 of file notify.c.

Referenced by AddNotificationDll(), AddSfcNotification(), CallNotificationDlls(), CleanupNotifications(), and InitNotifications().