#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 <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 DWORD *typedef	BOOL (WINAPI *PFWLXINITIALIZE)(LPWSTR

typedef DWORD *typedef	HANDLE

typedef DWORD *typedef	PVOID

typedef DWORD typedef PVOID typedef	VOID (WINAPI *PFWLXDISPLAYSASNOTICE)(PVOID)

typedef PVOID *typedef	PWSTR

typedef DWORD	DWORD

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

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

	WINE_DEFAULT_DEBUG_CHANNEL (winlogon)

typedef	BOOL (WINAPI *PFWLXNEGOTIATE)(DWORD

typedef	int (WINAPI *PFWLXLOGGEDOUTSAS)(PVOID

typedef	VOID (WINAPI *PFWLXDISPLAYLOCKEDNOTICE)(PVOID)

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)

DWORD	GetSetupType (VOID)

BOOL	RunSetup (VOID)

DWORD	TerminateSystemShutdown (VOID)

DWORD	StartSystemShutdown (PUNICODE_STRING lpMessage, ULONG dwTimeout, BOOLEAN bForceAppsClosed, BOOLEAN bRebootAfterShutdown, 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	AddAceToWindowStation (IN HWINSTA WinSta, IN PSID Sid)

BOOL	CreateWindowStationAndDesktops (IN OUT 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
typedef	PLUID

typedef	PSID

typedef	PDWORD

typedef	PHANDLE

typedef	PWLX_MPR_NOTIFY_INFO

typedef	HDESK

HINSTANCE	hAppInstance

PWLSESSION	WLSession

LUID	LuidNone

Macro Definition Documentation

#define LockWorkstation ( Session )

Definition at line 210 of file winlogon.h.

Referenced by WinMain().

#define UnlockWorkstation ( Session )

Definition at line 211 of file winlogon.h.

#define USE_GETLASTINPUTINFO

Definition at line 31 of file winlogon.h.

#define WIN32_NO_STATUS

Definition at line 33 of file winlogon.h.

#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 270 of file winlogon.h.

Referenced by DoGenericAction().

#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 276 of file winlogon.h.

Typedef Documentation

typedef CONST PIXELFORMATDESCRIPTOR *typedef CONST PIXELFORMATDESCRIPTOR *typedef BOOL(WINAPI *SWAPBUFFERS)(HDC hdc)

Definition at line 60 of file winlogon.h.

typedef DWORD

Definition at line 83 of file winlogon.h.

typedef struct _GINAFUNCTIONS GINAFUNCTIONS

typedef struct _GINAINSTANCE GINAINSTANCE

typedef HANDLE

Definition at line 60 of file winlogon.h.

typedef enum _LOGON_STATE LOGON_STATE

typedef enum _NOTIFICATION_TYPE NOTIFICATION_TYPE

typedef struct _GINAFUNCTIONS * PGINAFUNCTIONS

typedef struct _GINAINSTANCE * PGINAINSTANCE

typedef enum _LOGON_STATE * PLOGON_STATE

typedef enum _NOTIFICATION_TYPE * PNOTIFICATION_TYPE

typedef PVOID

Definition at line 60 of file winlogon.h.

typedef struct _WLSESSION * PWLSESSION

static PWSTR

Definition at line 65 of file winlogon.h.

typedef VOID

Definition at line 61 of file winlogon.h.

typedef struct _WLSESSION WLSESSION

Enumeration Type Documentation

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 195 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;

enum _NOTIFICATION_TYPE

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

Definition at line 250 of file winlogon.h.

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

Function Documentation

BOOL AddAceToWindowStation	(	IN HWINSTA	WinSta,
		IN PSID	Sid
	)

Definition at line 942 of file wlx.c.

Referenced by AllowWinstaAccess().

 {
     DWORD AclSize;
     SECURITY_INFORMATION SecurityInformation;
     PACL pDefaultAcl = NULL;
     PSECURITY_DESCRIPTOR WinstaSd = NULL;
     PACCESS_ALLOWED_ACE Ace = NULL;
     BOOL Ret = FALSE;
 
     /* Allocate space for an ACL */
     AclSize = sizeof(ACL)
         + 2 * (FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart) + GetLengthSid(Sid));
     pDefaultAcl = HeapAlloc(GetProcessHeap(), 0, AclSize);
     if (!pDefaultAcl)
     {
         ERR("WL: HeapAlloc() failed\n");
         goto cleanup;
     }
 
     /* Initialize it */
     if (!InitializeAcl(pDefaultAcl, AclSize, ACL_REVISION))
     {
         ERR("WL: InitializeAcl() failed (error %lu)\n", GetLastError());
         goto cleanup;
     }
 
     /* Initialize new security descriptor */
     WinstaSd = HeapAlloc(GetProcessHeap(), 0, SECURITY_DESCRIPTOR_MIN_LENGTH);
     if (!InitializeSecurityDescriptor(WinstaSd, SECURITY_DESCRIPTOR_REVISION))
     {
         ERR("WL: InitializeSecurityDescriptor() failed (error %lu)\n", GetLastError());
         goto cleanup;
     }
 
     /* Allocate memory for access allowed ACE */
     Ace = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ACCESS_ALLOWED_ACE)+
         GetLengthSid(Sid) - sizeof(DWORD));
 
     /* Create the first ACE for the window station */
     Ace->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
     Ace->Header.AceFlags = CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE | OBJECT_INHERIT_ACE;
     Ace->Header.AceSize = sizeof(ACCESS_ALLOWED_ACE) + GetLengthSid(Sid) - sizeof(DWORD);
     Ace->Mask = GENERIC_ACCESS;
 
     /* Copy the sid */
     if (!CopySid(GetLengthSid(Sid), &Ace->SidStart, Sid))
     {
         ERR("WL: CopySid() failed (error %lu)\n", GetLastError());
         goto cleanup;
     }
 
     /* Add the first ACE */
     if (!AddAce(pDefaultAcl, ACL_REVISION, MAXDWORD, (LPVOID)Ace, Ace->Header.AceSize))
     {
         ERR("WL: AddAce() failed (error %lu)\n", GetLastError());
         goto cleanup;
     }
 
     /* Add the second ACE to the end of ACL */
     Ace->Header.AceFlags = NO_PROPAGATE_INHERIT_ACE;
     Ace->Mask = WINSTA_ALL;
     if (!AddAce(pDefaultAcl, ACL_REVISION, MAXDWORD, (LPVOID)Ace, Ace->Header.AceSize))
     {
         ERR("WL: AddAce() failed (error %lu)\n", GetLastError());
         goto cleanup;
     }
 
     /* Add ACL to winsta's security descriptor */
     if (!SetSecurityDescriptorDacl(WinstaSd, TRUE, pDefaultAcl, FALSE))
     {
         ERR("WL: SetSecurityDescriptorDacl() failed (error %lu)\n", GetLastError());
         goto cleanup;
     }
 
     /* Apply security to the window station */
     SecurityInformation = DACL_SECURITY_INFORMATION;
     if (!SetUserObjectSecurity(WinSta, &SecurityInformation, WinstaSd))
     {
         ERR("WL: SetUserObjectSecurity() failed (error %lu)\n", GetLastError());
         goto cleanup;
     }
 
     /* Indicate success */
     Ret = TRUE;
 
 cleanup:
     /* Free allocated stuff */
     if (pDefaultAcl) HeapFree(GetProcessHeap(), 0, pDefaultAcl);
     if (WinstaSd) HeapFree(GetProcessHeap(), 0, WinstaSd);
     if (Ace) HeapFree(GetProcessHeap(), 0, Ace);
 
     return Ret;
 }

