exit.c File Reference

#include <user32.h>

Include dependency graph for exit.c:

Go to the source code of this file.

Classes
struct	EXIT_REACTOS_DATA

Typedefs
typedef struct EXIT_REACTOS_DATA *	PEXIT_REACTOS_DATA

Functions
static BOOL	ExitWindowsWorker (UINT uFlags, DWORD dwReserved, BOOL bCalledFromThread)
static DWORD WINAPI	ExitWindowsThread (LPVOID Param)
BOOL WINAPI	ExitWindowsEx (UINT uFlags, DWORD dwReserved)
BOOL WINAPI	EndTask (HWND hWnd, BOOL fShutDown, BOOL fForce)

Typedef Documentation

PEXIT_REACTOS_DATA

typedef struct EXIT_REACTOS_DATA * PEXIT_REACTOS_DATA

Function Documentation

EndTask()

BOOL WINAPI EndTask	(	HWND	hWnd,
		BOOL	fShutDown,
		BOOL	fForce
	)

Definition at line 207 of file exit.c.

{
    USER_API_MESSAGE ApiMessage;
    PUSER_END_TASK EndTaskRequest = &ApiMessage.Data.EndTaskRequest;
 
    UNREFERENCED_PARAMETER(fShutDown);
 
    // EndTaskRequest->LastError = ERROR_SUCCESS;
    EndTaskRequest->WndHandle = hWnd;
    EndTaskRequest->Force = fForce;
 
    CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
                        NULL,
                        CSR_CREATE_API_NUMBER(USERSRV_SERVERDLL_INDEX, UserpEndTask),
                        sizeof(*EndTaskRequest));
    if (!NT_SUCCESS(ApiMessage.Status))
    {
        UserSetLastNTError(ApiMessage.Status);
        return FALSE;
    }
 
    if (EndTaskRequest->LastError != ERROR_SUCCESS)
        UserSetLastError(EndTaskRequest->LastError);
 
    return EndTaskRequest->Success;
}

Referenced by ApplicationPage_OnEndTask().

ExitWindowsEx()

BOOL WINAPI ExitWindowsEx	(	UINT	uFlags,
		DWORD	dwReserved
	)

Definition at line 186 of file exit.c.

{
    /*
     * FIXME:
     * 1- Calling the Exit worker must be done under certain conditions.
     *    We may also need to warn the user if there are other people logged
     *    on this computer (see http://pve.proxmox.com/wiki/Windows_2003_guest_best_practices )
     * 2- Call SrvRecordShutdownReason.
     */
 
    return ExitWindowsWorker(uFlags, dwReserved, FALSE);
 
    /* FIXME: Call SrvRecordShutdownReason if we failed */
}

ExitWindowsThread()

static DWORD WINAPI ExitWindowsThread ( LPVOID  Param )

static

Definition at line 71 of file exit.c.

{
    DWORD dwExitCode;
    PEXIT_REACTOS_DATA ExitData = (PEXIT_REACTOS_DATA)Param;
 
    /* Do the exit asynchronously */
    if (ExitWindowsWorker(ExitData->uFlags, ExitData->dwReserved, TRUE))
        dwExitCode = ERROR_SUCCESS;
    else
        dwExitCode = GetLastError();
 
    ExitThread(dwExitCode);
    return ERROR_SUCCESS;
}

Referenced by ExitWindowsWorker().

ExitWindowsWorker()

static BOOL ExitWindowsWorker ( UINT  uFlags, DWORD  dwReserved, BOOL  bCalledFromThread  )

static

Definition at line 87 of file exit.c.

{
    EXIT_REACTOS_DATA ExitData;
    HANDLE hExitThread;
    DWORD ExitCode;
    MSG msg;
 
    USER_API_MESSAGE ApiMessage;
    PUSER_EXIT_REACTOS ExitReactOSRequest = &ApiMessage.Data.ExitReactOSRequest;
 
    /*
     * 1- FIXME: Call NtUserCallOneParam(uFlags, ONEPARAM_ROUTINE_PREPAREFORLOGOFF);
     *    If success we can continue, otherwise we must fail.
     */
 
    /*
     * 2- Send the Exit request to CSRSS (and to Win32k indirectly).
     *    We can shutdown synchronously or asynchronously.
     */
 
    // ExitReactOSRequest->LastError = ERROR_SUCCESS;
    ExitReactOSRequest->Flags = uFlags;
 
    CsrClientCallServer((PCSR_API_MESSAGE)&ApiMessage,
                        NULL,
                        CSR_CREATE_API_NUMBER(USERSRV_SERVERDLL_INDEX, UserpExitWindowsEx),
                        sizeof(*ExitReactOSRequest));
 
    /* Set the last error accordingly */
    if (NT_SUCCESS(ApiMessage.Status) || ApiMessage.Status == STATUS_CANT_WAIT)
    {
        if (ExitReactOSRequest->LastError != ERROR_SUCCESS)
            UserSetLastError(ExitReactOSRequest->LastError);
    }
    else
    {
        UserSetLastNTError(ApiMessage.Status);
        ExitReactOSRequest->Success = FALSE;
    }
 
    /*
     * In case CSR call succeeded and we did a synchronous exit
     * (STATUS_CANT_WAIT is considered as a non-success status),
     * return the real state of the operation now.
     */
    if (NT_SUCCESS(ApiMessage.Status))
        return ExitReactOSRequest->Success;
 
    /*
     * In case something failed: we have a non-success status and:
     * - either we were doing a synchronous exit (Status != STATUS_CANT_WAIT), or
     * - we were doing an asynchronous exit because we were called recursively via
     *   another thread but we failed to exit,
     * then bail out immediately, otherwise we would enter an infinite loop of exit requests.
     *
     * On the contrary if we need to do an asynchronous exit (Status == STATUS_CANT_WAIT
     * and not called recursively via another thread), then continue and do the exit.
     */
    if (ApiMessage.Status != STATUS_CANT_WAIT || bCalledFromThread)
    {
        UserSetLastNTError(ApiMessage.Status);
        return FALSE;
    }
 
    /*
     * 3- Win32k wants us to perform an asynchronous exit. Run the request in a thread.
     * (ApiMessage.Status == STATUS_CANT_WAIT and not already called from a thread)
     */
    ExitData.uFlags     = uFlags;
    ExitData.dwReserved = dwReserved;
    hExitThread = CreateThread(NULL, 0, ExitWindowsThread, &ExitData, 0, NULL);
    if (hExitThread == NULL)
        return FALSE;
 
    /* Pump and discard any input events sent to the app(s) */
    while (MsgWaitForMultipleObjectsEx(1, &hExitThread, INFINITE, QS_ALLINPUT, 0))
    {
        while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
            DispatchMessageW(&msg);
    }
 
    /* Finally, return to caller */
    if (!GetExitCodeThread(hExitThread, &ExitCode))
        ExitCode = GetLastError();
 
    CloseHandle(hExitThread);
 
    if (ExitCode != ERROR_SUCCESS)
        UserSetLastError(ExitCode);
 
    return (ExitCode == ERROR_SUCCESS);
}

Referenced by ExitWindowsEx(), and ExitWindowsThread().