winlogon.h File Reference

#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <wingdi.h>
#include <winuser.h>
#include <winreg.h>
#include <winwlx.h>
#include <ndk/rtlfuncs.h>
#include <ndk/exfuncs.h>
#include <strsafe.h>
#include <reactos/undocuser.h>
#include <reactos/undocmpr.h>
#include <wine/debug.h>
#include "resource.h"

Include dependency graph for winlogon.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_GINAFUNCTIONS
struct	_GINAINSTANCE
struct	_WLSESSION

Macros
#define	USE_GETLASTINPUTINFO
#define	WIN32_NO_STATUS
#define	LockWorkstation(Session)
#define	UnlockWorkstation(Session)
#define	WLX_SHUTTINGDOWN(Status)
#define	WLX_SUSPENDING(Status)

Typedefs
typedef BOOL(WINAPI *	PFWLXNEGOTIATE) (DWORD, DWORD *)
typedef BOOL(WINAPI *	PFWLXINITIALIZE) (LPWSTR, HANDLE, PVOID, PVOID, PVOID *)
typedef VOID(WINAPI *	PFWLXDISPLAYSASNOTICE) (PVOID)
typedef int(WINAPI *	PFWLXLOGGEDOUTSAS) (PVOID, DWORD, PLUID, PSID, PDWORD, PHANDLE, PWLX_MPR_NOTIFY_INFO, PVOID *)
typedef BOOL(WINAPI *	PFWLXACTIVATEUSERSHELL) (PVOID, PWSTR, PWSTR, PVOID)
typedef int(WINAPI *	PFWLXLOGGEDONSAS) (PVOID, DWORD, PVOID)
typedef VOID(WINAPI *	PFWLXDISPLAYLOCKEDNOTICE) (PVOID)
typedef int(WINAPI *	PFWLXWKSTALOCKEDSAS) (PVOID, DWORD)
typedef BOOL(WINAPI *	PFWLXISLOCKOK) (PVOID)
typedef BOOL(WINAPI *	PFWLXISLOGOFFOK) (PVOID)
typedef VOID(WINAPI *	PFWLXLOGOFF) (PVOID)
typedef VOID(WINAPI *	PFWLXSHUTDOWN) (PVOID, DWORD)
typedef BOOL(WINAPI *	PFWLXSCREENSAVERNOTIFY) (PVOID, BOOL *)
typedef BOOL(WINAPI *	PFWLXSTARTAPPLICATION) (PVOID, PWSTR, PVOID, PWSTR)
typedef BOOL(WINAPI *	PFWLXNETWORKPROVIDERLOAD) (PVOID, PWLX_MPR_NOTIFY_INFO)
typedef BOOL(WINAPI *	PFWLXDISPLAYSTATUSMESSAGE) (PVOID, HDESK, DWORD, PWSTR, PWSTR)
typedef BOOL(WINAPI *	PFWLXGETSTATUSMESSAGE) (PVOID, DWORD *, PWSTR, DWORD)
typedef BOOL(WINAPI *	PFWLXREMOVESTATUSMESSAGE) (PVOID)
typedef struct _GINAFUNCTIONS	GINAFUNCTIONS
typedef struct _GINAFUNCTIONS *	PGINAFUNCTIONS
typedef struct _GINAINSTANCE	GINAINSTANCE
typedef struct _GINAINSTANCE *	PGINAINSTANCE
typedef enum _LOGON_STATE	LOGON_STATE
typedef enum _LOGON_STATE *	PLOGON_STATE
typedef struct _WLSESSION	WLSESSION
typedef struct _WLSESSION *	PWLSESSION
typedef enum _NOTIFICATION_TYPE	NOTIFICATION_TYPE
typedef enum _NOTIFICATION_TYPE *	PNOTIFICATION_TYPE

Enumerations
enum	_LOGON_STATE {   STATE_INIT, STATE_LOGGED_OFF, STATE_LOGGED_OFF_SAS, STATE_LOGGED_ON,   STATE_LOGGED_ON_SAS, STATE_LOCKED, STATE_LOCKED_SAS, STATE_LOGGING_OFF,   STATE_SHUTTING_DOWN, STATE_SHUT_DOWN, STATE_SCREENSAVER }
enum	_NOTIFICATION_TYPE {   LogonHandler, LogoffHandler, LockHandler, UnlockHandler,   StartupHandler, ShutdownHandler, StartScreenSaverHandler, StopScreenSaverHandler,   DisconnectHandler, ReconnectHandler, StartShellHandler, PostShellHandler,   LastHandler }

Functions
BOOL WINAPI	SetWindowStationUser (IN HWINSTA hWindowStation, IN PLUID pluid, IN PSID psid OPTIONAL, IN DWORD size)
	WINE_DEFAULT_DEBUG_CHANNEL (winlogon)
BOOL	CreateUserEnvironment (IN PWLSESSION Session)
BOOL	InitNotifications (VOID)
VOID	CleanupNotifications (VOID)
VOID	CallNotificationDlls (PWLSESSION pSession, NOTIFICATION_TYPE Type)
BOOL	StartRpcServer (VOID)
BOOL	SetDefaultLanguage (IN PWLSESSION Session)
NTSTATUS	HandleShutdown (IN OUT PWLSESSION Session, IN DWORD wlxAction)
BOOL	InitializeSAS (IN OUT PWLSESSION Session)
BOOL	InitializeScreenSaver (IN OUT PWLSESSION Session)
VOID	StartScreenSaver (IN PWLSESSION Session)
PSECURITY_DESCRIPTOR	ConvertToSelfRelative (_In_ PSECURITY_DESCRIPTOR AbsoluteSd)
	Converts an absolute security descriptor to a self-relative format. More...
BOOL	CreateWinstaSecurity (_Out_ PSECURITY_DESCRIPTOR *WinstaSd)
	Creates a security descriptor for the default window station upon its creation. More...
BOOL	CreateApplicationDesktopSecurity (_Out_ PSECURITY_DESCRIPTOR *ApplicationDesktopSd)
	Creates a security descriptor for the default application desktop upon its creation. More...
BOOL	CreateWinlogonDesktopSecurity (_Out_ PSECURITY_DESCRIPTOR *WinlogonDesktopSd)
	Creates a security descriptor for the default Winlogon desktop. This descriptor serves as a security measure for the winlogon desktop so that only Winlogon itself (and admins) can interact with it. More...
BOOL	CreateScreenSaverSecurity (_Out_ PSECURITY_DESCRIPTOR *ScreenSaverDesktopSd)
	Creates a security descriptor for the screen saver desktop. More...
BOOL	AllowWinstaAccessToUser (_In_ HWINSTA WinSta, _In_ PSID LogonSid)
	Assigns access to the specific logon user to the default window station. Such access is given to the user when it has logged in. More...
BOOL	AllowDesktopAccessToUser (_In_ HDESK Desktop, _In_ PSID LogonSid)
	Assigns access to the specific logon user to the default desktop. Such access is given to the user when it has logged in. More...
BOOL	AllowAccessOnSession (_In_ PWLSESSION Session)
	Assigns both window station and desktop access to the specific session currently active on the system. More...
DWORD	GetSetupType (VOID)
BOOL	RunSetup (VOID)
DWORD	TerminateSystemShutdown (VOID)
DWORD	StartSystemShutdown (IN PUNICODE_STRING pMessage, IN ULONG dwTimeout, IN BOOLEAN bForceAppsClosed, IN BOOLEAN bRebootAfterShutdown, IN ULONG dwReason)
BOOL	PlaySoundRoutine (IN LPCWSTR FileName, IN UINT Logon, IN UINT Flags)
BOOL	DisplayStatusMessage (IN PWLSESSION Session, IN HDESK hDesktop, IN UINT ResourceId)
BOOL	RemoveStatusMessage (IN PWLSESSION Session)
VOID	InitDialogListHead (VOID)
VOID	CloseAllDialogWindows (VOID)
BOOL	GinaInit (IN OUT PWLSESSION Session)
BOOL	CreateWindowStationAndDesktops (_Inout_ PWLSESSION Session)
VOID WINAPI	WlxUseCtrlAltDel (HANDLE hWlx)
VOID WINAPI	WlxSetContextPointer (HANDLE hWlx, PVOID pWlxContext)
VOID WINAPI	WlxSasNotify (HANDLE hWlx, DWORD dwSasType)
BOOL WINAPI	WlxSetTimeout (HANDLE hWlx, DWORD Timeout)
int WINAPI	WlxAssignShellProtection (HANDLE hWlx, HANDLE hToken, HANDLE hProcess, HANDLE hThread)
int WINAPI	WlxMessageBox (HANDLE hWlx, HWND hwndOwner, LPWSTR lpszText, LPWSTR lpszTitle, UINT fuStyle)
int WINAPI	WlxDialogBox (HANDLE hWlx, HANDLE hInst, LPWSTR lpszTemplate, HWND hwndOwner, DLGPROC dlgprc)
int WINAPI	WlxDialogBoxParam (HANDLE hWlx, HANDLE hInst, LPWSTR lpszTemplate, HWND hwndOwner, DLGPROC dlgprc, LPARAM dwInitParam)
int WINAPI	WlxDialogBoxIndirect (HANDLE hWlx, HANDLE hInst, LPCDLGTEMPLATE hDialogTemplate, HWND hwndOwner, DLGPROC dlgprc)
int WINAPI	WlxDialogBoxIndirectParam (HANDLE hWlx, HANDLE hInst, LPCDLGTEMPLATE hDialogTemplate, HWND hwndOwner, DLGPROC dlgprc, LPARAM dwInitParam)
int WINAPI	WlxSwitchDesktopToUser (HANDLE hWlx)
int WINAPI	WlxSwitchDesktopToWinlogon (HANDLE hWlx)
int WINAPI	WlxChangePasswordNotify (HANDLE hWlx, PWLX_MPR_NOTIFY_INFO pMprInfo, DWORD dwChangeInfo)
BOOL WINAPI	WlxGetSourceDesktop (HANDLE hWlx, PWLX_DESKTOP *ppDesktop)
BOOL WINAPI	WlxSetReturnDesktop (HANDLE hWlx, PWLX_DESKTOP pDesktop)
BOOL WINAPI	WlxCreateUserDesktop (HANDLE hWlx, HANDLE hToken, DWORD Flags, PWSTR pszDesktopName, PWLX_DESKTOP *ppDesktop)
int WINAPI	WlxChangePasswordNotifyEx (HANDLE hWlx, PWLX_MPR_NOTIFY_INFO pMprInfo, DWORD dwChangeInfo, PWSTR ProviderName, PVOID Reserved)
BOOL WINAPI	WlxCloseUserDesktop (HANDLE hWlx, PWLX_DESKTOP pDesktop, HANDLE hToken)
BOOL WINAPI	WlxSetOption (HANDLE hWlx, DWORD Option, ULONG_PTR Value, ULONG_PTR *OldValue)
BOOL WINAPI	WlxGetOption (HANDLE hWlx, DWORD Option, ULONG_PTR *Value)
VOID WINAPI	WlxWin31Migrate (HANDLE hWlx)
BOOL WINAPI	WlxQueryClientCredentials (PWLX_CLIENT_CREDENTIALS_INFO_V1_0 pCred)
BOOL WINAPI	WlxQueryInetConnectorCredentials (PWLX_CLIENT_CREDENTIALS_INFO_V1_0 pCred)
DWORD WINAPI	WlxQueryConsoleSwitchCredentials (PWLX_CONSOLESWITCH_CREDENTIALS_INFO_V1_0 pCred)
BOOL WINAPI	WlxQueryTsLogonCredentials (PWLX_CLIENT_CREDENTIALS_INFO_V2_0 pCred)
BOOL WINAPI	WlxDisconnect (VOID)
DWORD WINAPI	WlxQueryTerminalServicesData (HANDLE hWlx, PWLX_TERMINAL_SERVICES_DATA pTSData, WCHAR *UserName, WCHAR *Domain)

Variables
HINSTANCE	hAppInstance
PWLSESSION	WLSession
LUID	LuidNone

Macro Definition Documentation

LockWorkstation

#define LockWorkstation

(

Session

)

Definition at line 211 of file winlogon.h.

UnlockWorkstation

#define UnlockWorkstation

(

Session

)

Definition at line 212 of file winlogon.h.

USE_GETLASTINPUTINFO

#define USE_GETLASTINPUTINFO

Definition at line 31 of file winlogon.h.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 33 of file winlogon.h.

WLX_SHUTTINGDOWN

#define WLX_SHUTTINGDOWN

(

Status

)

Value:

(((Status) == WLX_SAS_ACTION_SHUTDOWN) || \
   ((Status) == WLX_SAS_ACTION_SHUTDOWN_POWER_OFF) || \
   ((Status) == WLX_SAS_ACTION_SHUTDOWN_REBOOT) \
  )

Definition at line 271 of file winlogon.h.

WLX_SUSPENDING

#define WLX_SUSPENDING

(

Status

)

Value:

(((Status) == WLX_SAS_ACTION_SHUTDOWN_SLEEP) || \
   ((Status) == WLX_SAS_ACTION_SHUTDOWN_SLEEP2) || \
   ((Status) == WLX_SAS_ACTION_SHUTDOWN_HIBERNATE) \
  )