typedef BOOL ( WINAPI * PFWLXNEGOTIATE )

VOID CallNotificationDlls	(	PWLSESSION	pSession,
		NOTIFICATION_TYPE	Type
	)

Definition at line 249 of file notify.c.

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

 {
     PLIST_ENTRY ListEntry;
     PNOTIFICATION_ITEM NotificationDll;
     WLX_NOTIFICATION_INFO Info;
 
     TRACE("CallNotificationDlls()\n");
 
     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)
         {
 TRACE("NotificationDll->Handler: %p\n", NotificationDll->Handler[Type]);
             if (NotificationDll->Handler[Type] != NULL)
                 NotificationDll->Handler[Type](&Info);
         }
 
         ListEntry = ListEntry->Flink;
     }
 }

VOID CleanupNotifications ( VOID )

Definition at line 318 of file notify.c.

Referenced by WinMain().

 {
     PLIST_ENTRY ListEntry;
     PNOTIFICATION_ITEM NotificationDll;
 
     ListEntry = NotificationDllListHead.Flink;
     while (ListEntry != &NotificationDllListHead)
     {
         NotificationDll = CONTAINING_RECORD(ListEntry,
                                             NOTIFICATION_ITEM,
                                             ListEntry);
         if (NotificationDll != NULL)
         {
             FreeLibrary(NotificationDll->hInstance);
         }
 
         ListEntry = ListEntry->Flink;
 
         RemoveEntryList(&NotificationDll->ListEntry);
 
         RtlFreeHeap(RtlGetProcessHeap(), 0, NotificationDll);
     }
 }

VOID CloseAllDialogWindows ( VOID )

Definition at line 109 of file wlx.c.

Referenced by DispatchSAS().

 {
     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;
     }
 }

BOOL CreateUserEnvironment ( IN PWLSESSION Session )

Definition at line 128 of file environment.c.

Referenced by HandleLogon().

 {
     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;
 }

BOOL CreateWindowStationAndDesktops ( IN OUT PWLSESSION Session )

Definition at line 1121 of file wlx.c.

Referenced by WinMain().

 {
     BYTE LocalSystemBuffer[SECURITY_MAX_SID_SIZE];
     BYTE InteractiveBuffer[SECURITY_MAX_SID_SIZE];
     PSID pLocalSystemSid = (PSID)&LocalSystemBuffer;
     PSID pInteractiveSid = (PSID)InteractiveBuffer;
     DWORD SidSize, AclSize;
     PACL pDefaultAcl = NULL;
     PACL pUserDesktopAcl = NULL;
     SECURITY_DESCRIPTOR DefaultSecurityDescriptor;
     SECURITY_ATTRIBUTES DefaultSecurity;
     SECURITY_DESCRIPTOR UserDesktopSecurityDescriptor;
     SECURITY_ATTRIBUTES UserDesktopSecurity;
     BOOL ret = FALSE;
 
     /*
      * Prepare information for ACLs we will apply
      */
     SidSize = SECURITY_MAX_SID_SIZE;
     if (!CreateWellKnownSid(WinLocalSystemSid, NULL, pLocalSystemSid, &SidSize))
     {
         ERR("WL: CreateWellKnownSid() failed (error %lu)\n", GetLastError());
         goto cleanup;
     }
     SidSize = SECURITY_MAX_SID_SIZE;
     if (!CreateWellKnownSid(WinInteractiveSid, NULL, pInteractiveSid, &SidSize))
     {
         ERR("WL: CreateWellKnownSid() failed (error %lu)\n", GetLastError());
         goto cleanup;
     }
 
     AclSize = sizeof(ACL)
         + FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart) + GetLengthSid(pLocalSystemSid)
         + FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart) + GetLengthSid(pInteractiveSid);
     pDefaultAcl = HeapAlloc(GetProcessHeap(), 0, AclSize);
     pUserDesktopAcl = HeapAlloc(GetProcessHeap(), 0, AclSize);
     if (!pDefaultAcl || !pUserDesktopAcl)
     {
         ERR("WL: HeapAlloc() failed\n");
         goto cleanup;
     }
 
     if (!InitializeAcl(pDefaultAcl, AclSize, ACL_REVISION)
      || !InitializeAcl(pUserDesktopAcl, AclSize, ACL_REVISION))
     {
         ERR("WL: InitializeAcl() failed (error %lu)\n", GetLastError());
         goto cleanup;
     }
 
     /*
      * Create default ACL (window station, winlogon desktop, screen saver desktop)
      */
     if (!AddAccessAllowedAce(pDefaultAcl, ACL_REVISION, GENERIC_ALL, pLocalSystemSid)
      || !AddAccessAllowedAce(pDefaultAcl, ACL_REVISION, GENERIC_READ, pInteractiveSid))
     {
         ERR("WL: AddAccessAllowedAce() failed (error %lu)\n", GetLastError());
         goto cleanup;
     }
 
     /*
      * Create the default security descriptor
      */
     if (!InitializeSecurityDescriptor(&DefaultSecurityDescriptor, SECURITY_DESCRIPTOR_REVISION))
     {
         ERR("WL: InitializeSecurityDescriptor() failed (error %lu)\n", GetLastError());
         goto cleanup;
     }
 
     if (!SetSecurityDescriptorDacl(&DefaultSecurityDescriptor, TRUE, pDefaultAcl, FALSE))
     {
         ERR("WL: SetSecurityDescriptorDacl() failed (error %lu)\n", GetLastError());
         goto cleanup;
     }
 
     DefaultSecurity.nLength = sizeof(SECURITY_ATTRIBUTES);
     DefaultSecurity.lpSecurityDescriptor = &DefaultSecurityDescriptor;
     DefaultSecurity.bInheritHandle = TRUE;
 
     /*
      * Create user desktop ACL
      */
     if (!AddAccessAllowedAce(pUserDesktopAcl, ACL_REVISION, GENERIC_ALL, pLocalSystemSid)
      || !AddAccessAllowedAce(pUserDesktopAcl, ACL_REVISION, GENERIC_ALL, pInteractiveSid))
     {
         ERR("WL: AddAccessAllowedAce() failed (error %lu)\n", GetLastError());
         goto cleanup;
     }
 
     /*
      * Create the user desktop security descriptor
      */
     if (!InitializeSecurityDescriptor(&UserDesktopSecurityDescriptor, SECURITY_DESCRIPTOR_REVISION))
     {
         ERR("WL: InitializeSecurityDescriptor() failed (error %lu)\n", GetLastError());
         goto cleanup;
     }
 
     if (!SetSecurityDescriptorDacl(&UserDesktopSecurityDescriptor, TRUE, pUserDesktopAcl, FALSE))
     {
         ERR("WL: SetSecurityDescriptorDacl() failed (error %lu)\n", GetLastError());
         goto cleanup;
     }
 
     UserDesktopSecurity.nLength = sizeof(SECURITY_ATTRIBUTES);
     UserDesktopSecurity.lpSecurityDescriptor = &UserDesktopSecurityDescriptor;
     UserDesktopSecurity.bInheritHandle = TRUE;
 
     /*
      * Create the interactive window station
      */
     Session->InteractiveWindowStationName = L"WinSta0";
     Session->InteractiveWindowStation = CreateWindowStationW(
         Session->InteractiveWindowStationName,
         0,
         MAXIMUM_ALLOWED,
         &DefaultSecurity);
     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,
         &UserDesktopSecurity);
     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,
         &DefaultSecurity); // FIXME: Must use restricted Winlogon-only security!!
     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,
         &DefaultSecurity);
     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;
         }
     }
     HeapFree(GetProcessHeap(), 0, pDefaultAcl);
     HeapFree(GetProcessHeap(), 0, pUserDesktopAcl);
     return ret;
 }

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