Definition at line 277 of file winlogon.h.

Typedef Documentation

GINAFUNCTIONS

typedef struct _GINAFUNCTIONS GINAFUNCTIONS

GINAINSTANCE

typedef struct _GINAINSTANCE GINAINSTANCE

LOGON_STATE

typedef enum _LOGON_STATE LOGON_STATE

NOTIFICATION_TYPE

typedef enum _NOTIFICATION_TYPE NOTIFICATION_TYPE

PFWLXACTIVATEUSERSHELL

typedef BOOL(WINAPI * PFWLXACTIVATEUSERSHELL) (PVOID, PWSTR, PWSTR, PVOID)

Definition at line 66 of file winlogon.h.

PFWLXDISPLAYLOCKEDNOTICE

typedef VOID(WINAPI * PFWLXDISPLAYLOCKEDNOTICE) (PVOID)

Definition at line 68 of file winlogon.h.

PFWLXDISPLAYSASNOTICE

typedef VOID(WINAPI * PFWLXDISPLAYSASNOTICE) (PVOID)

Definition at line 62 of file winlogon.h.

PFWLXDISPLAYSTATUSMESSAGE

typedef BOOL(WINAPI * PFWLXDISPLAYSTATUSMESSAGE) (PVOID, HDESK, DWORD, PWSTR, PWSTR)

Definition at line 83 of file winlogon.h.

PFWLXGETSTATUSMESSAGE

typedef BOOL(WINAPI * PFWLXGETSTATUSMESSAGE) (PVOID, DWORD *, PWSTR, DWORD)

Definition at line 84 of file winlogon.h.

PFWLXINITIALIZE

typedef BOOL(WINAPI * PFWLXINITIALIZE) (LPWSTR, HANDLE, PVOID, PVOID, PVOID *)

Definition at line 61 of file winlogon.h.

PFWLXISLOCKOK

typedef BOOL(WINAPI * PFWLXISLOCKOK) (PVOID)

Definition at line 70 of file winlogon.h.

PFWLXISLOGOFFOK

typedef BOOL(WINAPI * PFWLXISLOGOFFOK) (PVOID)

Definition at line 71 of file winlogon.h.

PFWLXLOGGEDONSAS

typedef int(WINAPI * PFWLXLOGGEDONSAS) (PVOID, DWORD, PVOID)

Definition at line 67 of file winlogon.h.

PFWLXLOGGEDOUTSAS

typedef int(WINAPI * PFWLXLOGGEDOUTSAS) (PVOID, DWORD, PLUID, PSID, PDWORD, PHANDLE, PWLX_MPR_NOTIFY_INFO, PVOID *)

Definition at line 63 of file winlogon.h.

PFWLXLOGOFF

typedef VOID(WINAPI * PFWLXLOGOFF) (PVOID)

Definition at line 72 of file winlogon.h.

PFWLXNEGOTIATE

typedef BOOL(WINAPI * PFWLXNEGOTIATE) (DWORD, DWORD *)

Definition at line 60 of file winlogon.h.

PFWLXNETWORKPROVIDERLOAD

typedef BOOL(WINAPI * PFWLXNETWORKPROVIDERLOAD) (PVOID, PWLX_MPR_NOTIFY_INFO)

Definition at line 82 of file winlogon.h.

PFWLXREMOVESTATUSMESSAGE

typedef BOOL(WINAPI * PFWLXREMOVESTATUSMESSAGE) (PVOID)

Definition at line 85 of file winlogon.h.

PFWLXSCREENSAVERNOTIFY

typedef BOOL(WINAPI * PFWLXSCREENSAVERNOTIFY) (PVOID, BOOL *)

Definition at line 77 of file winlogon.h.

PFWLXSHUTDOWN

typedef VOID(WINAPI * PFWLXSHUTDOWN) (PVOID, DWORD)

Definition at line 73 of file winlogon.h.

PFWLXSTARTAPPLICATION

typedef BOOL(WINAPI * PFWLXSTARTAPPLICATION) (PVOID, PWSTR, PVOID, PWSTR)

Definition at line 78 of file winlogon.h.

PFWLXWKSTALOCKEDSAS

typedef int(WINAPI * PFWLXWKSTALOCKEDSAS) (PVOID, DWORD)

Definition at line 69 of file winlogon.h.

PGINAFUNCTIONS

typedef struct _GINAFUNCTIONS * PGINAFUNCTIONS

PGINAINSTANCE

typedef struct _GINAINSTANCE * PGINAINSTANCE

PLOGON_STATE

typedef enum _LOGON_STATE * PLOGON_STATE

PNOTIFICATION_TYPE

typedef enum _NOTIFICATION_TYPE * PNOTIFICATION_TYPE

PWLSESSION

typedef struct _WLSESSION * PWLSESSION

WLSESSION

typedef struct _WLSESSION WLSESSION

Enumeration Type Documentation

_LOGON_STATE

enum _LOGON_STATE

Enumerator
STATE_INIT
STATE_LOGGED_OFF
STATE_LOGGED_OFF_SAS
STATE_LOGGED_ON
STATE_LOGGED_ON_SAS
STATE_LOCKED
STATE_LOCKED_SAS
STATE_LOGGING_OFF
STATE_SHUTTING_DOWN
STATE_SHUT_DOWN
STATE_SCREENSAVER

Definition at line 196 of file winlogon.h.

{
    STATE_INIT,
    STATE_LOGGED_OFF,
    STATE_LOGGED_OFF_SAS,
    STATE_LOGGED_ON,
    STATE_LOGGED_ON_SAS,
    STATE_LOCKED,
    STATE_LOCKED_SAS,
    STATE_LOGGING_OFF,     // not used yet
    STATE_SHUTTING_DOWN,   // not used yet
    STATE_SHUT_DOWN,       // not used yet
    STATE_SCREENSAVER      // not used yet
} LOGON_STATE, *PLOGON_STATE;

_NOTIFICATION_TYPE

enum _NOTIFICATION_TYPE

Enumerator
LogonHandler
LogoffHandler
LockHandler
UnlockHandler
StartupHandler
ShutdownHandler
StartScreenSaverHandler
StopScreenSaverHandler
DisconnectHandler
ReconnectHandler
StartShellHandler
PostShellHandler
LastHandler

Definition at line 251 of file winlogon.h.

{
    LogonHandler,
    LogoffHandler,
    LockHandler,
    UnlockHandler,
    StartupHandler,
    ShutdownHandler,
    StartScreenSaverHandler,
    StopScreenSaverHandler,
    DisconnectHandler,
    ReconnectHandler,
    StartShellHandler,
    PostShellHandler,
    LastHandler
} NOTIFICATION_TYPE, *PNOTIFICATION_TYPE;

Function Documentation

AllowAccessOnSession()

BOOL AllowAccessOnSession

(

_In_ PWLSESSION

Session

)

Assigns both window station and desktop access to the specific session currently active on the system.

Parameters

[in]

Session

A pointer to an active session.

Returns

Returns TRUE if the function has successfully assigned access to the current session, FALSE otherwise.

Definition at line 1391 of file security.c.

{
    BOOL Success = FALSE;
    DWORD Index, SidLength, GroupsLength = 0;
    PTOKEN_GROUPS TokenGroup = NULL;
    PSID LogonSid;

    /* Get required buffer size and allocate the TOKEN_GROUPS buffer */
    if (!GetTokenInformation(Session->UserToken,
                             TokenGroups,
                             TokenGroup,
                             0,
                             &GroupsLength))
    {
        if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
        {
            ERR("AllowAccessOnSession(): Unexpected error code returned, must be ERROR_INSUFFICIENT_BUFFER (error code %lu)\n", GetLastError());
            return FALSE;
        }

        TokenGroup = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, GroupsLength);
        if (TokenGroup == NULL)
        {
            ERR("AllowAccessOnSession(): Failed to allocate memory buffer for token group!\n");
            return FALSE;
        }
    }

    /* Get the token group information from the access token */
    if (!GetTokenInformation(Session->UserToken,
                             TokenGroups,
                             TokenGroup,
                             GroupsLength,
                             &GroupsLength))
    {
        ERR("AllowAccessOnSession(): Failed to retrieve the token group information (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Loop through the groups to find the logon SID */
    for (Index = 0; Index < TokenGroup->GroupCount; Index++)
    {
        if ((TokenGroup->Groups[Index].Attributes & SE_GROUP_LOGON_ID)
            == SE_GROUP_LOGON_ID)
        {
            LogonSid = TokenGroup->Groups[Index].Sid;
            break;
        }
    }

    /* Allow window station access to this user within this session */
    if (!AllowWinstaAccessToUser(Session->InteractiveWindowStation, LogonSid))
    {
        ERR("AllowAccessOnSession(): Failed to allow winsta access to the logon user!\n");
        goto Quit;
    }

    /* Allow application desktop access to this user within this session */
    if (!AllowDesktopAccessToUser(Session->ApplicationDesktop, LogonSid))
    {
        ERR("AllowAccessOnSession(): Failed to allow application desktop access to the logon user!\n");
        goto Quit;
    }

    /* Get the length of this logon SID */
    SidLength = GetLengthSid(LogonSid);

    /* Assign the window station to this logged in user */
    if (!SetWindowStationUser(Session->InteractiveWindowStation,
                              &Session->LogonId,
                              LogonSid,
                              SidLength))
    {
        ERR("AllowAccessOnSession(): Failed to assign the window station to the logon user!\n");
        goto Quit;
    }

    Success = TRUE;

Quit:
    if (TokenGroup != NULL)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, TokenGroup);
    }

    return Success;
}

Referenced by HandleLogon().

AllowDesktopAccessToUser()

BOOL AllowDesktopAccessToUser	(	_In_ HDESK	Desktop,
		_In_ PSID	LogonSid
	)

Assigns access to the specific logon user to the default desktop. Such access is given to the user when it has logged in.

Parameters

[in]	Desktop	A handle to a desktop where the user is given access to it.
[in]	LogonSid	A pointer to a logon SID that represents the logged in user in question.

Returns

Returns TRUE if the function has successfully assigned access to the user, FALSE otherwise.

Definition at line 1165 of file security.c.