Definition at line 216 of file winlogon.c.

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

 {
     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);
 }

DWORD GetSetupType ( VOID )

Definition at line 16 of file setup.c.

Referenced by SASWindowProc(), and WinMain().

 {
     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;
 }

BOOL GinaInit ( IN OUT PWLSESSION Session )

Definition at line 919 of file wlx.c.

Referenced by WinMain().

 {
     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);
 }

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

Definition at line 969 of file sas.c.

Referenced by DoGenericAction(), and WinMain().

 {
     PLOGOFF_SHUTDOWN_DATA LSData;
     HANDLE hThread;
     DWORD exitCode;
     BOOLEAN Old;
 
     // SwitchDesktop(Session->WinlogonDesktop);
     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;
 }

VOID InitDialogListHead ( VOID )

Definition at line 45 of file wlx.c.

Referenced by WinMain().

 {
     InitializeListHead(&DialogListHead);
 }

BOOL InitializeSAS ( IN OUT PWLSESSION Session )

Definition at line 1508 of file sas.c.

Referenced by WinMain().

 {
     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;
 }

BOOL InitializeScreenSaver ( IN OUT PWLSESSION Session )

Definition at line 204 of file screensaver.c.

Referenced by HandleLogon().

 {
     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;
 }

BOOL InitNotifications ( VOID )

Definition at line 196 of file notify.c.

Referenced by WinMain().

 {
     HKEY hNotifyKey = NULL;
     LONG lError;
     DWORD dwIndex;
     WCHAR szKeyName[80];
     DWORD dwKeyName;
 
     TRACE("InitNotifications()\n");
 
     InitializeListHead(&NotificationDllListHead);
 
     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);
         LoadNotificationDll(hNotifyKey, szKeyName);
 
         dwIndex++;
     }
 
     RegCloseKey(hNotifyKey);
 
     TRACE("InitNotifications() done\n");
 
     return TRUE;
 }

typedef int ( WINAPI * PFWLXLOGGEDOUTSAS )

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

Definition at line 239 of file sas.c.

Referenced by HandleMessageBeep(), and PlayLogonSoundThread().

 {
     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(500, 500);
                 }
                 FreeLibrary(hLibrary);
                 return FALSE;
             }
         }
 
         Play = (PLAYSOUNDW)GetProcAddress(hLibrary, "PlaySoundW");
         if (Play)
         {
             Ret = Play(FileName, NULL, Flags);
         }
         FreeLibrary(hLibrary);
     }
 
     return Ret;
 }

BOOL RemoveStatusMessage ( IN PWLSESSION Session )

Definition at line 237 of file winlogon.c.

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

 {
     if (Session->Gina.Version < WLX_VERSION_1_3)
         return TRUE;
 
     return Session->Gina.Functions.WlxRemoveStatusMessage(Session->Gina.Context);
 }

BOOL RunSetup ( VOID )

Definition at line 153 of file setup.c.

Referenced by WinMain().

 {
     HANDLE hThread;
 
     hThread = CreateThread(NULL,
                            0,
                            RunSetupThreadProc,
                            NULL,
                            0,
                            NULL);
     if (hThread != NULL)
         CloseHandle(hThread);
 
     return hThread != NULL;
 }

BOOL SetDefaultLanguage ( IN PWLSESSION Session )

Definition at line 110 of file sas.c.

Referenced by HandleLogon(), and InitializeSAS().

 {
     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;
 }

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

Definition at line 400 of file winsta.c.

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

 {
     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;
 }

BOOL StartRpcServer ( VOID )

Definition at line 19 of file rpcserver.c.