{
    BOOL Success = FALSE;
    SECURITY_DESCRIPTOR AbsoluteSd;
    PSECURITY_DESCRIPTOR RelativeSd = NULL;
    PSID WinlogonSid = NULL, AdminsSid = NULL, InteractiveSid = NULL, NetworkServiceSid = NULL; /* NetworkServiceSid is a HACK, see the comment in CreateWinstaSecurity for information */
    SECURITY_INFORMATION SecurityInformation;
    DWORD DaclSize;
    PACL Dacl;

    /* Create the Winlogon SID */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  1,
                                  SECURITY_LOCAL_SYSTEM_RID,
                                  0, 0, 0, 0, 0, 0, 0,
                                  &WinlogonSid))
    {
        ERR("AllowDesktopAccessToUser(): Failed to create the Winlogon SID (error code %lu)\n", GetLastError());
        return FALSE;
    }

    /* Create the admins SID */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  2,
                                  SECURITY_BUILTIN_DOMAIN_RID,
                                  DOMAIN_ALIAS_RID_ADMINS,
                                  0, 0, 0, 0, 0, 0,
                                  &AdminsSid))
    {
        ERR("AllowDesktopAccessToUser(): Failed to create the admins SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Create the interactive logon SID */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  1,
                                  SECURITY_INTERACTIVE_RID,
                                  0, 0, 0, 0, 0, 0, 0,
                                  &InteractiveSid))
    {
        ERR("AllowDesktopAccessToUser(): Failed to create the interactive SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* HACK: Create the network service SID */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  1,
                                  SECURITY_NETWORK_SERVICE_RID,
                                  0, 0, 0, 0, 0, 0, 0,
                                  &NetworkServiceSid))
    {
        ERR("AllowDesktopAccessToUser(): Failed to create the network service SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /*
     * Build up the DACL size. This includes a number
     * of four ACEs of four different SIDs. The first ACE
     * gives full desktop access to Winlogon, the second one gives
     * generic limited desktop access to admins. The last two give
     * full power to both interactive logon users and logon user as
     * well.
     */
    DaclSize = sizeof(ACL) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(WinlogonSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(AdminsSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(InteractiveSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(LogonSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(NetworkServiceSid); /* HACK */

    /* Allocate the DACL now */
    Dacl = RtlAllocateHeap(RtlGetProcessHeap(),
                           HEAP_ZERO_MEMORY,
                           DaclSize);
    if (Dacl == NULL)
    {
        ERR("AllowDesktopAccessToUser(): Failed to allocate memory buffer for DACL!\n");
        goto Quit;
    }

    /* Initialize it */
    if (!InitializeAcl(Dacl, DaclSize, ACL_REVISION))
    {
        ERR("AllowDesktopAccessToUser(): Failed to initialize DACL (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* First ACE -- Give full desktop access to Winlogon */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               0,
                               DESKTOP_ALL,
                               WinlogonSid))
    {
        ERR("AllowDesktopAccessToUser(): Failed to set ACE for Winlogon (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Second ACE -- Give limited desktop access to admins */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               0,
                               DESKTOP_ADMINS_LIMITED,
                               AdminsSid))
    {
        ERR("AllowDesktopAccessToUser(): Failed to set ACE for admins (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Third ACE -- Give full desktop access to interactive logon users */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               0,
                               DESKTOP_ALL,
                               InteractiveSid))
    {
        ERR("AllowDesktopAccessToUser(): Failed to set ACE for interactive SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Fourth ACE -- Give full desktop access to logon user */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               0,
                               DESKTOP_ALL,
                               LogonSid))
    {
        ERR("AllowDesktopAccessToUser(): Failed to set ACE for logon user SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* HACK: Fifth ACE -- Give full desktop to network services */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               0,
                               DESKTOP_ALL,
                               NetworkServiceSid))
    {
        ERR("AllowDesktopAccessToUser(): Failed to set ACE for network service SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Initialize the security descriptor */
    if (!InitializeSecurityDescriptor(&AbsoluteSd, SECURITY_DESCRIPTOR_REVISION))
    {
        ERR("AllowDesktopAccessToUser(): Failed to initialize absolute security descriptor (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Set the DACL to the descriptor */
    if (!SetSecurityDescriptorDacl(&AbsoluteSd, TRUE, Dacl, FALSE))
    {
        ERR("AllowDesktopAccessToUser(): Failed to set up DACL to absolute security descriptor (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Conver it to self-relative format */
    RelativeSd = ConvertToSelfRelative(&AbsoluteSd);
    if (RelativeSd == NULL)
    {
        ERR("AllowDesktopAccessToUser(): Failed to convert security descriptor to self relative format!\n");
        goto Quit;
    }

    /* Assign new security to desktop based on this descriptor */
    SecurityInformation = DACL_SECURITY_INFORMATION;
    if (!SetUserObjectSecurity(Desktop, &SecurityInformation, RelativeSd))
    {
        ERR("AllowDesktopAccessToUser(): Failed to set desktop security descriptor (error code %lu)\n", GetLastError());
        goto Quit;
    }

    Success = TRUE;

Quit:
    if (WinlogonSid != NULL)
    {
        FreeSid(WinlogonSid);
    }

    if (AdminsSid != NULL)
    {
        FreeSid(AdminsSid);
    }

    if (InteractiveSid != NULL)
    {
        FreeSid(InteractiveSid);
    }

    /* HACK */
    if (NetworkServiceSid != NULL)
    {
        FreeSid(NetworkServiceSid);
    }
    /* END HACK */

    if (Dacl != NULL)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, Dacl);
    }

    if (RelativeSd != NULL)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, RelativeSd);
    }

    return Success;
}

Referenced by AllowAccessOnSession().

AllowWinstaAccessToUser()

BOOL AllowWinstaAccessToUser	(	_In_ HWINSTA	WinSta,
		_In_ PSID	LogonSid
	)

Assigns access to the specific logon user to the default window station. Such access is given to the user when it has logged in.

Parameters

[in]	WinSta	A handle to a window station where the user is given access to it.
[in]	LogonSid	A pointer to a logon SID that represents the logged in user in question.

Returns

Returns TRUE if the function has successfully assigned access to the user, FALSE otherwise.

Definition at line 874 of file security.c.

{
    BOOL Success = FALSE;
    SECURITY_DESCRIPTOR AbsoluteSd;
    PSECURITY_DESCRIPTOR RelativeSd = NULL;
    PSID WinlogonSid = NULL, AdminsSid = NULL, InteractiveSid = NULL, NetworkServiceSid = NULL; /* NetworkServiceSid is a HACK, see the comment in CreateWinstaSecurity for information */
    SECURITY_INFORMATION SecurityInformation;
    DWORD DaclSize;
    PACL Dacl;

    /* Create the Winlogon SID */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  1,
                                  SECURITY_LOCAL_SYSTEM_RID,
                                  0, 0, 0, 0, 0, 0, 0,
                                  &WinlogonSid))
    {
        ERR("AllowWinstaAccessToUser(): Failed to create the Winlogon SID (error code %lu)\n", GetLastError());
        return FALSE;
    }

    /* Create the admins SID */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  2,
                                  SECURITY_BUILTIN_DOMAIN_RID,
                                  DOMAIN_ALIAS_RID_ADMINS,
                                  0, 0, 0, 0, 0, 0,
                                  &AdminsSid))
    {
        ERR("AllowWinstaAccessToUser(): Failed to create the admins SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Create the interactive logon SID */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  1,
                                  SECURITY_INTERACTIVE_RID,
                                  0, 0, 0, 0, 0, 0, 0,
                                  &InteractiveSid))
    {
        ERR("AllowWinstaAccessToUser(): Failed to create the interactive SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* HACK: Create the network service SID */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  1,
                                  SECURITY_NETWORK_SERVICE_RID,
                                  0, 0, 0, 0, 0, 0, 0,
                                  &NetworkServiceSid))
    {
        ERR("AllowWinstaAccessToUser(): Failed to create the network service SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /*
     * Build up the DACL size. This includes a number
     * of eight ACEs of four different SIDs. The first ACE
     * gives full winsta access to Winlogon, the second one gives
     * generic access to Winlogon. Such approach is the same
     * for both interactive logon users and logon user as well.
     * Only admins are given limited powers.
     */
    DaclSize = sizeof(ACL) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(WinlogonSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(WinlogonSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(AdminsSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(AdminsSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(InteractiveSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(InteractiveSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(LogonSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(LogonSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(NetworkServiceSid) + /* HACK */
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(NetworkServiceSid);

    /* Allocate the DACL now */
    Dacl = RtlAllocateHeap(RtlGetProcessHeap(),
                           HEAP_ZERO_MEMORY,
                           DaclSize);
    if (Dacl == NULL)
    {
        ERR("AllowWinstaAccessToUser(): Failed to allocate memory buffer for DACL!\n");
        goto Quit;
    }

    /* Initialize it */
    if (!InitializeAcl(Dacl, DaclSize, ACL_REVISION))
    {
        ERR("AllowWinstaAccessToUser(): Failed to initialize DACL (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* First ACE -- Give full winsta access to Winlogon */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               NO_PROPAGATE_INHERIT_ACE,
                               WINSTA_ALL,
                               WinlogonSid))
    {
        ERR("AllowWinstaAccessToUser(): Failed to set ACE for Winlogon (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Second ACE -- Give generic access to Winlogon */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               INHERIT_ONLY_ACE | OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE,
                               GENERIC_ACCESS,
                               WinlogonSid))
    {
        ERR("AllowWinstaAccessToUser(): Failed to set ACE for Winlogon (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Third ACE -- Give limited winsta access to admins */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               NO_PROPAGATE_INHERIT_ACE,
                               WINSTA_ADMINS_LIMITED,
                               AdminsSid))
    {
        ERR("AllowWinstaAccessToUser(): Failed to set ACE for admins (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Fourth ACE -- Give limited desktop access to admins */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               INHERIT_ONLY_ACE | OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE,
                               DESKTOP_ADMINS_LIMITED,
                               AdminsSid))
    {
        ERR("AllowWinstaAccessToUser(): Failed to set ACE for admins (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Fifth ACE -- Give full winsta access to interactive logon users */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               NO_PROPAGATE_INHERIT_ACE,
                               WINSTA_ALL,
                               InteractiveSid))
    {
        ERR("AllowWinstaAccessToUser(): Failed to set ACE for interactive SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Sixth ACE -- Give generic access to interactive logon users */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               INHERIT_ONLY_ACE | OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE,
                               GENERIC_ACCESS,
                               InteractiveSid))
    {
        ERR("AllowWinstaAccessToUser(): Failed to set ACE for interactive SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Seventh ACE -- Give full winsta access to logon user */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               NO_PROPAGATE_INHERIT_ACE,
                               WINSTA_ALL,
                               LogonSid))
    {
        ERR("AllowWinstaAccessToUser(): Failed to set ACE for logon user SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Eighth ACE -- Give generic access to logon user */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               INHERIT_ONLY_ACE | OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE,
                               GENERIC_ACCESS,
                               LogonSid))
    {
        ERR("AllowWinstaAccessToUser(): Failed to set ACE for logon user SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* HACK : Ninenth ACE -- Give full winsta access to network services */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               NO_PROPAGATE_INHERIT_ACE,
                               WINSTA_ALL,
                               NetworkServiceSid))
    {
        ERR("AllowWinstaAccessToUser(): Failed to set ACE for logon network service SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* HACK: Tenth ACE -- Give generic access to network services */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               INHERIT_ONLY_ACE | OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE,
                               GENERIC_ACCESS,
                               NetworkServiceSid))
    {
        ERR("AllowWinstaAccessToUser(): Failed to set ACE for network service SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Initialize the security descriptor */
    if (!InitializeSecurityDescriptor(&AbsoluteSd, SECURITY_DESCRIPTOR_REVISION))
    {
        ERR("AllowWinstaAccessToUser(): Failed to initialize absolute security descriptor (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Set the DACL to descriptor */
    if (!SetSecurityDescriptorDacl(&AbsoluteSd, TRUE, Dacl, FALSE))
    {
        ERR("AllowWinstaAccessToUser(): Failed to set up DACL to absolute security descriptor (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Convert it to self-relative format */
    RelativeSd = ConvertToSelfRelative(&AbsoluteSd);
    if (RelativeSd == NULL)
    {
        ERR("AllowWinstaAccessToUser(): Failed to convert security descriptor to self relative format!\n");
        goto Quit;
    }

    /* Set new winsta security based on this descriptor */
    SecurityInformation = DACL_SECURITY_INFORMATION;
    if (!SetUserObjectSecurity(WinSta, &SecurityInformation, RelativeSd))
    {
        ERR("AllowWinstaAccessToUser(): Failed to set window station security descriptor (error code %lu)\n", GetLastError());
        goto Quit;
    }

    Success = TRUE;

Quit:
    if (WinlogonSid != NULL)
    {
        FreeSid(WinlogonSid);
    }

    if (AdminsSid != NULL)
    {
        FreeSid(AdminsSid);
    }

    if (InteractiveSid != NULL)
    {
        FreeSid(InteractiveSid);
    }

    /* HACK */
    if (NetworkServiceSid != NULL)
    {
        FreeSid(NetworkServiceSid);
    }
    /* END HACK */

    if (Dacl != NULL)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, Dacl);
    }

    if (RelativeSd != NULL)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, RelativeSd);
    }

    return Success;
}

Referenced by AllowAccessOnSession().

CallNotificationDlls()

VOID CallNotificationDlls	(	PWLSESSION	pSession,
		NOTIFICATION_TYPE	Type
	)

Definition at line 380 of file notify.c.

{
    PLIST_ENTRY ListEntry;
    PNOTIFICATION_ITEM NotificationDll;
    WLX_NOTIFICATION_INFO Info;
    HKEY hNotifyKey = NULL;
    DWORD dwError;

    TRACE("CallNotificationDlls()\n");

    dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                            L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon\\Notify",
                            0,
                            KEY_READ | KEY_ENUMERATE_SUB_KEYS,
                            &hNotifyKey);
    if (dwError != ERROR_SUCCESS)
    {
        TRACE("RegOpenKeyExW()\n");
        return;
    }

    Info.Size = sizeof(WLX_NOTIFICATION_INFO);

    switch (Type)
    {
        case LogoffHandler:
        case ShutdownHandler:
            Info.Flags = 3;
            break;

        default:
            Info.Flags = 0;
            break;
    }

    Info.UserName = NULL; //UserName;
    Info.Domain = NULL; //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;

    ListEntry = NotificationDllListHead.Flink;
    while (ListEntry != &NotificationDllListHead)
    {
TRACE("ListEntry %p\n", ListEntry);

        NotificationDll = CONTAINING_RECORD(ListEntry,
                                            NOTIFICATION_ITEM,
                                            ListEntry);
TRACE("NotificationDll: %p\n", NotificationDll);
        if (NotificationDll != NULL && NotificationDll->bEnabled)
            CallNotificationDll(hNotifyKey, NotificationDll, Type, &Info);

        ListEntry = ListEntry->Flink;
    }

    RegCloseKey(hNotifyKey);
}

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

CleanupNotifications()

VOID CleanupNotifications

(

VOID

)

Definition at line 460 of file notify.c.

{
    PLIST_ENTRY ListEntry;
    PNOTIFICATION_ITEM NotificationDll;

    ListEntry = NotificationDllListHead.Flink;
    while (ListEntry != &NotificationDllListHead)
    {
        NotificationDll = CONTAINING_RECORD(ListEntry,
                                            NOTIFICATION_ITEM,
                                            ListEntry);
        if (NotificationDll != NULL)
        {
            if (NotificationDll->pszKeyName != NULL)
                RtlFreeHeap(RtlGetProcessHeap(), 0, NotificationDll->pszKeyName);

            if (NotificationDll->pszDllName != NULL)
                RtlFreeHeap(RtlGetProcessHeap(), 0, NotificationDll->pszDllName);
        }

        ListEntry = ListEntry->Flink;

        RemoveEntryList(&NotificationDll->ListEntry);

        RtlFreeHeap(RtlGetProcessHeap(), 0, NotificationDll);
    }
}

Referenced by WinMain().

CloseAllDialogWindows()

VOID CloseAllDialogWindows

(

VOID

)

Definition at line 95 of file wlx.c.

{
    PDIALOG_LIST_ENTRY Current;
    PLIST_ENTRY ListEntry;

    ListEntry = DialogListHead.Flink;
    while (ListEntry != &DialogListHead)
    {
        Current = CONTAINING_RECORD(ListEntry,
                                    DIALOG_LIST_ENTRY,
                                    Entry);

        PostMessage(Current->hWnd, WLX_WM_SAS, 0, 0);

        ListEntry = ListEntry->Flink;
    }
}

Referenced by DispatchSAS().

ConvertToSelfRelative()

PSECURITY_DESCRIPTOR ConvertToSelfRelative

(

_In_ PSECURITY_DESCRIPTOR

AbsoluteSd

)

Converts an absolute security descriptor to a self-relative format.

Parameters

[in]

AbsoluteSd

A pointer to an absolute security descriptor to be converted.

Returns

Returns a pointer to a converted security descriptor in self-relative format. If the function fails, NULL is returned otherwise.

Remarks

The function allocates the security descriptor buffer in memory heap, the caller is entirely responsible for freeing such buffer from when it's no longer needed.

Definition at line 64 of file security.c.

{
    PSECURITY_DESCRIPTOR RelativeSd;
    DWORD DescriptorLength = 0;

    /* Determine the size for our buffer to allocate */
    if (!MakeSelfRelativeSD(AbsoluteSd, NULL, &DescriptorLength) && GetLastError() != ERROR_INSUFFICIENT_BUFFER)
    {
        ERR("ConvertToSelfRelative(): Unexpected error code (error code %lu -- must be ERROR_INSUFFICIENT_BUFFER)\n", GetLastError());
        return NULL;
    }

    /* Allocate the buffer now */
    RelativeSd = RtlAllocateHeap(RtlGetProcessHeap(),
                                 HEAP_ZERO_MEMORY,
                                 DescriptorLength);
    if (RelativeSd == NULL)
    {
        ERR("ConvertToSelfRelative(): Failed to allocate buffer for relative SD!\n");
        return NULL;
    }

    /* Convert the security descriptor now */
    if (!MakeSelfRelativeSD(AbsoluteSd, RelativeSd, &DescriptorLength))
    {
        ERR("ConvertToSelfRelative(): Failed to convert the security descriptor to a self relative format (error code %lu)\n", GetLastError());
        RtlFreeHeap(RtlGetProcessHeap(), 0, RelativeSd);
        return NULL;
    }

    return RelativeSd;
}

Referenced by AllowDesktopAccessToUser(), AllowWinstaAccessToUser(), CreateApplicationDesktopSecurity(), CreateScreenSaverSecurity(), CreateWinlogonDesktopSecurity(), and CreateWinstaSecurity().

CreateApplicationDesktopSecurity()

BOOL CreateApplicationDesktopSecurity

(

_Out_ PSECURITY_DESCRIPTOR *

ApplicationDesktopSd

)

Creates a security descriptor for the default application desktop upon its creation.

Parameters

[out]

ApplicationDesktopSd

A pointer to a created security descriptor for the application desktop.

Returns

Returns TRUE if the function has successfully created the security descriptor, FALSE otherwise.

Definition at line 359 of file security.c.

{
    BOOL Success = FALSE;
    SECURITY_DESCRIPTOR AbsoluteSd;
    PSECURITY_DESCRIPTOR RelativeSd = NULL;
    PSID WinlogonSid = NULL, AdminsSid = NULL, NetworkServiceSid = NULL; /* NetworkServiceSid is a HACK, see the comment in CreateWinstaSecurity for information */
    DWORD DaclSize;
    PACL Dacl;

    /* Create the Winlogon SID */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  1,
                                  SECURITY_LOCAL_SYSTEM_RID,
                                  0, 0, 0, 0, 0, 0, 0,
                                  &WinlogonSid))
    {
        ERR("CreateApplicationDesktopSecurity(): Failed to create the Winlogon SID (error code %lu)\n", GetLastError());
        return FALSE;
    }

    /* Create the admins SID */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  2,
                                  SECURITY_BUILTIN_DOMAIN_RID,
                                  DOMAIN_ALIAS_RID_ADMINS,
                                  0, 0, 0, 0, 0, 0,
                                  &AdminsSid))
    {
        ERR("CreateApplicationDesktopSecurity(): Failed to create the admins SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* HACK: Create the network service SID */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  1,
                                  SECURITY_NETWORK_SERVICE_RID,
                                  0, 0, 0, 0, 0, 0, 0,
                                  &NetworkServiceSid))
    {
        ERR("CreateApplicationDesktopSecurity(): Failed to create the network service SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /*
     * Build up the DACL size. This includes a number
     * of two ACEs of two different SIDs. The first ACE
     * gives full access to Winlogon, the last one gives
     * limited desktop access to admins.
     */
    DaclSize = sizeof(ACL) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(WinlogonSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(AdminsSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(NetworkServiceSid); /* HACK */

    /* Allocate the DACL now */
    Dacl = RtlAllocateHeap(RtlGetProcessHeap(),
                           HEAP_ZERO_MEMORY,
                           DaclSize);
    if (Dacl == NULL)
    {
        ERR("CreateApplicationDesktopSecurity(): Failed to allocate memory buffer for DACL!\n");
        goto Quit;
    }

    /* Initialize it */
    if (!InitializeAcl(Dacl, DaclSize, ACL_REVISION))
    {
        ERR("CreateApplicationDesktopSecurity(): Failed to initialize DACL (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* First ACE -- Give full desktop power to Winlogon */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               0,
                               DESKTOP_ALL,
                               WinlogonSid))
    {
        ERR("CreateApplicationDesktopSecurity(): Failed to set ACE for Winlogon (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Second ACE -- Give limited desktop power to admins */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               0,
                               DESKTOP_ADMINS_LIMITED,
                               AdminsSid))
    {
        ERR("CreateApplicationDesktopSecurity(): Failed to set ACE for admins (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* HACK: Third ACE -- Give full desktop power to network services */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               0,
                               DESKTOP_ALL,
                               NetworkServiceSid))
    {
        ERR("CreateApplicationDesktopSecurity(): Failed to set ACE for network services (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Initialize the security descriptor */
    if (!InitializeSecurityDescriptor(&AbsoluteSd, SECURITY_DESCRIPTOR_REVISION))
    {
        ERR("CreateApplicationDesktopSecurity(): Failed to initialize absolute security descriptor (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Set the DACL to the descriptor */
    if (!SetSecurityDescriptorDacl(&AbsoluteSd, TRUE, Dacl, FALSE))
    {
        ERR("CreateApplicationDesktopSecurity(): Failed to set up DACL to absolute security descriptor (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Conver it to self-relative format */
    RelativeSd = ConvertToSelfRelative(&AbsoluteSd);
    if (RelativeSd == NULL)
    {
        ERR("CreateApplicationDesktopSecurity(): Failed to convert security descriptor to self relative format!\n");
        goto Quit;
    }

    /* Give the descriptor to the caller */
    *ApplicationDesktopSd = RelativeSd;
    Success = TRUE;

Quit:
    if (WinlogonSid != NULL)
    {
        FreeSid(WinlogonSid);
    }

    if (AdminsSid != NULL)
    {
        FreeSid(AdminsSid);
    }

    /* HACK */
    if (NetworkServiceSid != NULL)
    {
        FreeSid(NetworkServiceSid);
    }
    /* END HACK */

    if (Dacl != NULL)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, Dacl);
    }

    if (Success == FALSE)
    {
        if (RelativeSd != NULL)
        {
            RtlFreeHeap(RtlGetProcessHeap(), 0, RelativeSd);
        }
    }

    return Success;
}

Referenced by CreateWindowStationAndDesktops().

CreateScreenSaverSecurity()

BOOL CreateScreenSaverSecurity

(

_Out_ PSECURITY_DESCRIPTOR *

ScreenSaverDesktopSd

)

Creates a security descriptor for the screen saver desktop.

Parameters

[out]

ScreenSaverDesktopSd

A pointer to a created security descriptor for the screen-saver desktop.

Returns

Returns TRUE if the function has successfully created the security descriptor, FALSE otherwise.

Definition at line 690 of file security.c.

{
    BOOL Success = FALSE;
    SECURITY_DESCRIPTOR AbsoluteSd;
    PSECURITY_DESCRIPTOR RelativeSd = NULL;
    PSID WinlogonSid = NULL, AdminsSid = NULL, InteractiveSid = NULL;
    DWORD DaclSize;
    PACL Dacl;

    /* Create the Winlogon SID */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  1,
                                  SECURITY_LOCAL_SYSTEM_RID,
                                  0, 0, 0, 0, 0, 0, 0,
                                  &WinlogonSid))
    {
        ERR("CreateScreenSaverSecurity(): Failed to create the Winlogon SID (error code %lu)\n", GetLastError());
        return FALSE;
    }

    /* Create the admins SID */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  2,
                                  SECURITY_BUILTIN_DOMAIN_RID,
                                  DOMAIN_ALIAS_RID_ADMINS,
                                  0, 0, 0, 0, 0, 0,
                                  &AdminsSid))
    {
        ERR("CreateScreenSaverSecurity(): Failed to create the admins SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Create the interactive logon SID */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  1,
                                  SECURITY_INTERACTIVE_RID,
                                  0, 0, 0, 0, 0, 0, 0,
                                  &InteractiveSid))
    {
        ERR("CreateScreenSaverSecurity(): Failed to create the interactive SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /*
     * Build up the DACL size. This includes a number
     * of three ACEs of three different SIDs. The first ACE
     * gives full access to Winlogon, the second one gives
     * limited desktop access to admins and the last one
     * gives full desktop access to users who have logged in
     * interactively.
     */
    DaclSize = sizeof(ACL) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(WinlogonSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(AdminsSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(InteractiveSid);

    /* Allocate the DACL now */
    Dacl = RtlAllocateHeap(RtlGetProcessHeap(),
                           HEAP_ZERO_MEMORY,
                           DaclSize);
    if (Dacl == NULL)
    {
        ERR("CreateScreenSaverSecurity(): Failed to allocate memory buffer for DACL!\n");
        goto Quit;
    }

    /* Initialize it */
    if (!InitializeAcl(Dacl, DaclSize, ACL_REVISION))
    {
        ERR("CreateScreenSaverSecurity(): Failed to initialize DACL (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* First ACE -- Give full desktop access to Winlogon */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               0,
                               DESKTOP_ALL,
                               WinlogonSid))
    {
        ERR("CreateScreenSaverSecurity(): Failed to set ACE for Winlogon (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Second ACE -- Give limited desktop access to admins */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               NO_PROPAGATE_INHERIT_ACE,
                               DESKTOP_ADMINS_LIMITED,
                               AdminsSid))
    {
        ERR("CreateScreenSaverSecurity(): Failed to set ACE for admins (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Third ACE -- Give full desktop access to interactive logon users */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               NO_PROPAGATE_INHERIT_ACE,
                               DESKTOP_INTERACTIVE_LIMITED,
                               InteractiveSid))
    {
        ERR("CreateScreenSaverSecurity(): Failed to set ACE for interactive SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Initialize the security descriptor */
    if (!InitializeSecurityDescriptor(&AbsoluteSd, SECURITY_DESCRIPTOR_REVISION))
    {
        ERR("CreateScreenSaverSecurity(): Failed to initialize absolute security descriptor (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Set the DACL to the descriptor */
    if (!SetSecurityDescriptorDacl(&AbsoluteSd, TRUE, Dacl, FALSE))
    {
        ERR("CreateScreenSaverSecurity(): Failed to set up DACL to absolute security descriptor (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Conver it to self-relative format */
    RelativeSd = ConvertToSelfRelative(&AbsoluteSd);
    if (RelativeSd == NULL)
    {
        ERR("CreateScreenSaverSecurity(): Failed to convert security descriptor to self relative format!\n");
        goto Quit;
    }

    /* Give the descriptor to the caller */
    *ScreenSaverDesktopSd = RelativeSd;
    Success = TRUE;

Quit:
    if (WinlogonSid != NULL)
    {
        FreeSid(WinlogonSid);
    }

    if (AdminsSid != NULL)
    {
        FreeSid(AdminsSid);
    }

    if (InteractiveSid != NULL)
    {
        FreeSid(InteractiveSid);
    }

    if (Dacl != NULL)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, Dacl);
    }

    if (Success == FALSE)
    {
        if (RelativeSd != NULL)
        {
            RtlFreeHeap(RtlGetProcessHeap(), 0, RelativeSd);
        }
    }

    return Success;
}

Referenced by CreateWindowStationAndDesktops().

CreateUserEnvironment()

BOOL CreateUserEnvironment

(

IN PWLSESSION

Session

)

Definition at line 128 of file environment.c.

{
    HKEY hKeyCurrentUser;
    LONG lError;

    TRACE("WL: CreateUserEnvironment called\n");

    /* Impersonate the new user */
    if (!ImpersonateLoggedOnUser(Session->UserToken))
    {
        ERR("ImpersonateLoggedOnUser() failed with error %lu\n", GetLastError());
        return FALSE;
    }

    /* Open the new user HKCU key */
    lError = RegOpenCurrentUser(KEY_CREATE_SUB_KEY,
                                &hKeyCurrentUser);
    if (lError == ERROR_SUCCESS)
    {
        BuildVolatileEnvironment(Session,
                                 hKeyCurrentUser);
        RegCloseKey(hKeyCurrentUser);
    }

    /* Revert the impersonation */
    RevertToSelf();

    TRACE("WL: CreateUserEnvironment done\n");

    return TRUE;
}

Referenced by HandleLogon().

CreateWindowStationAndDesktops()

BOOL CreateWindowStationAndDesktops

(

_Inout_ PWLSESSION

Session

)

Definition at line 928 of file wlx.c.

{
    SECURITY_ATTRIBUTES WinstaSecurity;
    SECURITY_ATTRIBUTES ApplicationDesktopSecurity;
    SECURITY_ATTRIBUTES WinlogonDesktopSecurity;
    SECURITY_ATTRIBUTES ScreenSaverDesktopSecurity;
    PSECURITY_DESCRIPTOR WlWinstaSecurityDescriptor;
    PSECURITY_DESCRIPTOR WlApplicationDesktopSecurityDescriptor;
    PSECURITY_DESCRIPTOR WlWinlogonDesktopSecurityDescriptor;
    PSECURITY_DESCRIPTOR WlScreenSaverDesktopSecurityDescriptor;
    BOOL ret = FALSE;

    if (!CreateWinstaSecurity(&WlWinstaSecurityDescriptor))
    {
        ERR("WL: Failed to create winsta security!\n");
        return ret;
    }

    WinstaSecurity.nLength = sizeof(SECURITY_ATTRIBUTES);
    WinstaSecurity.lpSecurityDescriptor = WlWinstaSecurityDescriptor;
    WinstaSecurity.bInheritHandle = TRUE;

    if (!CreateApplicationDesktopSecurity(&WlApplicationDesktopSecurityDescriptor))
    {
        ERR("WL: Failed to create application desktop security!\n");
        goto cleanup;
    }

    ApplicationDesktopSecurity.nLength = sizeof(SECURITY_ATTRIBUTES);
    ApplicationDesktopSecurity.lpSecurityDescriptor = WlApplicationDesktopSecurityDescriptor;
    ApplicationDesktopSecurity.bInheritHandle = TRUE;

    if (!CreateWinlogonDesktopSecurity(&WlWinlogonDesktopSecurityDescriptor))
    {
        ERR("WL: Failed to create winlogon desktop security!\n");
        goto cleanup;
    }

    WinlogonDesktopSecurity.nLength = sizeof(SECURITY_ATTRIBUTES);
    WinlogonDesktopSecurity.lpSecurityDescriptor = WlWinlogonDesktopSecurityDescriptor;
    WinlogonDesktopSecurity.bInheritHandle = FALSE;

    if (!CreateScreenSaverSecurity(&WlScreenSaverDesktopSecurityDescriptor))
    {
        ERR("WL: Failed to create winlogon desktop security!\n");
        goto cleanup;
    }

    ScreenSaverDesktopSecurity.nLength = sizeof(SECURITY_ATTRIBUTES);
    ScreenSaverDesktopSecurity.lpSecurityDescriptor = WlScreenSaverDesktopSecurityDescriptor;
    ScreenSaverDesktopSecurity.bInheritHandle = TRUE;

    /*
     * Create the interactive window station
     */
    Session->InteractiveWindowStationName = L"WinSta0";
    Session->InteractiveWindowStation = CreateWindowStationW(
        Session->InteractiveWindowStationName,
        0,
        MAXIMUM_ALLOWED,
        &WinstaSecurity);
    if (!Session->InteractiveWindowStation)
    {
        ERR("WL: Failed to create window station (%lu)\n", GetLastError());
        goto cleanup;
    }

    if (!SetProcessWindowStation(Session->InteractiveWindowStation))
    {
        ERR("WL: SetProcessWindowStation() failed (error %lu)\n", GetLastError());
        goto cleanup;
    }

    /*
     * Create the application desktop
     */
    Session->ApplicationDesktop = CreateDesktopW(
        L"Default",
        NULL,
        NULL,
        0, /* FIXME: Add DF_ALLOWOTHERACCOUNTHOOK flag? */
        MAXIMUM_ALLOWED,
        &ApplicationDesktopSecurity);
    if (!Session->ApplicationDesktop)
    {
        ERR("WL: Failed to create Default desktop (%lu)\n", GetLastError());
        goto cleanup;
    }

    /*
     * Create the winlogon desktop
     */
    Session->WinlogonDesktop = CreateDesktopW(
        L"Winlogon",
        NULL,
        NULL,
        0,
        MAXIMUM_ALLOWED,
        &WinlogonDesktopSecurity);
    if (!Session->WinlogonDesktop)
    {
        ERR("WL: Failed to create Winlogon desktop (%lu)\n", GetLastError());
        goto cleanup;
    }

    /*
     * Create the screen saver desktop
     */
    Session->ScreenSaverDesktop = CreateDesktopW(
        L"Screen-Saver",
        NULL,
        NULL,
        0,
        MAXIMUM_ALLOWED,
        &ScreenSaverDesktopSecurity);
    if(!Session->ScreenSaverDesktop)
    {
        ERR("WL: Failed to create Screen-Saver desktop (%lu)\n", GetLastError());
        goto cleanup;
    }

    /*
     * Switch to winlogon desktop
    */
    if (!SetThreadDesktop(Session->WinlogonDesktop) ||
        !SwitchDesktop(Session->WinlogonDesktop))
    {
        ERR("WL: Cannot switch to Winlogon desktop (%lu)\n", GetLastError());
        goto cleanup;
    }

    SetWindowStationUser(Session->InteractiveWindowStation,
                         &LuidNone, NULL, 0);

    ret = TRUE;

cleanup:
    if (!ret)
    {
        if (Session->ApplicationDesktop)
        {
            CloseDesktop(Session->ApplicationDesktop);
            Session->ApplicationDesktop = NULL;
        }
        if (Session->WinlogonDesktop)
        {
            CloseDesktop(Session->WinlogonDesktop);
            Session->WinlogonDesktop = NULL;
        }
        if (Session->ScreenSaverDesktop)
        {
            CloseDesktop(Session->ScreenSaverDesktop);
            Session->ScreenSaverDesktop = NULL;
        }
        if (Session->InteractiveWindowStation)
        {
            CloseWindowStation(Session->InteractiveWindowStation);
            Session->InteractiveWindowStation = NULL;
        }
        if (WlWinstaSecurityDescriptor)
        {
            RtlFreeHeap(RtlGetProcessHeap(), 0, WlWinstaSecurityDescriptor);
        }
        if (WlApplicationDesktopSecurityDescriptor)
        {
            RtlFreeHeap(RtlGetProcessHeap(), 0, WlApplicationDesktopSecurityDescriptor);
        }
        if (WlWinlogonDesktopSecurityDescriptor)
        {
            RtlFreeHeap(RtlGetProcessHeap(), 0, WlWinlogonDesktopSecurityDescriptor);
        }
        if (WlScreenSaverDesktopSecurityDescriptor)
        {
            RtlFreeHeap(RtlGetProcessHeap(), 0, WlScreenSaverDesktopSecurityDescriptor);
        }
    }

    return ret;
}

Referenced by WinMain().

CreateWinlogonDesktopSecurity()

BOOL CreateWinlogonDesktopSecurity

(

_Out_ PSECURITY_DESCRIPTOR *

WinlogonDesktopSd

)

Creates a security descriptor for the default Winlogon desktop. This descriptor serves as a security measure for the winlogon desktop so that only Winlogon itself (and admins) can interact with it.

Parameters

[out]

WinlogonDesktopSd

A pointer to a created security descriptor for the Winlogon desktop.

Returns

Returns TRUE if the function has successfully created the security descriptor, FALSE otherwise.

Definition at line 541 of file security.c.

{
    BOOL Success = FALSE;
    SECURITY_DESCRIPTOR AbsoluteSd;
    PSECURITY_DESCRIPTOR RelativeSd = NULL;
    PSID WinlogonSid = NULL, AdminsSid = NULL;
    DWORD DaclSize;
    PACL Dacl;

    /* Create the Winlogon SID */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  1,
                                  SECURITY_LOCAL_SYSTEM_RID,
                                  0, 0, 0, 0, 0, 0, 0,
                                  &WinlogonSid))
    {
        ERR("CreateWinlogonDesktopSecurity(): Failed to create the Winlogon SID (error code %lu)\n", GetLastError());
        return FALSE;
    }

    /* Create the admins SID */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  2,
                                  SECURITY_BUILTIN_DOMAIN_RID,
                                  DOMAIN_ALIAS_RID_ADMINS,
                                  0, 0, 0, 0, 0, 0,
                                  &AdminsSid))
    {
        ERR("CreateWinlogonDesktopSecurity(): Failed to create the admins SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /*
     * Build up the DACL size. This includes a number
     * of two ACEs of two different SIDs. The first ACE
     * gives full access to Winlogon, the last one gives
     * limited desktop access to admins.
     */
    DaclSize = sizeof(ACL) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(WinlogonSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(AdminsSid);

    /* Allocate the DACL now */
    Dacl = RtlAllocateHeap(RtlGetProcessHeap(),
                           HEAP_ZERO_MEMORY,
                           DaclSize);
    if (Dacl == NULL)
    {
        ERR("CreateWinlogonDesktopSecurity(): Failed to allocate memory buffer for DACL!\n");
        goto Quit;
    }

    /* Initialize it */
    if (!InitializeAcl(Dacl, DaclSize, ACL_REVISION))
    {
        ERR("CreateWinlogonDesktopSecurity(): Failed to initialize DACL (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* First ACE -- Give full desktop access to Winlogon */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               0,
                               DESKTOP_ALL,
                               WinlogonSid))
    {
        ERR("CreateWinlogonDesktopSecurity(): Failed to set ACE for Winlogon (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Second ACE -- Give limited desktop access to admins */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               0,
                               DESKTOP_WINLOGON_ADMINS_LIMITED,
                               AdminsSid))
    {
        ERR("CreateWinlogonDesktopSecurity(): Failed to set ACE for admins (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Initialize the security descriptor */
    if (!InitializeSecurityDescriptor(&AbsoluteSd, SECURITY_DESCRIPTOR_REVISION))
    {
        ERR("CreateWinlogonDesktopSecurity(): Failed to initialize absolute security descriptor (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Set the DACL to the descriptor */
    if (!SetSecurityDescriptorDacl(&AbsoluteSd, TRUE, Dacl, FALSE))
    {
        ERR("CreateWinlogonDesktopSecurity(): Failed to set up DACL to absolute security descriptor (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Conver it to self-relative format */
    RelativeSd = ConvertToSelfRelative(&AbsoluteSd);
    if (RelativeSd == NULL)
    {
        ERR("CreateWinlogonDesktopSecurity(): Failed to convert security descriptor to self relative format!\n");
        goto Quit;
    }

    /* Give the descriptor to the caller */
    *WinlogonDesktopSd = RelativeSd;
    Success = TRUE;

Quit:
    if (WinlogonSid != NULL)
    {
        FreeSid(WinlogonSid);
    }

    if (AdminsSid != NULL)
    {
        FreeSid(AdminsSid);
    }

    if (Dacl != NULL)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, Dacl);
    }

    if (Success == FALSE)
    {
        if (RelativeSd != NULL)
        {
            RtlFreeHeap(RtlGetProcessHeap(), 0, RelativeSd);
        }
    }

    return Success;
}

Referenced by CreateWindowStationAndDesktops().

CreateWinstaSecurity()

BOOL CreateWinstaSecurity

(

_Out_ PSECURITY_DESCRIPTOR *

WinstaSd

)

Creates a security descriptor for the default window station upon its creation.

Parameters

[out]

WinstaSd

A pointer to a created security descriptor for the window station.

Returns

Returns TRUE if the function has successfully created the security descriptor, FALSE otherwise.

Definition at line 112 of file security.c.

{
    BOOL Success = FALSE;
    SECURITY_DESCRIPTOR AbsoluteSd;
    PSECURITY_DESCRIPTOR RelativeSd = NULL;
    PSID WinlogonSid = NULL, AdminsSid = NULL, NetworkServiceSid = NULL; /* NetworkServiceSid is a HACK, see the comment below for information */
    DWORD DaclSize;
    PACL Dacl;

    /* Create the Winlogon SID */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  1,
                                  SECURITY_LOCAL_SYSTEM_RID,
                                  0, 0, 0, 0, 0, 0, 0,
                                  &WinlogonSid))
    {
        ERR("CreateWinstaSecurity(): Failed to create the Winlogon SID (error code %lu)\n", GetLastError());
        return FALSE;
    }

    /* Create the admins SID */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  2,
                                  SECURITY_BUILTIN_DOMAIN_RID,
                                  DOMAIN_ALIAS_RID_ADMINS,
                                  0, 0, 0, 0, 0, 0,
                                  &AdminsSid))
    {
        ERR("CreateWinstaSecurity(): Failed to create the admins SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* HACK: Create the network service SID */
    if (!AllocateAndInitializeSid(&NtAuthority,
                                  1,
                                  SECURITY_NETWORK_SERVICE_RID,
                                  0, 0, 0, 0, 0, 0, 0,
                                  &NetworkServiceSid))
    {
        ERR("CreateWinstaSecurity(): Failed to create the network service SID (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /*
     * Build up the DACL size. This includes a number
     * of four ACEs of two different SIDs. The first two
     * ACEs give both window station and generic access
     * to Winlogon, the last two give limited window station
     * and desktop access to admins.
     *
     * ===================== !!!MUST READ!!! =====================
     *
     * HACK -- Include in the DACL two more ACEs for network
     * service SID. Network services will be granted full
     * access to the default window station. Whilst technically
     * services that are either network or local ones are part
     * and act on behalf of the system, what we are doing here
     * is a hack because of two reasons:
     *
     * 1) Winlogon does not allow default window station (Winsta0)
     * access to network services on Windows. As a matter of fact,
     * network services must access their own service window station
     * (aka Service-0x0-3e4$) which never gets created. Why it never
     * gets created is explained on the second point.
     *
     * 2) Our LSASS terribly lacks in code that handles special logon
     * service types, NetworkService and LocalService. For this reason
     * whenever an access token is created for a network service process
     * for example, its authentication ID (aka LogonId represented as a LUID)
     * is a uniquely generated ID by LSASS for this process. This is wrong
     * on so many levels, partly because a network service is not a regular
     * service and network services have their own special authentication logon
     * ID (with its respective LUID as {0x3e4, 0x0}). On top of that, a network
     * service process must have an impersonation token but for whatever reason
     * we are creating a primary access token instead.
     *
     * FOR ANYONE WHO'S INTERESTED ON FIXING THIS, DO NOT FORGET TO REMOVE THIS
     * HACK!!!
     *
     * =========================== !!!END!!! ================================
     */
    DaclSize = sizeof(ACL) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(WinlogonSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(WinlogonSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(AdminsSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(AdminsSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(NetworkServiceSid) +
               sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + GetLengthSid(NetworkServiceSid);

    /* Allocate the DACL now */
    Dacl = RtlAllocateHeap(RtlGetProcessHeap(),
                           HEAP_ZERO_MEMORY,
                           DaclSize);
    if (Dacl == NULL)
    {
        ERR("CreateWinstaSecurity(): Failed to allocate memory buffer for DACL!\n");
        goto Quit;
    }

    /* Initialize it */
    if (!InitializeAcl(Dacl, DaclSize, ACL_REVISION))
    {
        ERR("CreateWinstaSecurity(): Failed to initialize DACL (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* First ACE -- give full winsta access to Winlogon */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               NO_PROPAGATE_INHERIT_ACE,
                               WINSTA_ALL,
                               WinlogonSid))
    {
        ERR("CreateWinstaSecurity(): Failed to set ACE for Winlogon (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Second ACE -- give full generic access to Winlogon */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               INHERIT_ONLY_ACE | OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE,
                               GENERIC_ACCESS,
                               WinlogonSid))
    {
        ERR("CreateWinstaSecurity(): Failed to set ACE for Winlogon (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Third ACE -- give limited winsta access to admins */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               NO_PROPAGATE_INHERIT_ACE,
                               WINSTA_ADMINS_LIMITED,
                               AdminsSid))
    {
        ERR("CreateWinstaSecurity(): Failed to set ACE for admins (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Fourth ACE -- give limited desktop access to admins */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               INHERIT_ONLY_ACE | OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE,
                               DESKTOP_ADMINS_LIMITED,
                               AdminsSid))
    {
        ERR("CreateWinstaSecurity(): Failed to set ACE for admins (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* HACK: Fifth ACE -- give full access to network services */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               NO_PROPAGATE_INHERIT_ACE,
                               WINSTA_ALL,
                               NetworkServiceSid))
    {
        ERR("CreateWinstaSecurity(): Failed to set ACE for network service (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* HACK: Sixth ACE -- give full generic access to network services */
    if (!AddAccessAllowedAceEx(Dacl,
                               ACL_REVISION,
                               INHERIT_ONLY_ACE | OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE,
                               GENERIC_ACCESS,
                               NetworkServiceSid))
    {
        ERR("CreateWinstaSecurity(): Failed to set ACE for network service (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Initialize the security descriptor */
    if (!InitializeSecurityDescriptor(&AbsoluteSd, SECURITY_DESCRIPTOR_REVISION))
    {
        ERR("CreateWinstaSecurity(): Failed to initialize absolute security descriptor (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Set the DACL to the descriptor */
    if (!SetSecurityDescriptorDacl(&AbsoluteSd, TRUE, Dacl, FALSE))
    {
        ERR("CreateWinstaSecurity(): Failed to set up DACL to absolute security descriptor (error code %lu)\n", GetLastError());
        goto Quit;
    }

    /* Convert it to self-relative format */
    RelativeSd = ConvertToSelfRelative(&AbsoluteSd);
    if (RelativeSd == NULL)
    {
        ERR("CreateWinstaSecurity(): Failed to convert security descriptor to self relative format!\n");
        goto Quit;
    }

    /* Give the descriptor to the caller */
    *WinstaSd = RelativeSd;
    Success = TRUE;

Quit:
    if (WinlogonSid != NULL)
    {
        FreeSid(WinlogonSid);
    }

    if (AdminsSid != NULL)
    {
        FreeSid(AdminsSid);
    }

    /* HACK */
    if (NetworkServiceSid != NULL)
    {
        FreeSid(NetworkServiceSid);
    }
    /* END HACK */

    if (Dacl != NULL)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, Dacl);
    }

    if (Success == FALSE)
    {
        if (RelativeSd != NULL)
        {
            RtlFreeHeap(RtlGetProcessHeap(), 0, RelativeSd);
        }
    }

    return Success;
}

Referenced by CreateWindowStationAndDesktops().

DisplayStatusMessage()

BOOL DisplayStatusMessage	(	IN PWLSESSION	Session,
		IN HDESK	hDesktop,
		IN UINT	ResourceId
	)

Definition at line 349 of file winlogon.c.

{
    WCHAR StatusMsg[MAX_PATH];

    if (Session->Gina.Version < WLX_VERSION_1_3)
        return TRUE;

    if (Session->SuppressStatus)
        return TRUE;

    if (LoadStringW(hAppInstance, ResourceId, StatusMsg, MAX_PATH) == 0)
        return FALSE;

    return Session->Gina.Functions.WlxDisplayStatusMessage(Session->Gina.Context, hDesktop, 0, NULL, StatusMsg);
}

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

GetSetupType()

DWORD GetSetupType

(

VOID

)

Definition at line 16 of file setup.c.

{
    DWORD dwError;
    HKEY hKey;
    DWORD dwType;
    DWORD dwSize;
    DWORD dwSetupType;

    TRACE("GetSetupType()\n");

    /* Open key */
    dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                            L"SYSTEM\\Setup",
                            0,
                            KEY_QUERY_VALUE,
                            &hKey);
    if (dwError != ERROR_SUCCESS)
        return 0;

    /* Read key */
    dwSize = sizeof(DWORD);
    dwError = RegQueryValueExW(hKey,
                               L"SetupType",
                               NULL,
                               &dwType,
                               (LPBYTE)&dwSetupType,
                               &dwSize);

    /* Close key, and check if returned values are correct */
    RegCloseKey(hKey);
    if (dwError != ERROR_SUCCESS || dwType != REG_DWORD || dwSize != sizeof(DWORD))
        return 0;

    TRACE("GetSetupType() returns %lu\n", dwSetupType);
    return dwSetupType;
}

Referenced by SASWindowProc(), and WinMain().

GinaInit()

BOOL GinaInit

(

IN OUT PWLSESSION

Session

)

Definition at line 905 of file wlx.c.

{
    DWORD GinaDllVersion;

    if (!LoadGina(&Session->Gina.Functions, &GinaDllVersion, &Session->Gina.hDllInstance))
        return FALSE;

    Session->Gina.Context = NULL;
    Session->Gina.Version = GinaDllVersion;
    Session->Gina.UseCtrlAltDelete = FALSE;
    Session->SuppressStatus = FALSE;

    TRACE("Calling WlxInitialize(\"%S\")\n", Session->InteractiveWindowStationName);
    return Session->Gina.Functions.WlxInitialize(
        Session->InteractiveWindowStationName,
        (HANDLE)Session,
        NULL,
        (PVOID)&FunctionTable,
        &Session->Gina.Context);
}

Referenced by WinMain().

HandleShutdown()

NTSTATUS HandleShutdown	(	IN OUT PWLSESSION	Session,
		IN DWORD	wlxAction
	)

Definition at line 964 of file sas.c.

{
    PLOGOFF_SHUTDOWN_DATA LSData;
    HANDLE hThread;
    DWORD exitCode;
    BOOLEAN Old;

    // SwitchDesktop(Session->WinlogonDesktop);

    /* If the system is rebooting, show the appropriate string */
    if (wlxAction == WLX_SAS_ACTION_SHUTDOWN_REBOOT)
        DisplayStatusMessage(Session, Session->WinlogonDesktop, IDS_REACTOSISRESTARTING);
    else
        DisplayStatusMessage(Session, Session->WinlogonDesktop, IDS_REACTOSISSHUTTINGDOWN);

    /* Prepare data for shutdown thread */
    LSData = HeapAlloc(GetProcessHeap(), 0, sizeof(LOGOFF_SHUTDOWN_DATA));
    if (!LSData)
    {
        ERR("Failed to allocate mem for thread data\n");
        return STATUS_NO_MEMORY;
    }
    if (wlxAction == WLX_SAS_ACTION_SHUTDOWN_POWER_OFF)
        LSData->Flags = EWX_POWEROFF;
    else if (wlxAction == WLX_SAS_ACTION_SHUTDOWN_REBOOT)
        LSData->Flags = EWX_REBOOT;
    else
        LSData->Flags = EWX_SHUTDOWN;
    LSData->Session = Session;

    // FIXME: We may need to specify this flag to really force application kill
    // (we are shutting down ReactOS, not just logging off so no hangs, etc...
    // should be allowed).
    // LSData->Flags |= EWX_FORCE;

    /* Run shutdown thread */
    hThread = CreateThread(NULL, 0, LogoffShutdownThread, (LPVOID)LSData, 0, NULL);
    if (!hThread)
    {
        ERR("Unable to create shutdown thread, error %lu\n", GetLastError());
        HeapFree(GetProcessHeap(), 0, LSData);
        return STATUS_UNSUCCESSFUL;
    }
    WaitForSingleObject(hThread, INFINITE);
    HeapFree(GetProcessHeap(), 0, LSData);
    if (!GetExitCodeThread(hThread, &exitCode))
    {
        ERR("Unable to get exit code of shutdown thread (error %lu)\n", GetLastError());
        CloseHandle(hThread);
        return STATUS_UNSUCCESSFUL;
    }
    CloseHandle(hThread);
    if (exitCode == 0)
    {
        ERR("Shutdown thread returned failure\n");
        return STATUS_UNSUCCESSFUL;
    }

    CallNotificationDlls(Session, ShutdownHandler);

    /* Destroy SAS window */
    UninitializeSAS(Session);

    /* Now we can shut down NT */
    ERR("Shutting down NT...\n");
    RtlAdjustPrivilege(SE_SHUTDOWN_PRIVILEGE, TRUE, FALSE, &Old);
    if (wlxAction == WLX_SAS_ACTION_SHUTDOWN_REBOOT)
    {
        NtShutdownSystem(ShutdownReboot);
    }
    else
    {
        if (FALSE)
        {
            /* FIXME - only show this dialog if it's a shutdown and the computer doesn't support APM */
            DialogBox(hAppInstance, MAKEINTRESOURCE(IDD_SHUTDOWNCOMPUTER),
                      GetDesktopWindow(), ShutdownComputerWindowProc);
        }
        NtShutdownSystem(ShutdownNoReboot);
    }
    RtlAdjustPrivilege(SE_SHUTDOWN_PRIVILEGE, Old, FALSE, &Old);
    return STATUS_SUCCESS;
}

Referenced by DoGenericAction(), and WinMain().

InitDialogListHead()

VOID InitDialogListHead

(

VOID

)

Definition at line 31 of file wlx.c.

{
    InitializeListHead(&DialogListHead);
}

Referenced by WinMain().

InitializeSAS()

BOOL InitializeSAS

(

IN OUT PWLSESSION

Session

)

Definition at line 1508 of file sas.c.

{
    WNDCLASSEXW swc;
    BOOL ret = FALSE;

    if (!SwitchDesktop(Session->WinlogonDesktop))
    {
        ERR("WL: Failed to switch to winlogon desktop\n");
        goto cleanup;
    }

    /* Register SAS window class */
    swc.cbSize = sizeof(WNDCLASSEXW);
    swc.style = CS_SAVEBITS;
    swc.lpfnWndProc = SASWindowProc;
    swc.cbClsExtra = 0;
    swc.cbWndExtra = 0;
    swc.hInstance = hAppInstance;
    swc.hIcon = NULL;
    swc.hCursor = NULL;
    swc.hbrBackground = NULL;
    swc.lpszMenuName = NULL;
    swc.lpszClassName = WINLOGON_SAS_CLASS;
    swc.hIconSm = NULL;
    if (RegisterClassExW(&swc) == 0)
    {
        ERR("WL: Failed to register SAS window class\n");
        goto cleanup;
    }

    /* Create invisible SAS window */
    Session->SASWindow = CreateWindowExW(
        0,
        WINLOGON_SAS_CLASS,
        WINLOGON_SAS_TITLE,
        WS_POPUP,
        0, 0, 0, 0, 0, 0,
        hAppInstance, Session);
    if (!Session->SASWindow)
    {
        ERR("WL: Failed to create SAS window\n");
        goto cleanup;
    }

    /* Register SAS window to receive SAS notifications */
    if (!SetLogonNotifyWindow(Session->SASWindow))
    {
        ERR("WL: Failed to register SAS window\n");
        goto cleanup;
    }

    if (!SetDefaultLanguage(NULL))
        return FALSE;

    ret = TRUE;

cleanup:
    if (!ret)
        UninitializeSAS(Session);
    return ret;
}

Referenced by WinMain().

InitializeScreenSaver()

BOOL InitializeScreenSaver

(

IN OUT PWLSESSION

Session

)

Definition at line 204 of file screensaver.c.

{
    HANDLE ScreenSaverThread;

#ifndef USE_GETLASTINPUTINFO
    /* Register hooks to detect keyboard and mouse activity */
    Session->KeyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardActivityProc, hAppInstance, 0);
    if (!Session->KeyboardHook)
    {
        ERR("WL: Unable to register keyboard hook\n");
        return FALSE;
    }

    Session->MouseHook = SetWindowsHookEx(WH_MOUSE_LL, MouseActivityProc, hAppInstance, 0);
    if (!Session->MouseHook)
    {
        ERR("WL: Unable to register mouse hook\n");
        return FALSE;
    }
#endif

    Session->hScreenSaverParametersChanged = CreateEventW(NULL, FALSE, FALSE, NULL);
    if (!Session->hScreenSaverParametersChanged)
    {
        WARN("WL: Unable to create screen saver event (error %lu)\n", GetLastError());
        return TRUE;
    }

    Session->hEndOfScreenSaverThread = CreateEventW(NULL, FALSE, FALSE, NULL);
    if (!Session->hEndOfScreenSaverThread)
    {
        WARN("WL: Unable to create screen saver event (error %lu)\n", GetLastError());
        CloseHandle(Session->hScreenSaverParametersChanged);
        return TRUE;
    }

    ScreenSaverThread = CreateThread(NULL,
                                     0,
                                     ScreenSaverThreadMain,
                                     Session,
                                     0,
                                     NULL);
    if (ScreenSaverThread)
        CloseHandle(ScreenSaverThread);
    else
        ERR("WL: Unable to start screen saver thread\n");

    return TRUE;
}

Referenced by HandleLogon().

InitNotifications()

BOOL InitNotifications

(

VOID

)

Definition at line 253 of file notify.c.

{
    HKEY hNotifyKey = NULL;
    LONG lError;
    DWORD dwIndex;
    WCHAR szKeyName[80];
    DWORD dwKeyName;

    TRACE("InitNotifications()\n");

    InitializeListHead(&NotificationDllListHead);

    AddSfcNotification();

    lError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                           L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon\\Notify",
                           0,
                           KEY_READ | KEY_ENUMERATE_SUB_KEYS,
                           &hNotifyKey);
    if (lError != ERROR_SUCCESS)
    {
        TRACE("RegOpenKeyExW()\n");
        return TRUE;
    }

    dwIndex = 0;
    for(;;)
    {
        dwKeyName = 80 * sizeof(WCHAR);
        lError = RegEnumKeyExW(hNotifyKey,
                               dwIndex,
                               szKeyName,
                               &dwKeyName,
                               NULL,
                               NULL,
                               NULL,
                               NULL);
        if (lError != ERROR_SUCCESS)
            break;

        TRACE("Notification DLL: %S\n", szKeyName);
        AddNotificationDll(hNotifyKey, szKeyName);

        dwIndex++;
    }

    RegCloseKey(hNotifyKey);

    TRACE("InitNotifications() done\n");

    return TRUE;
}

Referenced by WinMain().

PlaySoundRoutine()

BOOL PlaySoundRoutine	(	IN LPCWSTR	FileName,
		IN UINT	Logon,
		IN UINT	Flags
	)

Definition at line 240 of file sas.c.

{
    typedef BOOL (WINAPI *PLAYSOUNDW)(LPCWSTR,HMODULE,DWORD);
    typedef UINT (WINAPI *WAVEOUTGETNUMDEVS)(VOID);
    PLAYSOUNDW Play;
    WAVEOUTGETNUMDEVS waveOutGetNumDevs;
    UINT NumDevs;
    HMODULE hLibrary;
    BOOL Ret = FALSE;

    hLibrary = LoadLibraryW(L"winmm.dll");
    if (hLibrary)
    {
        waveOutGetNumDevs = (WAVEOUTGETNUMDEVS)GetProcAddress(hLibrary, "waveOutGetNumDevs");
        if (waveOutGetNumDevs)
        {
            NumDevs = waveOutGetNumDevs();
            if (!NumDevs)
            {
                if (!bLogon)
                {
                    Beep(440, 125);
                }
                FreeLibrary(hLibrary);
                return FALSE;
            }
        }

        Play = (PLAYSOUNDW)GetProcAddress(hLibrary, "PlaySoundW");
        if (Play)
        {
            Ret = Play(FileName, NULL, Flags);
        }
        FreeLibrary(hLibrary);
    }

    return Ret;
}

Referenced by HandleMessageBeep(), and PlayLogonSoundThread().

RemoveStatusMessage()

BOOL RemoveStatusMessage

(

IN PWLSESSION

Session

)

Definition at line 370 of file winlogon.c.

{
    if (Session->Gina.Version < WLX_VERSION_1_3)
        return TRUE;

    return Session->Gina.Functions.WlxRemoveStatusMessage(Session->Gina.Context);
}

Referenced by DoGenericAction(), HandleLogon(), and WinMain().

RunSetup()

BOOL RunSetup

(

VOID

)

Definition at line 153 of file setup.c.

{
    HANDLE hThread;

    hThread = CreateThread(NULL,
                           0,
                           RunSetupThreadProc,
                           NULL,
                           0,
                           NULL);
    if (hThread != NULL)
        CloseHandle(hThread);

    return hThread != NULL;
}

Referenced by WinMain().

SetDefaultLanguage()

BOOL SetDefaultLanguage

(

IN PWLSESSION

Session

)

Definition at line 111 of file sas.c.

{
    BOOL ret = FALSE;
    BOOL UserProfile;
    LONG rc;
    HKEY UserKey, hKey = NULL;
    LPCWSTR SubKey, ValueName;
    DWORD dwType, dwSize;
    LPWSTR Value = NULL;
    UNICODE_STRING ValueString;
    NTSTATUS Status;
    LCID Lcid;

    UserProfile = (Session && Session->UserToken);

    if (UserProfile && !ImpersonateLoggedOnUser(Session->UserToken))
    {
        ERR("WL: ImpersonateLoggedOnUser() failed with error %lu\n", GetLastError());
        return FALSE;
        // FIXME: ... or use the default language of the system??
        // UserProfile = FALSE;
    }

    if (UserProfile)
    {
        rc = RegOpenCurrentUser(MAXIMUM_ALLOWED, &UserKey);
        if (rc != ERROR_SUCCESS)
        {
            TRACE("RegOpenCurrentUser() failed with error %lu\n", rc);
            goto cleanup;
        }

        SubKey = L"Control Panel\\International";
        ValueName = L"Locale";
    }
    else
    {
        UserKey = NULL;
        SubKey = L"System\\CurrentControlSet\\Control\\Nls\\Language";
        ValueName = L"Default";
    }

    rc = RegOpenKeyExW(UserKey ? UserKey : HKEY_LOCAL_MACHINE,
                       SubKey,
                       0,
                       KEY_READ,
                       &hKey);

    if (UserKey)
        RegCloseKey(UserKey);

    if (rc != ERROR_SUCCESS)
    {
        TRACE("RegOpenKeyEx() failed with error %lu\n", rc);
        goto cleanup;
    }

    rc = RegQueryValueExW(hKey,
                          ValueName,
                          NULL,
                          &dwType,
                          NULL,
                          &dwSize);
    if (rc != ERROR_SUCCESS)
    {
        TRACE("RegQueryValueEx() failed with error %lu\n", rc);
        goto cleanup;
    }
    else if (dwType != REG_SZ)
    {
        TRACE("Wrong type for %S\\%S registry entry (got 0x%lx, expected 0x%x)\n",
            SubKey, ValueName, dwType, REG_SZ);
        goto cleanup;
    }

    Value = HeapAlloc(GetProcessHeap(), 0, dwSize);
    if (!Value)
    {
        TRACE("HeapAlloc() failed\n");
        goto cleanup;
    }
    rc = RegQueryValueExW(hKey,
                          ValueName,
                          NULL,
                          NULL,
                          (LPBYTE)Value,
                          &dwSize);
    if (rc != ERROR_SUCCESS)
    {
        TRACE("RegQueryValueEx() failed with error %lu\n", rc);
        goto cleanup;
    }

    /* Convert Value to a Lcid */
    ValueString.Length = ValueString.MaximumLength = (USHORT)dwSize;
    ValueString.Buffer = Value;
    Status = RtlUnicodeStringToInteger(&ValueString, 16, (PULONG)&Lcid);
    if (!NT_SUCCESS(Status))
    {
        TRACE("RtlUnicodeStringToInteger() failed with status 0x%08lx\n", Status);
        goto cleanup;
    }

    TRACE("%s language is 0x%08lx\n",
        UserProfile ? "User" : "System", Lcid);
    Status = NtSetDefaultLocale(UserProfile, Lcid);
    if (!NT_SUCCESS(Status))
    {
        TRACE("NtSetDefaultLocale() failed with status 0x%08lx\n", Status);
        goto cleanup;
    }

    ret = TRUE;

cleanup:
    if (Value)
        HeapFree(GetProcessHeap(), 0, Value);

    if (hKey)
        RegCloseKey(hKey);

    if (UserProfile)
        RevertToSelf();

    return ret;
}

Referenced by HandleLogon(), and InitializeSAS().

SetWindowStationUser()

BOOL WINAPI SetWindowStationUser	(	IN HWINSTA	hWindowStation,
		IN PLUID	pluid,
		IN PSID psid	OPTIONAL,
		IN DWORD	size
	)

Definition at line 419 of file winsta.c.

{
    BOOL Success;

    Success = NtUserSetWindowStationUser(hWindowStation, pluid, psid, size);
    if (Success)
    {
        /* Signal log-on/off to WINSRV */

        /* User is logging on if *pluid != LuidNone, otherwise it is a log-off */
        LUID LuidNone = {0, 0};
        BOOL IsLogon = (pluid && !RtlEqualLuid(pluid, &LuidNone));

        Logon(IsLogon);
    }

    return Success;
}

Referenced by AllowAccessOnSession(), CreateWindowStationAndDesktops(), HandleLogoff(), and HandleLogon().

StartRpcServer()

BOOL StartRpcServer

(

VOID

)

Definition at line 32 of file rpcserver.c.

{
    NTSTATUS Status;

    Status = lpServiceGlobals->StartRpcServer(L"seclogon", ISeclogon_v1_0_s_ifspec);
    TRACE("StartRpcServer returned 0x%08lx\n", Status);

    return RtlNtStatusToDosError(Status);
}

StartScreenSaver()

VOID StartScreenSaver

(

IN PWLSESSION

Session

)

Definition at line 257 of file screensaver.c.

{
    HKEY hKey = NULL, hCurrentUser = NULL;
    WCHAR szApplicationName[MAX_PATH];
    WCHAR szCommandLine[MAX_PATH + 3];
    DWORD bufferSize = sizeof(szApplicationName) - sizeof(WCHAR);
    DWORD dwType;
    STARTUPINFOW StartupInfo;
    PROCESS_INFORMATION ProcessInformation;
    HANDLE HandleArray[2];
    LONG rc;
    DWORD Status;
    BOOL ret = FALSE;

    if (!ImpersonateLoggedOnUser(Session->UserToken))
    {
        ERR("WL: ImpersonateLoggedOnUser() failed with error %lu\n", GetLastError());
        goto cleanup;
    }

    rc = RegOpenCurrentUser(KEY_READ,
                            &hCurrentUser);
    if (rc != ERROR_SUCCESS)
    {
        ERR("WL: RegOpenCurrentUser error %lu\n", rc);
        goto cleanup;
    }

    rc = RegOpenKeyExW(hCurrentUser,
                       L"Control Panel\\Desktop",
                       0,
                       KEY_QUERY_VALUE,
                       &hKey);
    if (rc != ERROR_SUCCESS)
    {
        ERR("WL: RegOpenKeyEx error %lu\n", rc);
        goto cleanup;
    }

    rc = RegQueryValueExW(hKey,
                          L"SCRNSAVE.EXE",
                          0,
                          &dwType,
                          (LPBYTE)szApplicationName,
                          &bufferSize);
    if (rc != ERROR_SUCCESS || dwType != REG_SZ)
    {
        if (rc != ERROR_FILE_NOT_FOUND)
            ERR("WL: RegQueryValueEx error %lu\n", rc);
        goto cleanup;
    }

    if (bufferSize == 0)
    {
        ERR("WL: Buffer size is NULL!\n");
        goto cleanup;
    }

    szApplicationName[bufferSize / sizeof(WCHAR)] = 0; /* Terminate the string */

    if (wcslen(szApplicationName) == 0)
    {
        ERR("WL: Application Name length is zero!\n");
        goto cleanup;
    }

    wsprintfW(szCommandLine, L"%s /s", szApplicationName);
    TRACE("WL: Executing %S\n", szCommandLine);

    ZeroMemory(&StartupInfo, sizeof(STARTUPINFOW));
    ZeroMemory(&ProcessInformation, sizeof(PROCESS_INFORMATION));
    StartupInfo.cb = sizeof(STARTUPINFOW);
    StartupInfo.dwFlags = STARTF_SCREENSAVER;

    /* FIXME: Run the screen saver on the secure screen saver desktop if required */
    StartupInfo.lpDesktop = L"WinSta0\\Default";

    ret = CreateProcessAsUserW(Session->UserToken,
                               szApplicationName,
                               szCommandLine,
                               NULL,
                               NULL,
                               FALSE,
                               IDLE_PRIORITY_CLASS,
                               NULL,
                               NULL,
                               &StartupInfo,
                               &ProcessInformation);
    if (!ret)
    {
        ERR("WL: Unable to start %S, error %lu\n", szApplicationName, GetLastError());
        goto cleanup;
    }

    CloseHandle(ProcessInformation.hThread);

    SystemParametersInfoW(SPI_SETSCREENSAVERRUNNING, TRUE, NULL, 0);

    CallNotificationDlls(Session, StartScreenSaverHandler);

    /* Wait the end of the process or some other activity */
    ResetEvent(Session->hUserActivity);
    HandleArray[0] = ProcessInformation.hProcess;
    HandleArray[1] = Session->hUserActivity;
    Status = WaitForMultipleObjects(2, HandleArray, FALSE, INFINITE);
    if (Status == WAIT_OBJECT_0 + 1)
    {
        /* Kill the screen saver */
        TerminateProcess(ProcessInformation.hProcess, 0);
    }

    SetEvent(Session->hEndOfScreenSaver);

    CloseHandle(ProcessInformation.hProcess);

    CallNotificationDlls(Session, StopScreenSaverHandler);

cleanup:
    if (hKey)
        RegCloseKey(hKey);

    if (hCurrentUser)
        RegCloseKey(hCurrentUser);

    RevertToSelf();

    if (!ret)
    {
        PostMessageW(Session->SASWindow, WLX_WM_SAS, WLX_SAS_TYPE_SCRNSVR_ACTIVITY, 0);
#ifndef USE_GETLASTINPUTINFO
        InterlockedExchange((LONG*)&Session->LastActivity, GetTickCount());
#endif
    }
}

Referenced by DispatchSAS().

StartSystemShutdown()

DWORD StartSystemShutdown	(	IN PUNICODE_STRING	pMessage,
		IN ULONG	dwTimeout,
		IN BOOLEAN	bForceAppsClosed,
		IN BOOLEAN	bRebootAfterShutdown,
		IN ULONG	dwReason
	)

Definition at line 337 of file shutdown.c.

{
    HANDLE hThread;

    /* Fail if the timeout is 10 years or more */
    if (dwTimeout >= SECONDS_PER_DECADE)
        return ERROR_INVALID_PARAMETER;

    if (_InterlockedCompareExchange8((volatile char*)&g_ShutdownParams.bShuttingDown, TRUE, FALSE) == TRUE)
        return ERROR_SHUTDOWN_IN_PROGRESS;

    if ((dwTimeout != 0) && pMessage && pMessage->Length && pMessage->Buffer)
    {
        g_ShutdownParams.pszMessage = HeapAlloc(GetProcessHeap(),
                                                HEAP_ZERO_MEMORY,
                                                pMessage->Length + sizeof(UNICODE_NULL));
        if (g_ShutdownParams.pszMessage == NULL)
        {
            g_ShutdownParams.bShuttingDown = FALSE;
            return GetLastError();
        }

        wcsncpy(g_ShutdownParams.pszMessage,
                pMessage->Buffer,
                pMessage->Length / sizeof(WCHAR));
    }
    else
    {
        g_ShutdownParams.pszMessage = NULL;
    }

    g_ShutdownParams.dwTimeout = dwTimeout;
    g_ShutdownParams.bForceAppsClosed = bForceAppsClosed;
    g_ShutdownParams.bRebootAfterShutdown = bRebootAfterShutdown;
    g_ShutdownParams.dwReason = dwReason;

    /* If dwTimeout is zero perform an immediate system shutdown,
     * otherwise display the countdown shutdown dialog. */
    if (g_ShutdownParams.dwTimeout == 0)
    {
        if (DoSystemShutdown(&g_ShutdownParams))
            return ERROR_SUCCESS;
    }
    else
    {
        hThread = CreateThread(NULL, 0, InitiateSystemShutdownThread,
                               &g_ShutdownParams, 0, NULL);
        if (hThread)
        {
            CloseHandle(hThread);
            return ERROR_SUCCESS;
        }
    }

    if (g_ShutdownParams.pszMessage)
    {
        HeapFree(GetProcessHeap(), 0, g_ShutdownParams.pszMessage);
        g_ShutdownParams.pszMessage = NULL;
    }

    g_ShutdownParams.bShuttingDown = FALSE;
    return GetLastError();
}

Referenced by BaseInitiateSystemShutdownEx().

TerminateSystemShutdown()

DWORD TerminateSystemShutdown

(

VOID

)

Definition at line 328 of file shutdown.c.

{
    if (_InterlockedCompareExchange8((volatile char*)&g_ShutdownParams.bShuttingDown, FALSE, TRUE) == FALSE)
        return ERROR_NO_SHUTDOWN_IN_PROGRESS;

    return ERROR_SUCCESS;
}

Referenced by BaseAbortSystemShutdown().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

winlogon

)

WlxAssignShellProtection()

int WINAPI WlxAssignShellProtection	(	HANDLE	hWlx,
		HANDLE	hToken,
		HANDLE	hProcess,
		HANDLE	hThread
	)

Definition at line 248 of file wlx.c.

{
    UNREFERENCED_PARAMETER(hWlx);
    UNREFERENCED_PARAMETER(hToken);
    UNREFERENCED_PARAMETER(hProcess);
    UNREFERENCED_PARAMETER(hThread);

    UNIMPLEMENTED;
    return 0;
}

WlxChangePasswordNotify()

int WINAPI WlxChangePasswordNotify	(	HANDLE	hWlx,
		PWLX_MPR_NOTIFY_INFO	pMprInfo,
		DWORD	dwChangeInfo
	)

Definition at line 423 of file wlx.c.

{
    UNREFERENCED_PARAMETER(hWlx);
    UNREFERENCED_PARAMETER(pMprInfo);
    UNREFERENCED_PARAMETER(dwChangeInfo);

    UNIMPLEMENTED;
    return 0;
}

WlxChangePasswordNotifyEx()

int WINAPI WlxChangePasswordNotifyEx	(	HANDLE	hWlx,
		PWLX_MPR_NOTIFY_INFO	pMprInfo,
		DWORD	dwChangeInfo,
		PWSTR	ProviderName,
		PVOID	Reserved
	)

Definition at line 495 of file wlx.c.

{
    UNREFERENCED_PARAMETER(hWlx);
    UNREFERENCED_PARAMETER(pMprInfo);
    UNREFERENCED_PARAMETER(dwChangeInfo);
    UNREFERENCED_PARAMETER(ProviderName);
    UNREFERENCED_PARAMETER(Reserved);

    UNIMPLEMENTED;
    return 0;
}

WlxCloseUserDesktop()

BOOL WINAPI WlxCloseUserDesktop	(	HANDLE	hWlx,
		PWLX_DESKTOP	pDesktop,
		HANDLE	hToken
	)

Definition at line 517 of file wlx.c.

{
    UNREFERENCED_PARAMETER(hWlx);
    UNREFERENCED_PARAMETER(pDesktop);
    UNREFERENCED_PARAMETER(hToken);

    UNIMPLEMENTED;
    return FALSE;
}

WlxCreateUserDesktop()

BOOL WINAPI WlxCreateUserDesktop	(	HANDLE	hWlx,
		HANDLE	hToken,
		DWORD	Flags,
		PWSTR	pszDesktopName,
		PWLX_DESKTOP *	ppDesktop
	)

Definition at line 473 of file wlx.c.

{
    UNREFERENCED_PARAMETER(hWlx);
    UNREFERENCED_PARAMETER(hToken);
    UNREFERENCED_PARAMETER(Flags);
    UNREFERENCED_PARAMETER(pszDesktopName);
    UNREFERENCED_PARAMETER(ppDesktop);

    UNIMPLEMENTED;
    return FALSE;
}

WlxDialogBox()

int WINAPI WlxDialogBox	(	HANDLE	hWlx,
		HANDLE	hInst,
		LPWSTR	lpszTemplate,
		HWND	hwndOwner,
		DLGPROC	dlgprc
	)

Definition at line 287 of file wlx.c.

{
    UNREFERENCED_PARAMETER(hWlx);

    TRACE("WlxDialogBox()\n");

    return (int)WlxDialogBoxParam(hWlx, hInst, lpszTemplate, hwndOwner, dlgprc, 0);
}

WlxDialogBoxIndirect()

int WINAPI WlxDialogBoxIndirect	(	HANDLE	hWlx,
		HANDLE	hInst,
		LPCDLGTEMPLATE	hDialogTemplate,
		HWND	hwndOwner,
		DLGPROC	dlgprc
	)

Definition at line 340 of file wlx.c.

{
    UNREFERENCED_PARAMETER(hWlx);

    TRACE("WlxDialogBoxIndirect()\n");

    return (int)WlxDialogBoxIndirectParam(hWlx, hInst, hDialogTemplate, hwndOwner, dlgprc, 0);
}

WlxDialogBoxIndirectParam()

int WINAPI WlxDialogBoxIndirectParam	(	HANDLE	hWlx,
		HANDLE	hInst,
		LPCDLGTEMPLATE	hDialogTemplate,
		HWND	hwndOwner,
		DLGPROC	dlgprc,
		LPARAM	dwInitParam
	)

Definition at line 359 of file wlx.c.

{
    PDIALOG_LIST_ENTRY ListEntry;
    int ret;

    UNREFERENCED_PARAMETER(hWlx);

    TRACE("WlxDialogBoxIndirectParam()\n");

    ListEntry = AddDialogListEntry();
    if (ListEntry == NULL)
        return -1;

    ListEntry->DlgProc = dlgprc;
    ListEntry->lParam = dwInitParam;

    ret = (int)DialogBoxIndirectParamW(hInst, hDialogTemplate, hwndOwner, DefaultWlxWindowProc, (LPARAM)ListEntry);

    RemoveDialogListEntry(ListEntry);

    return ret;
}

Referenced by WlxDialogBoxIndirect().

WlxDialogBoxParam()

int WINAPI WlxDialogBoxParam	(	HANDLE	hWlx,
		HANDLE	hInst,
		LPWSTR	lpszTemplate,
		HWND	hwndOwner,
		DLGPROC	dlgprc,
		LPARAM	dwInitParam
	)

Definition at line 306 of file wlx.c.

{
    PDIALOG_LIST_ENTRY ListEntry;
    int ret;

    UNREFERENCED_PARAMETER(hWlx);

    TRACE("WlxDialogBoxParam()\n");

    ListEntry = AddDialogListEntry();
    if (ListEntry == NULL)
        return -1;

    ListEntry->DlgProc = dlgprc;
    ListEntry->lParam = dwInitParam;

    ret = (int)DialogBoxParamW(hInst, lpszTemplate, hwndOwner, DefaultWlxWindowProc, (LPARAM)ListEntry);

    RemoveDialogListEntry(ListEntry);

    return ret;
}

Referenced by WlxDialogBox().

WlxDisconnect()

BOOL WINAPI WlxDisconnect

(

VOID

)

Definition at line 667 of file wlx.c.

{
    UNIMPLEMENTED;
    return FALSE;
}

WlxGetOption()