Referenced by WinMain().

 {
     RPC_STATUS Status;
 
     TRACE("StartRpcServer() called\n");
 
     Status = RpcServerUseProtseqEpW(L"ncacn_np",
                                     RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
                                     L"\\pipe\\winreg",
                                     NULL);
     if (Status != RPC_S_OK)
     {
         ERR("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
         return FALSE;
     }
 
     Status = RpcServerRegisterIf(winreg_v1_0_s_ifspec,
                                  NULL,
                                  NULL);
     if (Status != RPC_S_OK)
     {
         ERR("RpcServerRegisterIf() failed (Status %lx)\n", Status);
         return FALSE;
     }
 
     Status = RpcServerListen(1, 20, TRUE);
     if (Status != RPC_S_OK)
     {
         ERR("RpcServerListen() failed (Status %lx)\n", Status);
         return FALSE;
     }
 
     TRACE("StartRpcServer() done\n");
     return TRUE;
 }

VOID StartScreenSaver ( IN PWLSESSION Session )

Definition at line 257 of file screensaver.c.

Referenced by DispatchSAS().

 {
     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_SCRNSAVER;
 
     /* FIXME: run the screen saver on the screen saver desktop */
     ret = CreateProcessW(szApplicationName,
                          szCommandLine,
                          NULL,
                          NULL,
                          FALSE,
                          0,
                          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
     }
 }

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

Definition at line 218 of file shutdown.c.

Referenced by BaseInitiateSystemShutdownEx().

 {
     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 (lpMessage && lpMessage->Length && lpMessage->Buffer)
     {
         g_ShutdownParams.pszMessage = HeapAlloc(GetProcessHeap(),
                                                 HEAP_ZERO_MEMORY,
                                                 lpMessage->Length + sizeof(UNICODE_NULL));
         if (g_ShutdownParams.pszMessage == NULL)
         {
             g_ShutdownParams.bShuttingDown = FALSE;
             return GetLastError();
         }
 
         wcsncpy(g_ShutdownParams.pszMessage,
                 lpMessage->Buffer,
                 lpMessage->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, (PVOID)&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();
 }

DWORD TerminateSystemShutdown ( VOID )

Definition at line 208 of file shutdown.c.

Referenced by BaseAbortSystemShutdown().

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

typedef VOID ( WINAPI * PFWLXDISPLAYLOCKEDNOTICE )

WINE_DEFAULT_DEBUG_CHANNEL ( winlogon )

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

Definition at line 262 of file wlx.c.

 {
     UNREFERENCED_PARAMETER(hWlx);
     UNREFERENCED_PARAMETER(hToken);
     UNREFERENCED_PARAMETER(hProcess);
     UNREFERENCED_PARAMETER(hThread);
 
     UNIMPLEMENTED;
     return 0;
 }

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

Definition at line 437 of file wlx.c.

 {
     UNREFERENCED_PARAMETER(hWlx);
     UNREFERENCED_PARAMETER(pMprInfo);
     UNREFERENCED_PARAMETER(dwChangeInfo);
 
     UNIMPLEMENTED;
     return 0;
 }

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

Definition at line 509 of file wlx.c.

 {
     UNREFERENCED_PARAMETER(hWlx);
     UNREFERENCED_PARAMETER(pMprInfo);
     UNREFERENCED_PARAMETER(dwChangeInfo);
     UNREFERENCED_PARAMETER(ProviderName);
     UNREFERENCED_PARAMETER(Reserved);
 
     UNIMPLEMENTED;
     return 0;
 }

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

Definition at line 531 of file wlx.c.

 {
     UNREFERENCED_PARAMETER(hWlx);
     UNREFERENCED_PARAMETER(pDesktop);
     UNREFERENCED_PARAMETER(hToken);
 
     UNIMPLEMENTED;
     return FALSE;
 }

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

Definition at line 487 of file wlx.c.

 {
     UNREFERENCED_PARAMETER(hWlx);
     UNREFERENCED_PARAMETER(hToken);
     UNREFERENCED_PARAMETER(Flags);
     UNREFERENCED_PARAMETER(pszDesktopName);
     UNREFERENCED_PARAMETER(ppDesktop);
 
     UNIMPLEMENTED;
     return FALSE;
 }

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

Definition at line 301 of file wlx.c.

 {
     UNREFERENCED_PARAMETER(hWlx);
 
     TRACE("WlxDialogBox()\n");
 
     return (int)WlxDialogBoxParam(hWlx, hInst, lpszTemplate, hwndOwner, dlgprc, 0);
 }

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

Definition at line 354 of file wlx.c.

 {
     UNREFERENCED_PARAMETER(hWlx);
 
     TRACE("WlxDialogBoxIndirect()\n");
 
     return (int)WlxDialogBoxIndirectParam(hWlx, hInst, hDialogTemplate, hwndOwner, dlgprc, 0);
 }

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

Definition at line 373 of file wlx.c.

Referenced by WlxDialogBoxIndirect().

 {
     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;
 }

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

Definition at line 320 of file wlx.c.

Referenced by WlxDialogBox().

 {
     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;
 }

BOOL WINAPI WlxDisconnect ( VOID )

Definition at line 681 of file wlx.c.

 {
     UNIMPLEMENTED;
     return FALSE;
 }

BOOL WINAPI WlxGetOption	(	HANDLE	hWlx,
		DWORD	Option,
		ULONG_PTR *	Value
	)

Definition at line 582 of file wlx.c.

 {
     PWLSESSION Session = (PWLSESSION)hWlx;
 
     TRACE("WlxGetOption(%lu)\n", Option);
 
     switch (Option)
     {
         case WLX_OPTION_USE_CTRL_ALT_DEL:
             *Value = (ULONG_PTR)Session->Gina.UseCtrlAltDelete;
             return TRUE;
         case WLX_OPTION_CONTEXT_POINTER:
         {
             *Value = (ULONG_PTR)Session->Gina.Context;
             return TRUE;
         }
         case WLX_OPTION_USE_SMART_CARD:
         case WLX_OPTION_SMART_CARD_PRESENT:
         case WLX_OPTION_SMART_CARD_INFO:
             UNIMPLEMENTED;
             return FALSE;
         case WLX_OPTION_DISPATCH_TABLE_SIZE:
         {
             switch (Session->Gina.Version)
             {
                 case WLX_VERSION_1_0:
                     *Value = sizeof(WLX_DISPATCH_VERSION_1_0);
                     break;
                 case WLX_VERSION_1_1:
                     *Value = sizeof(WLX_DISPATCH_VERSION_1_1);
                     break;
                 case WLX_VERSION_1_2:
                     *Value = sizeof(WLX_DISPATCH_VERSION_1_2);
                     break;
                 case WLX_VERSION_1_3:
                     *Value = sizeof(WLX_DISPATCH_VERSION_1_3);
                     break;
                 case WLX_VERSION_1_4:
                     *Value = sizeof(WLX_DISPATCH_VERSION_1_4);
                     break;
                 default:
                     return FALSE;
             }
             return TRUE;
         }
     }
 
     return FALSE;
 }

BOOL WINAPI WlxGetSourceDesktop	(	HANDLE	hWlx,
		PWLX_DESKTOP *	ppDesktop
	)

Definition at line 455 of file wlx.c.

 {
     UNREFERENCED_PARAMETER(hWlx);
     UNREFERENCED_PARAMETER(ppDesktop);
 
     UNIMPLEMENTED;
     return FALSE;
 }

int WINAPI WlxMessageBox	(	HANDLE	hWlx,
		HWND	hwndOwner,
		LPWSTR	lpszText,
		LPWSTR	lpszTitle,
		UINT	fuStyle
	)

Definition at line 282 of file wlx.c.

 {
     UNREFERENCED_PARAMETER(hWlx);
 
     TRACE("WlxMessageBox()\n");
     /* FIXME: Provide a custom window proc to be able to handle timeout */
     return MessageBoxW(hwndOwner, lpszText, lpszTitle, fuStyle);
 }

BOOL WINAPI WlxQueryClientCredentials ( PWLX_CLIENT_CREDENTIALS_INFO_V1_0 pCred )

Definition at line 653 of file wlx.c.

 {
     UNREFERENCED_PARAMETER(pCred);
 
     UNIMPLEMENTED;
     return FALSE;
 }

DWORD WINAPI WlxQueryConsoleSwitchCredentials ( PWLX_CONSOLESWITCH_CREDENTIALS_INFO_V1_0 pCred )

Definition at line 712 of file wlx.c.

 {
     UNREFERENCED_PARAMETER(pCred);
 
     UNIMPLEMENTED;
     return 0;
 }

BOOL WINAPI WlxQueryInetConnectorCredentials ( PWLX_CLIENT_CREDENTIALS_INFO_V1_0 pCred )

Definition at line 667 of file wlx.c.

 {
     UNREFERENCED_PARAMETER(pCred);
 
     UNIMPLEMENTED;
     return FALSE;
 }

DWORD WINAPI WlxQueryTerminalServicesData	(	HANDLE	hWlx,
		PWLX_TERMINAL_SERVICES_DATA	pTSData,
		WCHAR *	UserName,
		WCHAR *	Domain
	)

Definition at line 692 of file wlx.c.

 {
     UNREFERENCED_PARAMETER(hWlx);
     UNREFERENCED_PARAMETER(pTSData);
     UNREFERENCED_PARAMETER(UserName);
     UNREFERENCED_PARAMETER(Domain);
 
     UNIMPLEMENTED;
     return 0;
 }

BOOL WINAPI WlxQueryTsLogonCredentials ( PWLX_CLIENT_CREDENTIALS_INFO_V2_0 pCred )

Definition at line 726 of file wlx.c.

 {
     UNREFERENCED_PARAMETER(pCred);
 
     UNIMPLEMENTED;
     return FALSE;
 }

VOID WINAPI WlxSasNotify	(	HANDLE	hWlx,
		DWORD	dwSasType
	)

Definition at line 228 of file wlx.c.

 {
     PWLSESSION Session = (PWLSESSION)hWlx;
 
     TRACE("WlxSasNotify(0x%lx)\n", dwSasType);
 
     if (dwSasType == WLX_SAS_TYPE_CTRL_ALT_DEL || dwSasType > WLX_SAS_TYPE_MAX_MSFT_VALUE)
         PostMessageW(Session->SASWindow, WLX_WM_SAS, dwSasType, 0);
 }

VOID WINAPI WlxSetContextPointer	(	HANDLE	hWlx,
		PVOID	pWlxContext
	)

Definition at line 212 of file wlx.c.

 {
     ULONG_PTR OldValue;
 
     TRACE("WlxSetContextPointer(%p)\n", pWlxContext);
 
     WlxSetOption(hWlx, WLX_OPTION_CONTEXT_POINTER, (ULONG_PTR)pWlxContext, &OldValue);
 }

BOOL WINAPI WlxSetOption	(	HANDLE	hWlx,
		DWORD	Option,
		ULONG_PTR	Value,
		ULONG_PTR *	OldValue
	)

Definition at line 549 of file wlx.c.

Referenced by WlxSetContextPointer(), and WlxUseCtrlAltDel().

 {
     PWLSESSION Session = (PWLSESSION)hWlx;
 
     TRACE("WlxSetOption(%lu)\n", Option);
 
     switch (Option)
     {
         case WLX_OPTION_USE_CTRL_ALT_DEL:
             *OldValue = (ULONG_PTR)Session->Gina.UseCtrlAltDelete;
             Session->Gina.UseCtrlAltDelete = (BOOL)Value;
             return TRUE;
         case WLX_OPTION_CONTEXT_POINTER:
             *OldValue = (ULONG_PTR)Session->Gina.Context;
             Session->Gina.Context = (PVOID)Value;
             return TRUE;
         case WLX_OPTION_USE_SMART_CARD:
             UNIMPLEMENTED;
             return FALSE;
     }
 
     return FALSE;
 }

BOOL WINAPI WlxSetReturnDesktop	(	HANDLE	hWlx,
		PWLX_DESKTOP	pDesktop
	)

Definition at line 471 of file wlx.c.

 {
     UNREFERENCED_PARAMETER(hWlx);
     UNREFERENCED_PARAMETER(pDesktop);
 
     UNIMPLEMENTED;
     return FALSE;
 }

BOOL WINAPI WlxSetTimeout	(	HANDLE	hWlx,
		DWORD	Timeout
	)

Definition at line 245 of file wlx.c.

 {
     PWLSESSION Session = (PWLSESSION)hWlx;
 
     TRACE("WlxSetTimeout(%lu)\n", Timeout);
 
     Session->DialogTimeout = Timeout;
     return TRUE;
 }

int WINAPI WlxSwitchDesktopToUser ( HANDLE hWlx )

Definition at line 407 of file wlx.c.

 {
     PWLSESSION Session = (PWLSESSION)hWlx;
 
     TRACE("WlxSwitchDesktopToUser()\n");
 
     return (int)SwitchDesktop(Session->ApplicationDesktop);
 }

int WINAPI WlxSwitchDesktopToWinlogon ( HANDLE hWlx )

Definition at line 422 of file wlx.c.

 {
     PWLSESSION Session = (PWLSESSION)hWlx;
 
     TRACE("WlxSwitchDesktopToWinlogon()\n");
 
     return (int)SwitchDesktop(Session->WinlogonDesktop);
 }

VOID WINAPI WlxUseCtrlAltDel ( HANDLE hWlx )

Definition at line 197 of file wlx.c.

 {
     ULONG_PTR OldValue;
 
     TRACE("WlxUseCtrlAltDel()\n");
 
     WlxSetOption(hWlx, WLX_OPTION_USE_CTRL_ALT_DEL, TRUE, &OldValue);
 }

VOID WINAPI WlxWin31Migrate ( HANDLE hWlx )

Definition at line 640 of file wlx.c.

 {
     UNREFERENCED_PARAMETER(hWlx);
 
     UNIMPLEMENTED;
 }

Variable Documentation

LUID LuidNone

Definition at line 46 of file sas.c.

Referenced by CreateWindowStationAndDesktops(), and SetWindowStationUser().

typedef PDWORD