csrsrv.h File Reference

#include "csrmsg.h"

Include dependency graph for csrsrv.h:

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

Go to the source code of this file.

Classes
struct	_CSR_NT_SESSION
struct	_CSR_PROCESS
struct	_CSR_THREAD
struct	_CSR_WAIT_BLOCK
struct	_CSR_SERVER_DLL

Macros
#define	CSR_CSRSS_SECTION_SIZE   65536
#define	CsrGetClientThread()    ((PCSR_THREAD)(NtCurrentTeb()->CsrClientThread))
#define	CsrProcessPriorityFlags
#define	CSR_API(n)
#define	CSR_SERVER_DLL_INIT(n)    NTSTATUS NTAPI n(IN PCSR_SERVER_DLL LoadedServerDll)

Typedefs
typedef struct _CSR_NT_SESSION	CSR_NT_SESSION
typedef struct _CSR_NT_SESSION *	PCSR_NT_SESSION
typedef struct _CSR_PROCESS	CSR_PROCESS
typedef struct _CSR_PROCESS *	PCSR_PROCESS
typedef struct _CSR_THREAD	CSR_THREAD
typedef struct _CSR_THREAD *	PCSR_THREAD
typedef enum _CSR_PROCESS_FLAGS	CSR_PROCESS_FLAGS
typedef enum _CSR_PROCESS_FLAGS *	PCSR_PROCESS_FLAGS
typedef enum _CSR_THREAD_FLAGS	CSR_THREAD_FLAGS
typedef enum _CSR_THREAD_FLAGS *	PCSR_THREAD_FLAGS
typedef enum _SHUTDOWN_RESULT	SHUTDOWN_RESULT
typedef enum _SHUTDOWN_RESULT *	PSHUTDOWN_RESULT
typedef enum _CSR_SHUTDOWN_FLAGS	CSR_SHUTDOWN_FLAGS
typedef enum _CSR_SHUTDOWN_FLAGS *	PCSR_SHUTDOWN_FLAGS
typedef enum _CSR_DEBUG_FLAGS	CSR_PROCESS_DEBUG_FLAGS
typedef enum _CSR_DEBUG_FLAGS *	PCSR_PROCESS_DEBUG_FLAGS
typedef enum _CSR_REPLY_CODE	CSR_REPLY_CODE
typedef enum _CSR_REPLY_CODE *	PCSR_REPLY_CODE
typedef BOOLEAN(NTAPI *	CSR_WAIT_FUNCTION) (IN PLIST_ENTRY WaitList, IN PCSR_THREAD WaitThread, IN PCSR_API_MESSAGE WaitApiMessage, IN PVOID WaitContext, IN PVOID WaitArgument1, IN PVOID WaitArgument2, IN ULONG WaitFlags)
typedef struct _CSR_WAIT_BLOCK	CSR_WAIT_BLOCK
typedef struct _CSR_WAIT_BLOCK *	PCSR_WAIT_BLOCK
typedef NTSTATUS(NTAPI *	PCSR_API_ROUTINE) (IN OUT PCSR_API_MESSAGE ApiMessage, IN OUT PCSR_REPLY_CODE ReplyCode OPTIONAL)
typedef NTSTATUS(NTAPI *	PCSR_CONNECT_CALLBACK) (IN PCSR_PROCESS CsrProcess, IN OUT PVOID ConnectionInfo, IN OUT PULONG ConnectionInfoLength)
typedef VOID(NTAPI *	PCSR_DISCONNECT_CALLBACK) (IN PCSR_PROCESS CsrProcess)
typedef NTSTATUS(NTAPI *	PCSR_NEWPROCESS_CALLBACK) (IN PCSR_PROCESS Parent, IN PCSR_PROCESS CsrProcess)
typedef VOID(NTAPI *	PCSR_HARDERROR_CALLBACK) (IN PCSR_THREAD CsrThread, IN PHARDERROR_MSG HardErrorMessage)
typedef ULONG(NTAPI *	PCSR_SHUTDOWNPROCESS_CALLBACK) (IN PCSR_PROCESS CsrProcess, IN ULONG Flags, IN BOOLEAN FirstPhase)
typedef struct _CSR_SERVER_DLL	CSR_SERVER_DLL
typedef struct _CSR_SERVER_DLL *	PCSR_SERVER_DLL
typedef NTSTATUS(NTAPI *	PCSR_SERVER_DLL_INIT_CALLBACK) (IN PCSR_SERVER_DLL LoadedServerDll)

Enumerations
enum	_CSR_PROCESS_FLAGS {   CsrProcessTerminating = 0x1 , CsrProcessSkipShutdown = 0x2 , CsrProcessNormalPriority = 0x10 , CsrProcessIdlePriority = 0x20 ,   CsrProcessHighPriority = 0x40 , CsrProcessRealtimePriority = 0x80 , CsrProcessCreateNewGroup = 0x100 , CsrProcessTerminated = 0x200 ,   CsrProcessLastThreadTerminated = 0x400 , CsrProcessIsConsoleApp = 0x800 }
enum	_CSR_THREAD_FLAGS { CsrThreadAlertable = 0x1 , CsrThreadInTermination = 0x2 , CsrThreadTerminated = 0x4 , CsrThreadIsServerThread = 0x10 }
enum	_SHUTDOWN_RESULT { CsrShutdownCsrProcess = 1 , CsrShutdownNonCsrProcess , CsrShutdownCancelled }
enum	_CSR_SHUTDOWN_FLAGS { CsrShutdownSystem = 4 , CsrShutdownOther = 8 }
enum	_CSR_DEBUG_FLAGS { CsrDebugOnlyThisProcess = 1 , CsrDebugProcessChildren = 2 }
enum	_CSR_REPLY_CODE { CsrReplyImmediately = 0 , CsrReplyPending = 1 , CsrReplyDeadClient = 2 , CsrReplyAlreadySent = 3 }

Functions
	C_ASSERT (FIELD_OFFSET(CSR_SERVER_DLL, SharedSection)==0x38)
NTSTATUS NTAPI	CsrServerInitialization (IN ULONG ArgumentCount, IN PCHAR Arguments[])
PCSR_THREAD NTAPI	CsrAddStaticServerThread (IN HANDLE hThread, IN PCLIENT_ID ClientId, IN ULONG ThreadFlags)
NTSTATUS NTAPI	CsrCallServerFromServer (IN PCSR_API_MESSAGE ReceiveMsg, IN OUT PCSR_API_MESSAGE ReplyMsg)
PCSR_THREAD NTAPI	CsrConnectToUser (VOID)
NTSTATUS NTAPI	CsrCreateProcess (IN HANDLE hProcess, IN HANDLE hThread, IN PCLIENT_ID ClientId, IN PCSR_NT_SESSION NtSession, IN ULONG Flags, IN PCLIENT_ID DebugCid)
NTSTATUS NTAPI	CsrCreateRemoteThread (IN HANDLE hThread, IN PCLIENT_ID ClientId)
NTSTATUS NTAPI	CsrCreateThread (IN PCSR_PROCESS CsrProcess, IN HANDLE hThread, IN PCLIENT_ID ClientId, IN BOOLEAN HaveClient)
BOOLEAN NTAPI	CsrCreateWait (IN PLIST_ENTRY WaitList, IN CSR_WAIT_FUNCTION WaitFunction, IN PCSR_THREAD CsrWaitThread, IN OUT PCSR_API_MESSAGE WaitApiMessage, IN PVOID WaitContext)
NTSTATUS NTAPI	CsrDebugProcess (IN PCSR_PROCESS CsrProcess)
NTSTATUS NTAPI	CsrDebugProcessStop (IN PCSR_PROCESS CsrProcess)
VOID NTAPI	CsrDereferenceProcess (IN PCSR_PROCESS CsrProcess)
VOID NTAPI	CsrDereferenceThread (IN PCSR_THREAD CsrThread)
VOID NTAPI	CsrDereferenceWait (IN PLIST_ENTRY WaitList)
NTSTATUS NTAPI	CsrDestroyProcess (IN PCLIENT_ID Cid, IN NTSTATUS ExitStatus)
NTSTATUS NTAPI	CsrDestroyThread (IN PCLIENT_ID Cid)
NTSTATUS NTAPI	CsrExecServerThread (IN PVOID ThreadHandler, IN ULONG Flags)
NTSTATUS NTAPI	CsrGetProcessLuid (IN HANDLE hProcess OPTIONAL, OUT PLUID Luid)
BOOLEAN NTAPI	CsrImpersonateClient (IN PCSR_THREAD CsrThread)
NTSTATUS NTAPI	CsrLockProcessByClientId (IN HANDLE Pid, OUT PCSR_PROCESS *CsrProcess OPTIONAL)
NTSTATUS NTAPI	CsrLockThreadByClientId (IN HANDLE Tid, OUT PCSR_THREAD *CsrThread)
VOID NTAPI	CsrMoveSatisfiedWait (IN PLIST_ENTRY DestinationList, IN PLIST_ENTRY WaitList)
BOOLEAN NTAPI	CsrNotifyWait (IN PLIST_ENTRY WaitList, IN BOOLEAN NotifyAll, IN PVOID WaitArgument1, IN PVOID WaitArgument2)
VOID NTAPI	CsrPopulateDosDevices (VOID)
HANDLE NTAPI	CsrQueryApiPort (VOID)
VOID NTAPI	CsrReferenceThread (IN PCSR_THREAD CsrThread)
BOOLEAN NTAPI	CsrRevertToSelf (VOID)
VOID NTAPI	CsrSetBackgroundPriority (IN PCSR_PROCESS CsrProcess)
VOID NTAPI	CsrSetCallingSpooler (ULONG Reserved)
VOID NTAPI	CsrSetForegroundPriority (IN PCSR_PROCESS CsrProcess)
NTSTATUS NTAPI	CsrShutdownProcesses (IN PLUID CallerLuid, IN ULONG Flags)
EXCEPTION_DISPOSITION NTAPI	CsrUnhandledExceptionFilter (IN PEXCEPTION_POINTERS ExceptionInfo)
NTSTATUS NTAPI	CsrUnlockProcess (IN PCSR_PROCESS CsrProcess)
NTSTATUS NTAPI	CsrUnlockThread (IN PCSR_THREAD CsrThread)
BOOLEAN NTAPI	CsrValidateMessageBuffer (IN PCSR_API_MESSAGE ApiMessage, IN PVOID *Buffer, IN ULONG ElementCount, IN ULONG ElementSize)
BOOLEAN NTAPI	CsrValidateMessageString (IN PCSR_API_MESSAGE ApiMessage, IN PWSTR *MessageString)

Macro Definition Documentation

CSR_API

#define CSR_API

(

n

)

Value:

    NTSTATUS NTAPI n(IN OUT PCSR_API_MESSAGE ApiMessage,    \
                     IN OUT PCSR_REPLY_CODE  ReplyCode OPTIONAL)

Definition at line 176 of file csrsrv.h.

CSR_CSRSS_SECTION_SIZE

#define CSR_CSRSS_SECTION_SIZE   65536

Definition at line 27 of file csrsrv.h.

CSR_SERVER_DLL_INIT

#define CSR_SERVER_DLL_INIT

(

n

)

NTSTATUS NTAPI n(IN PCSR_SERVER_DLL LoadedServerDll)

Definition at line 255 of file csrsrv.h.

CsrGetClientThread

#define CsrGetClientThread

(

)

((PCSR_THREAD)(NtCurrentTeb()->CsrClientThread))

Definition at line 77 of file csrsrv.h.

CsrProcessPriorityFlags

#define CsrProcessPriorityFlags

Value:

                                 (CsrProcessNormalPriority | \
                                 CsrProcessIdlePriority   | \
                                 CsrProcessHighPriority   | \
                                 CsrProcessRealtimePriority)

Definition at line 97 of file csrsrv.h.

Typedef Documentation

CSR_NT_SESSION

typedef struct _CSR_NT_SESSION CSR_NT_SESSION

CSR_PROCESS

typedef struct _CSR_PROCESS CSR_PROCESS

CSR_PROCESS_DEBUG_FLAGS

typedef enum _CSR_DEBUG_FLAGS CSR_PROCESS_DEBUG_FLAGS

CSR_PROCESS_FLAGS

typedef enum _CSR_PROCESS_FLAGS CSR_PROCESS_FLAGS

CSR_REPLY_CODE

typedef enum _CSR_REPLY_CODE CSR_REPLY_CODE

CSR_SERVER_DLL

typedef struct _CSR_SERVER_DLL CSR_SERVER_DLL

CSR_SHUTDOWN_FLAGS

typedef enum _CSR_SHUTDOWN_FLAGS CSR_SHUTDOWN_FLAGS

CSR_THREAD

typedef struct _CSR_THREAD CSR_THREAD

CSR_THREAD_FLAGS

typedef enum _CSR_THREAD_FLAGS CSR_THREAD_FLAGS

CSR_WAIT_BLOCK

typedef struct _CSR_WAIT_BLOCK CSR_WAIT_BLOCK

CSR_WAIT_FUNCTION

typedef BOOLEAN(NTAPI * CSR_WAIT_FUNCTION) (IN PLIST_ENTRY WaitList, IN PCSR_THREAD WaitThread, IN PCSR_API_MESSAGE WaitApiMessage, IN PVOID WaitContext, IN PVOID WaitArgument1, IN PVOID WaitArgument2, IN ULONG WaitFlags)

Definition at line 144 of file csrsrv.h.

PCSR_API_ROUTINE

typedef NTSTATUS(NTAPI * PCSR_API_ROUTINE) (IN OUT PCSR_API_MESSAGE ApiMessage, IN OUT PCSR_REPLY_CODE ReplyCode OPTIONAL)

Definition at line 170 of file csrsrv.h.

PCSR_CONNECT_CALLBACK

typedef NTSTATUS(NTAPI * PCSR_CONNECT_CALLBACK) (IN PCSR_PROCESS CsrProcess, IN OUT PVOID ConnectionInfo, IN OUT PULONG ConnectionInfoLength)

Definition at line 181 of file csrsrv.h.

PCSR_DISCONNECT_CALLBACK

typedef VOID(NTAPI * PCSR_DISCONNECT_CALLBACK) (IN PCSR_PROCESS CsrProcess)

Definition at line 189 of file csrsrv.h.

PCSR_HARDERROR_CALLBACK

typedef VOID(NTAPI * PCSR_HARDERROR_CALLBACK) (IN PCSR_THREAD CsrThread, IN PHARDERROR_MSG HardErrorMessage)

Definition at line 200 of file csrsrv.h.

PCSR_NEWPROCESS_CALLBACK

typedef NTSTATUS(NTAPI * PCSR_NEWPROCESS_CALLBACK) (IN PCSR_PROCESS Parent, IN PCSR_PROCESS CsrProcess)

Definition at line 193 of file csrsrv.h.

PCSR_NT_SESSION

typedef struct _CSR_NT_SESSION * PCSR_NT_SESSION

PCSR_PROCESS

typedef struct _CSR_PROCESS * PCSR_PROCESS

PCSR_PROCESS_DEBUG_FLAGS

typedef enum _CSR_DEBUG_FLAGS * PCSR_PROCESS_DEBUG_FLAGS

PCSR_PROCESS_FLAGS

typedef enum _CSR_PROCESS_FLAGS * PCSR_PROCESS_FLAGS

PCSR_REPLY_CODE

typedef enum _CSR_REPLY_CODE * PCSR_REPLY_CODE

PCSR_SERVER_DLL

typedef struct _CSR_SERVER_DLL * PCSR_SERVER_DLL

PCSR_SERVER_DLL_INIT_CALLBACK

typedef NTSTATUS(NTAPI * PCSR_SERVER_DLL_INIT_CALLBACK) (IN PCSR_SERVER_DLL LoadedServerDll)

Definition at line 252 of file csrsrv.h.

PCSR_SHUTDOWN_FLAGS

typedef enum _CSR_SHUTDOWN_FLAGS * PCSR_SHUTDOWN_FLAGS

PCSR_SHUTDOWNPROCESS_CALLBACK

typedef ULONG(NTAPI * PCSR_SHUTDOWNPROCESS_CALLBACK) (IN PCSR_PROCESS CsrProcess, IN ULONG Flags, IN BOOLEAN FirstPhase)

Definition at line 207 of file csrsrv.h.

PCSR_THREAD

typedef struct _CSR_THREAD * PCSR_THREAD

PCSR_THREAD_FLAGS

typedef enum _CSR_THREAD_FLAGS * PCSR_THREAD_FLAGS

PCSR_WAIT_BLOCK

typedef struct _CSR_WAIT_BLOCK * PCSR_WAIT_BLOCK

PSHUTDOWN_RESULT

typedef enum _SHUTDOWN_RESULT * PSHUTDOWN_RESULT

SHUTDOWN_RESULT

typedef enum _SHUTDOWN_RESULT SHUTDOWN_RESULT

Enumeration Type Documentation

_CSR_DEBUG_FLAGS

enum _CSR_DEBUG_FLAGS

Enumerator
CsrDebugOnlyThisProcess
CsrDebugProcessChildren

Definition at line 123 of file csrsrv.h.

{
    CsrDebugOnlyThisProcess = 1,
    CsrDebugProcessChildren = 2
} CSR_PROCESS_DEBUG_FLAGS, *PCSR_PROCESS_DEBUG_FLAGS;

_CSR_PROCESS_FLAGS

enum _CSR_PROCESS_FLAGS

Enumerator
CsrProcessTerminating
CsrProcessSkipShutdown
CsrProcessNormalPriority
CsrProcessIdlePriority
CsrProcessHighPriority
CsrProcessRealtimePriority
CsrProcessCreateNewGroup
CsrProcessTerminated
CsrProcessLastThreadTerminated
CsrProcessIsConsoleApp

Definition at line 83 of file csrsrv.h.

{
    CsrProcessTerminating          = 0x1,
    CsrProcessSkipShutdown         = 0x2,
    CsrProcessNormalPriority       = 0x10,
    CsrProcessIdlePriority         = 0x20,
    CsrProcessHighPriority         = 0x40,
    CsrProcessRealtimePriority     = 0x80,
    CsrProcessCreateNewGroup       = 0x100,
    CsrProcessTerminated           = 0x200,
    CsrProcessLastThreadTerminated = 0x400,
    CsrProcessIsConsoleApp         = 0x800
} CSR_PROCESS_FLAGS, *PCSR_PROCESS_FLAGS;

_CSR_REPLY_CODE

enum _CSR_REPLY_CODE

Enumerator
CsrReplyImmediately
CsrReplyPending
CsrReplyDeadClient
CsrReplyAlreadySent

Definition at line 129 of file csrsrv.h.

{
    CsrReplyImmediately = 0,
    CsrReplyPending     = 1,
    CsrReplyDeadClient  = 2,
    CsrReplyAlreadySent = 3
} CSR_REPLY_CODE, *PCSR_REPLY_CODE;

_CSR_SHUTDOWN_FLAGS

enum _CSR_SHUTDOWN_FLAGS

Enumerator
CsrShutdownSystem
CsrShutdownOther

Definition at line 117 of file csrsrv.h.

{
    CsrShutdownSystem = 4,
    CsrShutdownOther  = 8
} CSR_SHUTDOWN_FLAGS, *PCSR_SHUTDOWN_FLAGS;

_CSR_THREAD_FLAGS

enum _CSR_THREAD_FLAGS

Enumerator
CsrThreadAlertable
CsrThreadInTermination
CsrThreadTerminated
CsrThreadIsServerThread

Definition at line 102 of file csrsrv.h.

{
    CsrThreadAlertable      = 0x1,
    CsrThreadInTermination  = 0x2,
    CsrThreadTerminated     = 0x4,
    CsrThreadIsServerThread = 0x10
} CSR_THREAD_FLAGS, *PCSR_THREAD_FLAGS;

_SHUTDOWN_RESULT

enum _SHUTDOWN_RESULT

Enumerator
CsrShutdownCsrProcess
CsrShutdownNonCsrProcess
CsrShutdownCancelled

Definition at line 110 of file csrsrv.h.

{
    CsrShutdownCsrProcess = 1,
    CsrShutdownNonCsrProcess,
    CsrShutdownCancelled
} SHUTDOWN_RESULT, *PSHUTDOWN_RESULT;

Function Documentation

C_ASSERT()

C_ASSERT

(

FIELD_OFFSET(CSR_SERVER_DLL, SharedSection)

= =0x38

)

CsrAddStaticServerThread()

PCSR_THREAD NTAPI CsrAddStaticServerThread	(	IN HANDLE	hThread,
		IN PCLIENT_ID	ClientId,
		IN ULONG	ThreadFlags
	)

Definition at line 512 of file thredsup.c.

{
    PCSR_THREAD CsrThread;
 
    /* Get the Lock */
    CsrAcquireProcessLock();
 
    /* Allocate the Server Thread */
    CsrThread = CsrAllocateThread(CsrRootProcess);
    if (CsrThread)
    {
        /* Setup the Object */
        CsrThread->ThreadHandle = hThread;
        ProtectHandle(hThread);
        CsrThread->ClientId = *ClientId;
        CsrThread->Flags = ThreadFlags;
 
        /* Insert it into the Thread List */
        InsertTailList(&CsrRootProcess->ThreadList, &CsrThread->Link);
 
        /* Increment the thread count */
        CsrRootProcess->ThreadCount++;
    }
    else
    {
        DPRINT1("CsrAddStaticServerThread: alloc failed for thread 0x%x\n", hThread);
    }
 
    /* Release the Process Lock and return */
    CsrReleaseProcessLock();
    return CsrThread;
}

Referenced by CsrApiPortInitialize(), CsrpCheckRequestThreads(), CsrSbApiPortInitialize(), and GuiInit().

CsrCallServerFromServer()

NTSTATUS NTAPI CsrCallServerFromServer	(	IN PCSR_API_MESSAGE	ReceiveMsg,
		IN OUT PCSR_API_MESSAGE	ReplyMsg
	)

Definition at line 51 of file api.c.

{
    ULONG ServerId;
    PCSR_SERVER_DLL ServerDll = NULL;
    ULONG ApiId;
    CSR_REPLY_CODE ReplyCode = CsrReplyImmediately;
 
    /* Get the Server ID */
    ServerId = CSR_API_NUMBER_TO_SERVER_ID(ReceiveMsg->ApiNumber);
 
    /* Make sure that the ID is within limits, and the Server DLL loaded */
    if ((ServerId >= CSR_SERVER_DLL_MAX) ||
        (!(ServerDll = CsrLoadedServerDll[ServerId])))
    {
        /* We are beyond the Maximum Server ID */
#ifdef CSR_DBG
        DPRINT1("CSRSS: %lx is invalid ServerDllIndex (%08x)\n",
                ServerId, ServerDll);
        if (NtCurrentPeb()->BeingDebugged) DbgBreakPoint();
#endif
        ReplyMsg->Status = STATUS_ILLEGAL_FUNCTION;
        return STATUS_ILLEGAL_FUNCTION;
    }
    else
    {
        /* Get the API ID, normalized with our Base ID */
        ApiId = CSR_API_NUMBER_TO_API_ID(ReceiveMsg->ApiNumber) - ServerDll->ApiBase;
 
        /* Make sure that the ID is within limits, and the entry exists */
        if ((ApiId >= ServerDll->HighestApiSupported) ||
            ((ServerDll->ValidTable) && !(ServerDll->ValidTable[ApiId])))
        {
            /* We are beyond the Maximum API ID, or it doesn't exist */
#ifdef CSR_DBG
            DPRINT1("API: %d\n", ApiId);
            DPRINT1("CSRSS: %lx (%s) is invalid ApiTableIndex for %Z or is an "
                    "invalid API to call from the server.\n",
                    ApiId,
                    ((ServerDll->NameTable) && (ServerDll->NameTable[ApiId])) ?
                    ServerDll->NameTable[ApiId] : "*** UNKNOWN ***",
                    &ServerDll->Name);
            if (NtCurrentPeb()->BeingDebugged) DbgBreakPoint();
#endif
            ReplyMsg->Status = STATUS_ILLEGAL_FUNCTION;
            return STATUS_ILLEGAL_FUNCTION;
        }
    }
 
#ifdef CSR_DBG
    if (CsrDebug & 2)
    {
        DPRINT1("CSRSS: %s Api Request received from server process\n",
                ServerDll->NameTable[ApiId]);
    }
#endif
 
    /* Validation complete, start SEH */
    _SEH2_TRY
    {
        /* Call the API, get the reply code and return the result */
        ReplyMsg->Status = ServerDll->DispatchTable[ApiId](ReceiveMsg, &ReplyCode);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        /* If we got an exception, return access violation */
        ReplyMsg->Status = STATUS_ACCESS_VIOLATION;
    }
    _SEH2_END;
 
    /* Return success */
    return STATUS_SUCCESS;
}

CsrConnectToUser()

PCSR_THREAD NTAPI CsrConnectToUser

(

VOID

)

Definition at line 1021 of file api.c.

{
    NTSTATUS Status;
    ANSI_STRING DllName;
    UNICODE_STRING TempName;
    HANDLE hUser32;
    STRING StartupName;
    PTEB Teb = NtCurrentTeb();
    PCSR_THREAD CsrThread;
    BOOLEAN Connected;
 
    /* Check if we didn't already find it */
    if (!CsrClientThreadSetup)
    {
        /* Get the DLL Handle for user32.dll */
        RtlInitAnsiString(&DllName, "user32");
        RtlAnsiStringToUnicodeString(&TempName, &DllName, TRUE);
        Status = LdrGetDllHandle(NULL,
                                 NULL,
                                 &TempName,
                                 &hUser32);
        RtlFreeUnicodeString(&TempName);
 
        /* If we got the handle, get the Client Thread Startup Entrypoint */
        if (NT_SUCCESS(Status))
        {
            RtlInitAnsiString(&StartupName,"ClientThreadSetup");
            Status = LdrGetProcedureAddress(hUser32,
                                            &StartupName,
                                            0,
                                            (PVOID)&CsrClientThreadSetup);
        }
    }
 
    /* Connect to user32 */
    _SEH2_TRY
    {
        Connected = CsrClientThreadSetup();
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        Connected = FALSE;
    }
    _SEH2_END;
 
    if (!Connected)
    {
        DPRINT1("CSRSS: CsrConnectToUser failed\n");
        return NULL;
    }
 
    /* Save pointer to this thread in TEB */
    CsrAcquireProcessLock();
    CsrThread = CsrLocateThreadInProcess(NULL, &Teb->ClientId);
    CsrReleaseProcessLock();
    if (CsrThread) Teb->CsrClientThread = CsrThread;
 
    /* Return it */
    return CsrThread;
}

Referenced by CsrApiRequestThread(), and GuiConsoleInputThread().

CsrCreateProcess()

NTSTATUS NTAPI CsrCreateProcess	(	IN HANDLE	hProcess,
		IN HANDLE	hThread,
		IN PCLIENT_ID	ClientId,
		IN PCSR_NT_SESSION	NtSession,
		IN ULONG	Flags,
		IN PCLIENT_ID	DebugCid
	)

Definition at line 422 of file procsup.c.

{
    PCSR_THREAD CurrentThread = CsrGetClientThread();
    CLIENT_ID CurrentCid;
    PCSR_PROCESS CurrentProcess;
    PCSR_SERVER_DLL ServerDll;
    PVOID ProcessData;
    ULONG i;
    PCSR_PROCESS CsrProcess;
    NTSTATUS Status;
    PCSR_THREAD CsrThread;
    KERNEL_USER_TIMES KernelTimes;
 
    /* Get the current CID and lock Processes */
    CurrentCid = CurrentThread->ClientId;
    CsrAcquireProcessLock();
 
    /* Get the current CSR Thread */
    CurrentThread = CsrLocateThreadByClientId(&CurrentProcess, &CurrentCid);
    if (!CurrentThread)
    {
        /* We've failed to locate the thread */
        CsrReleaseProcessLock();
        return STATUS_THREAD_IS_TERMINATING;
    }
 
    /* Allocate a new Process Object */
    CsrProcess = CsrAllocateProcess();
    if (!CsrProcess)
    {
        /* Couldn't allocate Process */
        CsrReleaseProcessLock();
        return STATUS_NO_MEMORY;
    }
 
    /* Inherit the Process Data */
    CurrentProcess = CurrentThread->Process;
    ProcessData = &CsrProcess->ServerData[CSR_SERVER_DLL_MAX];
    for (i = 0; i < CSR_SERVER_DLL_MAX; i++)
    {
        /* Get the current Server */
        ServerDll = CsrLoadedServerDll[i];
 
        /* Check if the DLL is Loaded and has Per Process Data */
        if (ServerDll && ServerDll->SizeOfProcessData)
        {
            /* Set the pointer */
            CsrProcess->ServerData[i] = ProcessData;
 
            /* Copy the Data */
            RtlMoveMemory(ProcessData,
                          CurrentProcess->ServerData[i],
                          ServerDll->SizeOfProcessData);
 
            /* Update next data pointer */
            ProcessData = (PVOID)((ULONG_PTR)ProcessData +
                                  ServerDll->SizeOfProcessData);
        }
        else
        {
            /* No data for this Server */
            CsrProcess->ServerData[i] = NULL;
        }
    }
 
    /* Set the Exception Port for us */
    Status = NtSetInformationProcess(hProcess,
                                     ProcessExceptionPort,
                                     &CsrApiPort,
                                     sizeof(CsrApiPort));
    if (!NT_SUCCESS(Status))
    {
        /* Failed */
        CsrDeallocateProcess(CsrProcess);
        CsrReleaseProcessLock();
        return STATUS_NO_MEMORY;
    }
 
    /* Check if CreateProcess got CREATE_NEW_PROCESS_GROUP */
    if (Flags & CsrProcessCreateNewGroup)
    {
        /*
         * We create the process group leader of a new process group, therefore
         * its process group ID and sequence number are its own ones.
         */
        CsrProcess->ProcessGroupId = HandleToUlong(ClientId->UniqueProcess);
        CsrProcess->ProcessGroupSequence = CsrProcess->SequenceNumber;
    }
    else
    {
        /* Inherit the process group ID and sequence number from the current process */
        CsrProcess->ProcessGroupId = CurrentProcess->ProcessGroupId;
        CsrProcess->ProcessGroupSequence = CurrentProcess->ProcessGroupSequence;
    }
 
    /* Check if this is a console process */
    if (Flags & CsrProcessIsConsoleApp) CsrProcess->Flags |= CsrProcessIsConsoleApp;
 
    /* Mask out non-debug flags */
    Flags &= ~(CsrProcessIsConsoleApp | CsrProcessCreateNewGroup | CsrProcessPriorityFlags);
 
    /* Check if every process will be debugged */
    if (!(Flags) && (CurrentProcess->DebugFlags & CsrDebugProcessChildren))
    {
        /* Pass it on to the current process */
        CsrProcess->DebugFlags = CsrDebugProcessChildren;
        CsrProcess->DebugCid = CurrentProcess->DebugCid;
    }
 
    /* Check if Debugging was used on this process */
    if ((Flags & (CsrDebugOnlyThisProcess | CsrDebugProcessChildren)) && (DebugCid))
    {
        /* Save the debug flag used */
        CsrProcess->DebugFlags = Flags;
 
        /* Save the CID */
        CsrProcess->DebugCid = *DebugCid;
    }
 
    /* Check if Debugging is enabled */
    if (CsrProcess->DebugFlags)
    {
        /* Set the Debug Port for us */
        Status = NtSetInformationProcess(hProcess,
                                         ProcessDebugPort,
                                         &CsrApiPort,
                                         sizeof(CsrApiPort));
        ASSERT(NT_SUCCESS(Status));
        if (!NT_SUCCESS(Status))
        {
            /* Failed */
            CsrDeallocateProcess(CsrProcess);
            CsrReleaseProcessLock();
            return STATUS_NO_MEMORY;
        }
    }
 
    /* Get the Thread Create Time */
    Status = NtQueryInformationThread(hThread,
                                      ThreadTimes,
                                      &KernelTimes,
                                      sizeof(KernelTimes),
                                      NULL);
    if (!NT_SUCCESS(Status))
    {
        /* Failed */
        CsrDeallocateProcess(CsrProcess);
        CsrReleaseProcessLock();
        return STATUS_NO_MEMORY;
    }
 
    /* Allocate a CSR Thread Structure */
    CsrThread = CsrAllocateThread(CsrProcess);
    if (!CsrThread)
    {
        /* Failed */
        CsrDeallocateProcess(CsrProcess);
        CsrReleaseProcessLock();
        return STATUS_NO_MEMORY;
    }
 
    /* Save the data we have */
    CsrThread->CreateTime = KernelTimes.CreateTime;
    CsrThread->ClientId = *ClientId;
    CsrThread->ThreadHandle = hThread;
    ProtectHandle(hThread);
    CsrThread->Flags = 0;
 
    /* Insert the Thread into the Process */
    Status = CsrInsertThread(CsrProcess, CsrThread);
    if (!NT_SUCCESS(Status))
    {
        /* Bail out */
        CsrDeallocateProcess(CsrProcess);
        CsrDeallocateThread(CsrThread);
        CsrReleaseProcessLock();
        return Status;
    }
 
    /* Reference the session */
    CsrReferenceNtSession(NtSession);
    CsrProcess->NtSession = NtSession;
 
    /* Setup Process Data */
    CsrProcess->ClientId = *ClientId;
    CsrProcess->ProcessHandle = hProcess;
    CsrProcess->ShutdownLevel = 0x280;
 
    /* Set the priority to Background */
    CsrSetBackgroundPriority(CsrProcess);
 
    /* Insert the Process */
    CsrInsertProcess(CurrentProcess, CsrProcess);
 
    /* Release lock and return */
    CsrReleaseProcessLock();
    return Status;
}

Referenced by CSR_API().

CsrCreateRemoteThread()

NTSTATUS NTAPI CsrCreateRemoteThread	(	IN HANDLE	hThread,
		IN PCLIENT_ID	ClientId
	)

Definition at line 569 of file thredsup.c.

{
    NTSTATUS Status;
    HANDLE ThreadHandle;
    PCSR_THREAD CsrThread;
    PCSR_PROCESS CsrProcess;
    KERNEL_USER_TIMES KernelTimes;
 
    /* Get the Thread Create Time */
    Status = NtQueryInformationThread(hThread,
                                      ThreadTimes,
                                      &KernelTimes,
                                      sizeof(KernelTimes),
                                      NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to query thread times: %lx\n", Status);
        return Status;
    }
 
    /* Lock the Owner Process */
    Status = CsrLockProcessByClientId(ClientId->UniqueProcess, &CsrProcess);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("No known process for %lx\n", ClientId->UniqueProcess);
        return Status;
    }
 
    /* Make sure the thread didn't terminate */
    if (KernelTimes.ExitTime.QuadPart)
    {
        /* Unlock the process and return */
        CsrUnlockProcess(CsrProcess);
        DPRINT1("Dead thread: %I64x\n", KernelTimes.ExitTime.QuadPart);
        return STATUS_THREAD_IS_TERMINATING;
    }
 
    /* Allocate a CSR Thread Structure */
    CsrThread = CsrAllocateThread(CsrProcess);
    if (!CsrThread)
    {
        DPRINT1("CSRSRV: %s: out of memory!\n", __FUNCTION__);
        CsrUnlockProcess(CsrProcess);
        return STATUS_NO_MEMORY;
    }
 
    /* Duplicate the Thread Handle */
    Status = NtDuplicateObject(NtCurrentProcess(),
                               hThread,
                               NtCurrentProcess(),
                               &ThreadHandle,
                               0,
                               0,
                               DUPLICATE_SAME_ACCESS);
    /* Allow failure */
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Thread duplication failed: %lx\n", Status);
        ThreadHandle = hThread;
    }
 
    /* Save the data we have */
    CsrThread->CreateTime = KernelTimes.CreateTime;
    CsrThread->ClientId = *ClientId;
    CsrThread->ThreadHandle = ThreadHandle;
    ProtectHandle(ThreadHandle);
    CsrThread->Flags = 0;
 
    /* Insert the Thread into the Process */
    Status = CsrInsertThread(CsrProcess, CsrThread);
    if (!NT_SUCCESS(Status))
    {
        /* Bail out */
        if (CsrThread->ThreadHandle != hThread) NtClose(CsrThread->ThreadHandle);
        CsrUnlockProcess(CsrProcess);
        CsrDeallocateThread(CsrThread);
        return Status;
    }
 
    /* Release the lock and return */
    CsrUnlockProcess(CsrProcess);
    return STATUS_SUCCESS;
}

Referenced by CreateRemoteThread().

CsrCreateThread()

NTSTATUS NTAPI CsrCreateThread	(	IN PCSR_PROCESS	CsrProcess,
		IN HANDLE	hThread,
		IN PCLIENT_ID	ClientId,
		IN BOOLEAN	HaveClient
	)

Definition at line 678 of file thredsup.c.

{
    NTSTATUS Status;
    PCSR_THREAD CsrThread, CurrentThread;
    PCSR_PROCESS CurrentProcess;
    CLIENT_ID CurrentCid;
    KERNEL_USER_TIMES KernelTimes;
 
    if (HaveClient)
    {
        /* Get the current thread and CID */
        CurrentThread = CsrGetClientThread();
        CurrentCid = CurrentThread->ClientId;
 
        /* Acquire the Process Lock */
        CsrAcquireProcessLock();
 
        /* Get the current Process and make sure the Thread is valid with this CID */
        CurrentThread = CsrLocateThreadByClientId(&CurrentProcess, &CurrentCid);
 
        /* Something is wrong if we get an empty thread back */
        if (!CurrentThread)
        {
            DPRINT1("CSRSRV: %s: invalid thread!\n", __FUNCTION__);
            CsrReleaseProcessLock();
            return STATUS_THREAD_IS_TERMINATING;
        }
    }
    else
    {
        /* Acquire the Process Lock */
        CsrAcquireProcessLock();
    }
 
    /* Get the Thread Create Time */
    Status = NtQueryInformationThread(hThread,
                                      ThreadTimes,
                                      &KernelTimes,
                                      sizeof(KernelTimes),
                                      NULL);
    if (!NT_SUCCESS(Status))
    {
        CsrReleaseProcessLock();
        return Status;
    }
 
    /* Allocate a CSR Thread Structure */
    CsrThread = CsrAllocateThread(CsrProcess);
    if (!CsrThread)
    {
        DPRINT1("CSRSRV: %s: out of memory!\n", __FUNCTION__);
        CsrReleaseProcessLock();
        return STATUS_NO_MEMORY;
    }
 
    /* Save the data we have */
    CsrThread->CreateTime = KernelTimes.CreateTime;
    CsrThread->ClientId = *ClientId;
    CsrThread->ThreadHandle = hThread;
    ProtectHandle(hThread);
    CsrThread->Flags = 0;
 
    /* Insert the Thread into the Process */
    Status = CsrInsertThread(CsrProcess, CsrThread);
    if (!NT_SUCCESS(Status))
    {
        /* Bail out */
        CsrUnlockProcess(CsrProcess);
        CsrDeallocateThread(CsrThread);
        return Status;
    }
 
    /* Release the lock and return */
    CsrReleaseProcessLock();
 
    return STATUS_SUCCESS;
}

Referenced by CSR_API().

CsrCreateWait()

BOOLEAN NTAPI CsrCreateWait	(	IN PLIST_ENTRY	WaitList,
		IN CSR_WAIT_FUNCTION	WaitFunction,
		IN PCSR_THREAD	CsrWaitThread,
		IN OUT PCSR_API_MESSAGE	WaitApiMessage,
		IN PVOID	WaitContext
	)

Definition at line 209 of file wait.c.

{
    PCSR_WAIT_BLOCK WaitBlock;
 
    /* Initialize the wait */
    if (!CsrInitializeWait(WaitFunction,
                           CsrWaitThread,
                           WaitApiMessage,
                           WaitContext,
                           &WaitBlock))
    {
        return FALSE;
    }
 
    /* Acquire the Wait Lock */
    CsrAcquireWaitLock();
 
    /* Make sure the thread wasn't destroyed */
    if (CsrWaitThread->Flags & CsrThreadTerminated)
    {
        /* Fail the wait */
        RtlFreeHeap(CsrHeap, 0, WaitBlock);
        CsrReleaseWaitLock();
        return FALSE;
    }
 
    /* Associate the newly created wait to the waiting thread */
    CsrWaitThread->WaitBlock = WaitBlock;
 
    /* Insert the wait in the queue */
    InsertTailList(WaitList, &WaitBlock->WaitList);
 
    /* Return */
    CsrReleaseWaitLock();
    return TRUE;
}

Referenced by DoWriteConsole(), and WaitBeforeReading().

CsrDebugProcess()

NTSTATUS NTAPI CsrDebugProcess

(

IN PCSR_PROCESS

CsrProcess

)

Definition at line 643 of file procsup.c.

{
    /* CSR does not handle debugging anymore */
    DPRINT("CSRSRV: %s(0x%p) called\n", __FUNCTION__, CsrProcess);
    return STATUS_UNSUCCESSFUL;
}

CsrDebugProcessStop()

NTSTATUS NTAPI CsrDebugProcessStop

(

IN PCSR_PROCESS

CsrProcess

)

Definition at line 667 of file procsup.c.

{
    /* CSR does not handle debugging anymore */
    DPRINT("CSRSRV: %s(0x%p) called\n", __FUNCTION__, CsrProcess);
    return STATUS_UNSUCCESSFUL;
}

CsrDereferenceProcess()

VOID NTAPI CsrDereferenceProcess

(

IN PCSR_PROCESS

CsrProcess

)

Definition at line 691 of file procsup.c.

{
    LONG LockCount;
 
    /* Acquire process lock */
    CsrAcquireProcessLock();
 
    /* Decrease reference count */
    LockCount = --CsrProcess->ReferenceCount;
    ASSERT(LockCount >= 0);
    if (LockCount == 0)
    {
        /* Call the generic cleanup code */
        CsrProcessRefcountZero(CsrProcess);
    }
    else
    {
        /* Just release the lock */
        CsrReleaseProcessLock();
    }
}

Referenced by ConsoleClientShutdown(), CsrThreadRefcountZero(), NonConsoleProcessShutdown(), and UserClientShutdown().

CsrDereferenceThread()

VOID NTAPI CsrDereferenceThread

(

IN PCSR_THREAD

CsrThread

)

Definition at line 776 of file thredsup.c.

{
    /* Acquire process lock */
    CsrAcquireProcessLock();
 
    /* Decrease reference count */
    ASSERT(CsrThread->ReferenceCount > 0);
    if ((--CsrThread->ReferenceCount) == 0)
    {
        /* Call the generic cleanup code */
        CsrThreadRefcountZero(CsrThread);
    }
    else
    {
        /* Just release the lock */
        CsrReleaseProcessLock();
    }
}

Referenced by CsrApiRequestThread(), CsrDereferenceWait(), CsrNotifyWaitBlock(), GuiConsoleInputThread(), and NotifyUserProcessForShutdown().

CsrDereferenceWait()

VOID NTAPI CsrDereferenceWait

(

IN PLIST_ENTRY

WaitList

)

Definition at line 266 of file wait.c.

{
    PLIST_ENTRY NextEntry;
    PCSR_WAIT_BLOCK WaitBlock;
 
    /* Acquire the Process and Wait Locks */
    CsrAcquireProcessLock();
    CsrAcquireWaitLock();
 
    /* Set the list pointers */
    NextEntry = WaitList->Flink;
 
    /* Start the loop */
    while (NextEntry != WaitList)
    {
        /* Get the wait block */
        WaitBlock = CONTAINING_RECORD(NextEntry, CSR_WAIT_BLOCK, WaitList);
 
        /* Move to the next entry */
        NextEntry = NextEntry->Flink;
 
        /* Check if there's no Wait Routine (satisfied wait) */
        if (WaitBlock->WaitFunction == NULL)
        {
            /* Remove it from the Wait List */
            if (WaitBlock->WaitList.Flink)
            {
                RemoveEntryList(&WaitBlock->WaitList);
            }
 
            /* Dereference the thread waiting on it */
            CsrDereferenceThread(WaitBlock->WaitThread);
 
            /* Free the block */
            RtlFreeHeap(CsrHeap, 0, WaitBlock);
        }
    }
 
    /* Release the locks */
    CsrReleaseWaitLock();
    CsrReleaseProcessLock();
}

Referenced by ConioUnpause(), ConSrvCloseHandle(), and PostprocessInput().

CsrDestroyProcess()

NTSTATUS NTAPI CsrDestroyProcess	(	IN PCLIENT_ID	Cid,
		IN NTSTATUS	ExitStatus
	)

Definition at line 735 of file procsup.c.

{
    PCSR_THREAD CsrThread;
    PCSR_PROCESS CsrProcess;
    CLIENT_ID ClientId = *Cid;
    PLIST_ENTRY NextEntry;
 
    /* Acquire lock */
    CsrAcquireProcessLock();
 
    /* Find the thread */
    CsrThread = CsrLocateThreadByClientId(&CsrProcess, &ClientId);
 
    /* Make sure we got one back, and that it's not already gone */
    if (!(CsrThread) || (CsrProcess->Flags & CsrProcessTerminating))
    {
        /* Release the lock and return failure */
        CsrReleaseProcessLock();
        return STATUS_THREAD_IS_TERMINATING;
    }
 
    /* Set the terminated flag */
    CsrProcess->Flags |= CsrProcessTerminating;
 
    /* Get the List Pointers */
    NextEntry = CsrProcess->ThreadList.Flink;
    while (NextEntry != &CsrProcess->ThreadList)
    {
        /* Get the current thread entry */
        CsrThread = CONTAINING_RECORD(NextEntry, CSR_THREAD, Link);
 
        /* Move to the next entry */
        NextEntry = NextEntry->Flink;
 
        /* Make sure the thread isn't already dead */
        if (CsrThread->Flags & CsrThreadTerminated)
        {
            /* Go the the next thread */
            continue;
        }
 
        /* Set the Terminated flag */
        CsrThread->Flags |= CsrThreadTerminated;
 
        /* Acquire the Wait Lock */
        CsrAcquireWaitLock();
 
        /* Do we have an active wait block? */
        if (CsrThread->WaitBlock)
        {
            /* Notify waiters of termination */
            CsrNotifyWaitBlock(CsrThread->WaitBlock,
                               NULL,
                               NULL,
                               NULL,
                               CsrProcessTerminating,
                               TRUE);
        }
 
        /* Release the Wait Lock */
        CsrReleaseWaitLock();
 
        /* Dereference the thread */
        CsrLockedDereferenceThread(CsrThread);
    }
 
    /* Release the Process Lock and return success */
    CsrReleaseProcessLock();
    return STATUS_SUCCESS;
}

Referenced by CSR_API(), and CsrApiRequestThread().

CsrDestroyThread()

NTSTATUS NTAPI CsrDestroyThread

(

IN PCLIENT_ID

Cid

)

Definition at line 814 of file thredsup.c.

{
    CLIENT_ID ClientId = *Cid;
    PCSR_THREAD CsrThread;
    PCSR_PROCESS CsrProcess;
 
    /* Acquire lock */
    CsrAcquireProcessLock();
 
    /* Find the thread */
    CsrThread = CsrLocateThreadByClientId(&CsrProcess,
                                          &ClientId);
 
    /* Make sure we got one back, and that it's not already gone */
    if (!CsrThread || (CsrThread->Flags & CsrThreadTerminated))
    {
        /* Release the lock and return failure */
        CsrReleaseProcessLock();
        return STATUS_THREAD_IS_TERMINATING;
    }
 
    /* Set the terminated flag */
    CsrThread->Flags |= CsrThreadTerminated;
 
    /* Acquire the Wait Lock */
    CsrAcquireWaitLock();
 
    /* Do we have an active wait block? */
    if (CsrThread->WaitBlock)
    {
        /* Notify waiters of termination */
        CsrNotifyWaitBlock(CsrThread->WaitBlock,
                           NULL,
                           NULL,
                           NULL,
                           CsrProcessTerminating,
                           TRUE);
    }
 
    /* Release the Wait Lock */
    CsrReleaseWaitLock();
 
    /* Dereference the thread */
    CsrLockedDereferenceThread(CsrThread);
 
    /* Release the Process Lock and return success */
    CsrReleaseProcessLock();
    return STATUS_SUCCESS;
}

Referenced by CsrApiRequestThread().

CsrExecServerThread()

NTSTATUS NTAPI CsrExecServerThread	(	IN PVOID	ThreadHandler,
		IN ULONG	Flags
	)

Definition at line 886 of file thredsup.c.

{
    PCSR_THREAD CsrThread;
    HANDLE hThread;
    CLIENT_ID ClientId;
    NTSTATUS Status;
 
    /* Acquire process lock */
    CsrAcquireProcessLock();
 
    /* Allocate a CSR Thread in the Root Process */
    ASSERT(CsrRootProcess != NULL);
    CsrThread = CsrAllocateThread(CsrRootProcess);
    if (!CsrThread)
    {
        /* Fail */
        CsrReleaseProcessLock();
        return STATUS_NO_MEMORY;
    }
 
    /* Create the Thread */
    Status = RtlCreateUserThread(NtCurrentProcess(),
                                 NULL,
                                 FALSE,
                                 0,
                                 0,
                                 0,
                                 ThreadHandler,
                                 NULL,
                                 &hThread,
                                 &ClientId);
    if (!NT_SUCCESS(Status))
    {
        /* Fail */
        CsrDeallocateThread(CsrThread);
        CsrReleaseProcessLock();
        return Status;
    }
 
    /* Setup the Thread Object */
    CsrThread->ThreadHandle = hThread;
    ProtectHandle(hThread);
    CsrThread->ClientId = ClientId;
    CsrThread->Flags = Flags;
 
    /* Insert it into the Thread List */
    InsertHeadList(&CsrRootProcess->ThreadList, &CsrThread->Link);
 
    /* Increase the thread count */
    CsrRootProcess->ThreadCount++;
 
    /* Return */
    CsrReleaseProcessLock();
    return Status;
}

Referenced by CSR_API().

CsrGetProcessLuid()

NTSTATUS NTAPI CsrGetProcessLuid	(	IN HANDLE hProcess	OPTIONAL,
		OUT PLUID	Luid
	)

Definition at line 828 of file procsup.c.

{
    HANDLE hToken = NULL;
    NTSTATUS Status;
    ULONG Length;
    PTOKEN_STATISTICS TokenStats;
 
    /* Check if we have a handle to a CSR Process */
    if (!hProcess)
    {
        /* We don't, so try opening the Thread's Token */
        Status = NtOpenThreadToken(NtCurrentThread(),
                                   TOKEN_QUERY,
                                   FALSE,
                                   &hToken);
 
        /* Check for success */
        if (!NT_SUCCESS(Status))
        {
            /* If we got some other failure, then return and quit */
            if (Status != STATUS_NO_TOKEN) return Status;
 
            /* We don't have a Thread Token, use a Process Token */
            hProcess = NtCurrentProcess();
            hToken = NULL;
        }
    }
 
    /* Check if we have a token by now */
    if (!hToken)
    {
        /* No token yet, so open the Process Token */
        Status = NtOpenProcessToken(hProcess,
                                    TOKEN_QUERY,
                                    &hToken);
        if (!NT_SUCCESS(Status))
        {
            /* Still no token, return the error */
            return Status;
        }
    }
 
    /* Now get the size we'll need for the Token Information */
    Status = NtQueryInformationToken(hToken,
                                     TokenStatistics,
                                     NULL,
                                     0,
                                     &Length);
    if (Status != STATUS_BUFFER_TOO_SMALL)
    {
        /* Close the token and fail */
        NtClose(hToken);
        return Status;
    }
 
    /* Allocate memory for the Token Info */
    if (!(TokenStats = RtlAllocateHeap(CsrHeap, 0, Length)))
    {
        /* Fail and close the token */
        NtClose(hToken);
        return STATUS_NO_MEMORY;
    }
 
    /* Now query the information */
    Status = NtQueryInformationToken(hToken,
                                     TokenStatistics,
                                     TokenStats,
                                     Length,
                                     &Length);
 
    /* Close the handle */
    NtClose(hToken);
 
    /* Check for success */
    if (NT_SUCCESS(Status))
    {
        /* Return the LUID */
        *Luid = TokenStats->AuthenticationId;
    }
 
    /* Free the query information */
    RtlFreeHeap(CsrHeap, 0, TokenStats);
 
    /* Return the Status */
    return Status;
}

Referenced by FindProcessForShutdown(), and UserExitReactOS().

CsrImpersonateClient()

BOOLEAN NTAPI CsrImpersonateClient

(

IN PCSR_THREAD

CsrThread

)

Definition at line 932 of file procsup.c.

{
    NTSTATUS Status;
    PCSR_THREAD CurrentThread = CsrGetClientThread();
 
    /* Use the current thread if none given */
    if (!CsrThread) CsrThread = CurrentThread;
 
    /* Still no thread, something is wrong */
    if (!CsrThread)
    {
        /* Failure */
        return FALSE;
    }
 
    /* Make the call */
    Status = NtImpersonateThread(NtCurrentThread(),
                                 CsrThread->ThreadHandle,
                                 &CsrSecurityQos);
 
    if (!NT_SUCCESS(Status))
    {
        /* Failure */
#ifdef CSR_DBG
        DPRINT1("CSRSS: Can't impersonate client thread - Status = %lx\n", Status);
        // if (Status != STATUS_BAD_IMPERSONATION_LEVEL) DbgBreakPoint();
#endif
        return FALSE;
    }
 
    /* Increase the impersonation count for the current thread */
    if (CurrentThread) ++CurrentThread->ImpersonationCount;
 
    /* Return Success */
    return TRUE;
}

Referenced by BaseSrvIsVdmAllowed(), CheckForGlobalDriveLetter(), ConSrvInitConsole(), CSR_API(), FindProcessForShutdown(), GuiInit(), GuiLoadFrontEnd(), and UserExitReactOS().

CsrLockProcessByClientId()

NTSTATUS NTAPI CsrLockProcessByClientId	(	IN HANDLE	Pid,
		OUT PCSR_PROCESS *CsrProcess	OPTIONAL
	)

Referenced by CON_API_NOCONSOLE(), CSR_API(), CsrCreateRemoteThread(), and NotifyUserProcessForShutdown().

CsrLockThreadByClientId()

NTSTATUS NTAPI CsrLockThreadByClientId	(	IN HANDLE	Tid,
		OUT PCSR_THREAD *	CsrThread
	)

Definition at line 965 of file thredsup.c.

{
    PLIST_ENTRY NextEntry;
    PCSR_THREAD CurrentThread = NULL;
    NTSTATUS Status = STATUS_UNSUCCESSFUL;
    ULONG i;
 
    /* Acquire the lock */
    CsrAcquireProcessLock();
 
    /* Assume failure */
    ASSERT(CsrThread != NULL);
    *CsrThread = NULL;
 
    /* Convert to Hash */
    i = CsrHashThread(Tid);
 
    /* Setup the List Pointers */
    NextEntry = CsrThreadHashTable[i].Flink;
 
    /* Start Loop */
    while (NextEntry != &CsrThreadHashTable[i])
    {
        /* Get the Thread */
        CurrentThread = CONTAINING_RECORD(NextEntry, CSR_THREAD, HashLinks);
 
        /* Check for TID Match */
        if ((CurrentThread->ClientId.UniqueThread == Tid) &&
            (CurrentThread->Flags & CsrThreadTerminated) == 0)
        {
            /* Get out of here */
            break;
        }
 
        /* Move to the next entry */
        NextEntry = NextEntry->Flink;
    }
 
    /* Nothing found if we got back to the list */
    if (NextEntry == &CsrThreadHashTable[i]) CurrentThread = NULL;
 
    /* Did the loop find something? */
    if (CurrentThread)
    {
        /* Reference the found thread */
        Status = STATUS_SUCCESS;
        CsrLockedReferenceThread(CurrentThread);
        *CsrThread = CurrentThread;
    }
    else
    {
        /* Nothing found, release the lock */
        Status = STATUS_UNSUCCESSFUL;
        CsrReleaseProcessLock();
    }
 
    /* Return the status */
    return Status;
}

Referenced by GetThreadConsoleDesktop().

CsrMoveSatisfiedWait()

VOID NTAPI CsrMoveSatisfiedWait	(	IN PLIST_ENTRY	DestinationList,
		IN PLIST_ENTRY	WaitList
	)

Definition at line 330 of file wait.c.

{
    PLIST_ENTRY NextEntry;
    PCSR_WAIT_BLOCK WaitBlock;
 
    /* Acquire the Wait Lock */
    CsrAcquireWaitLock();
 
    /* Set the List pointers */
    NextEntry = WaitList->Flink;
 
    /* Start looping */
    while (NextEntry != WaitList)
    {
        /* Get the Wait block */
        WaitBlock = CONTAINING_RECORD(NextEntry, CSR_WAIT_BLOCK, WaitList);
 
        /* Go to the next entry */
        NextEntry = NextEntry->Flink;
 
        /* Check if there's no Wait Routine (satisfied wait) */
        if (WaitBlock->WaitFunction == NULL)
        {
            /* Remove it from the Wait Block Queue */
            RemoveEntryList(&WaitBlock->WaitList);
 
            /* Insert the wait into the destination list */
            InsertTailList(DestinationList, &WaitBlock->WaitList);
        }
    }
 
    /* Release the wait lock */
    CsrReleaseWaitLock();
}

CsrNotifyWait()

BOOLEAN NTAPI CsrNotifyWait	(	IN PLIST_ENTRY	WaitList,
		IN BOOLEAN	NotifyAll,
		IN PVOID	WaitArgument1,
		IN PVOID	WaitArgument2
	)

Definition at line 388 of file wait.c.

{
    PLIST_ENTRY NextEntry;
    PCSR_WAIT_BLOCK WaitBlock;
    BOOLEAN NotifySuccess = FALSE;
 
    /* Acquire the Wait Lock */
    CsrAcquireWaitLock();
 
    /* Set the List pointers */
    NextEntry = WaitList->Flink;
 
    /* Start looping */
    while (NextEntry != WaitList)
    {
        /* Get the Wait block */
        WaitBlock = CONTAINING_RECORD(NextEntry, CSR_WAIT_BLOCK, WaitList);
 
        /* Go to the next entry */
        NextEntry = NextEntry->Flink;
 
        /* Check if there is a Wait Routine */
        if (WaitBlock->WaitFunction != NULL)
        {
            /* Notify the Waiter */
            NotifySuccess |= CsrNotifyWaitBlock(WaitBlock,
                                                WaitList,
                                                WaitArgument1,
                                                WaitArgument2,
                                                0,
                                                FALSE);
 
            /*
             * We've already done a wait, so leave unless
             * we want to notify all the waits...
             */
            if (!NotifyAll) break;
        }
    }
 
    /* Release the wait lock and return */
    CsrReleaseWaitLock();
    return NotifySuccess;
}

Referenced by ConioUnpause(), ConSrvCloseHandle(), and PostprocessInput().

CsrPopulateDosDevices()

VOID NTAPI CsrPopulateDosDevices

(

VOID

)

Definition at line 1146 of file init.c.

{
    DPRINT1("Deprecated API in r55585.\n");
    return;
}

CsrQueryApiPort()

HANDLE NTAPI CsrQueryApiPort

(

VOID

)

Definition at line 1097 of file api.c.

{
    return CsrApiPort;
}

Referenced by CSR_API(), and UserClientConnect().

CsrReferenceThread()

VOID NTAPI CsrReferenceThread

(

IN PCSR_THREAD

CsrThread

)

Definition at line 1043 of file thredsup.c.

{
    /* Acquire process lock */
    CsrAcquireProcessLock();
 
    /* Sanity checks */
    ASSERT((CsrThread->Flags & CsrThreadTerminated) == 0);
    ASSERT(CsrThread->ReferenceCount != 0);
 
    /* Increment reference count */
    CsrThread->ReferenceCount++;
 
    /* Release the lock */
    CsrReleaseProcessLock();
}

Referenced by NotifyUserProcessForShutdown().

CsrRevertToSelf()

BOOLEAN NTAPI CsrRevertToSelf

(

VOID

)

Definition at line 1057 of file procsup.c.

{
    NTSTATUS Status;
    PCSR_THREAD CurrentThread = CsrGetClientThread();
    HANDLE ImpersonationToken = NULL;
 
    /* Check if we have a Current Thread */
    if (CurrentThread)
    {
        /* Make sure impersonation is on */
        if (!CurrentThread->ImpersonationCount)
        {
            DPRINT1("CSRSS: CsrRevertToSelf called while not impersonating\n");
            // DbgBreakPoint();
            return FALSE;
        }
        else if ((--CurrentThread->ImpersonationCount) > 0)
        {
            /* Success; impersonation count decreased but still not zero */
            return TRUE;
        }
    }
 
    /* Impersonation has been totally removed, revert to ourselves */
    Status = NtSetInformationThread(NtCurrentThread(),
                                    ThreadImpersonationToken,
                                    &ImpersonationToken,
                                    sizeof(ImpersonationToken));
 
    /* Return TRUE or FALSE */
    return NT_SUCCESS(Status);
}

Referenced by BaseSrvIsVdmAllowed(), CheckForGlobalDriveLetter(), ConSrvInitConsole(), CSR_API(), FindProcessForShutdown(), GuiInit(), GuiLoadFrontEnd(), and UserExitReactOS().

CsrServerInitialization()

NTSTATUS NTAPI CsrServerInitialization	(	IN ULONG	ArgumentCount,
		IN PCHAR	Arguments[]
	)

Definition at line 1011 of file init.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
 
    /* Cache System Basic Information so we don't always request it */
    Status = NtQuerySystemInformation(SystemBasicInformation,
                                      &CsrNtSysInfo,
                                      sizeof(SYSTEM_BASIC_INFORMATION),
                                      NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CSRSRV:%s: NtQuerySystemInformation failed (Status=0x%08lx)\n",
                __FUNCTION__, Status);
        return Status;
    }
 
    /* Save our Heap */
    CsrHeap = RtlGetProcessHeap();
 
    /* Set our Security Descriptor to protect the process */
    Status = CsrSetProcessSecurity();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CSRSRV:%s: CsrSetProcessSecurity failed (Status=0x%08lx)\n",
                __FUNCTION__, Status);
        return Status;
    }
 
    /* Set up Session Support */
    Status = CsrInitializeNtSessionList();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CSRSRV:%s: CsrInitializeSessions failed (Status=0x%08lx)\n",
                __FUNCTION__, Status);
        return Status;
    }
 
    /* Set up Process Support and allocate the CSR Root Process */
    Status = CsrInitializeProcessStructure();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CSRSRV:%s: CsrInitializeProcessStructure failed (Status=0x%08lx)\n",
                __FUNCTION__, Status);
        return Status;
    }
 
    /* Parse the command line */
    Status = CsrParseServerCommandLine(ArgumentCount, Arguments);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CSRSRV:%s: CsrParseServerCommandLine failed (Status=0x%08lx)\n",
                __FUNCTION__, Status);
        return Status;
    }
 
    /* Finish to initialize the CSR Root Process */
    Status = CsrInitCsrRootProcess();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CSRSRV:%s: CsrInitCsrRootProcess failed (Status=0x%08lx)\n",
                __FUNCTION__, Status);
        return Status;
    }
 
    /* Now initialize our API Port */
    Status = CsrApiPortInitialize();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CSRSRV:%s: CsrApiPortInitialize failed (Status=0x%08lx)\n",
                __FUNCTION__, Status);
        return Status;
    }
 
#ifdef __REACTOS__
    if (CsrSubSystemType != IMAGE_SUBSYSTEM_UNKNOWN)
    {
#endif
    /* Initialize the API Port for SM communication */
    Status = CsrSbApiPortInitialize();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CSRSRV:%s: CsrSbApiPortInitialize failed (Status=0x%08lx)\n",
                __FUNCTION__, Status);
        return Status;
    }
 
    /* We're all set! Connect to SM! */
    Status = SmConnectToSm(&CsrSbApiPortName,
                           CsrSbApiPort,
#ifdef __REACTOS__
                           CsrSubSystemType,
#else
                           IMAGE_SUBSYSTEM_WINDOWS_GUI,
#endif
                           &CsrSmApiPort);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CSRSRV:%s: SmConnectToSm failed (Status=0x%08lx)\n",
                __FUNCTION__, Status);
        return Status;
    }
#ifdef __REACTOS__
    }
#endif
 
    /* Have us handle Hard Errors */
    Status = NtSetDefaultHardErrorPort(CsrApiPort);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CSRSRV:%s: NtSetDefaultHardErrorPort failed (Status=0x%08lx)\n",
                __FUNCTION__, Status);
        return Status;
    }
 
    /* Return status */
    return Status;
}

Referenced by _main().

CsrSetBackgroundPriority()

VOID NTAPI CsrSetBackgroundPriority

(

IN PCSR_PROCESS

CsrProcess

)

Definition at line 1107 of file procsup.c.

{
    PROCESS_FOREGROUND_BACKGROUND ProcessPriority;
 
    /* Set the Foreground bit off */
    ProcessPriority.Foreground = FALSE;
 
    /* Set the new priority */
    NtSetInformationProcess(CsrProcess->ProcessHandle,
                            ProcessForegroundInformation,
                            &ProcessPriority,
                            sizeof(ProcessPriority));
}

Referenced by ConSrvSetProcessFocus(), CsrCreateProcess(), and CsrSbCreateSession().

CsrSetCallingSpooler()

VOID NTAPI CsrSetCallingSpooler

(

ULONG

Reserved

)

Definition at line 620 of file server.c.

{
    /* Deprecated */
    return;
}

CsrSetForegroundPriority()

VOID NTAPI CsrSetForegroundPriority

(

IN PCSR_PROCESS

CsrProcess

)

Definition at line 1138 of file procsup.c.

{
    PROCESS_FOREGROUND_BACKGROUND ProcessPriority;
 
    /* Set the Foreground bit on */
    ProcessPriority.Foreground = TRUE;
 
    /* Set the new priority */
    NtSetInformationProcess(CsrProcess->ProcessHandle,
                            ProcessForegroundInformation,
                            &ProcessPriority,
                            sizeof(ProcessPriority));
}

Referenced by ConSrvSetProcessFocus().

CsrShutdownProcesses()

NTSTATUS NTAPI CsrShutdownProcesses	(	IN PLUID	CallerLuid,
		IN ULONG	Flags
	)

Definition at line 1277 of file procsup.c.

{
    PLIST_ENTRY NextEntry;
    PCSR_PROCESS CsrProcess;
    NTSTATUS Status;
    BOOLEAN FirstTry;
    ULONG i;
    PCSR_SERVER_DLL ServerDll;
    ULONG Result = 0;
 
    /* Acquire process lock */
    CsrAcquireProcessLock();
 
    /* Add shutdown flag */
    CsrRootProcess->ShutdownFlags |= CsrShutdownSystem;
 
    /* Get the list pointers */
    NextEntry = CsrRootProcess->ListLink.Flink;
    while (NextEntry != &CsrRootProcess->ListLink)
    {
        /* Get the Process */
        CsrProcess = CONTAINING_RECORD(NextEntry, CSR_PROCESS, ListLink);
 
        /* Move to the next entry */
        NextEntry = NextEntry->Flink;
 
        /* Remove the skip flag, set shutdown flags to 0 */
        CsrProcess->Flags &= ~CsrProcessSkipShutdown;
        CsrProcess->ShutdownFlags = 0;
    }
 
    /* Set shutdown Priority */
    CsrSetToShutdownPriority();
 
    /* Start looping */
    while (TRUE)
    {
        /* Find the next process to shutdown */
        CsrProcess = FindProcessForShutdown(CallerLuid);
        if (!CsrProcess) break;
 
        /* Increase reference to process */
        CsrLockedReferenceProcess(CsrProcess);
 
        FirstTry = TRUE;
        while (TRUE)
        {
            /* Loop all the servers */
            for (i = 0; i < CSR_SERVER_DLL_MAX; i++)
            {
                /* Get the current server */
                ServerDll = CsrLoadedServerDll[i];
 
                /* Check if it's valid and if it has a Shutdown Process Callback */
                if (ServerDll && ServerDll->ShutdownProcessCallback)
                {
                    /* Release the lock, make the callback, and acquire it back */
                    CsrReleaseProcessLock();
                    Result = ServerDll->ShutdownProcessCallback(CsrProcess,
                                                                Flags,
                                                                FirstTry);
                    CsrAcquireProcessLock();
 
                    /* Check the result */
                    if (Result == CsrShutdownCsrProcess)
                    {
                        /* The callback unlocked the process */
                        break;
                    }
                    else if (Result == CsrShutdownCancelled)
                    {
#ifdef CSR_DBG
                        /* Check if this was a forced shutdown */
                        if (Flags & EWX_FORCE)
                        {
                            DPRINT1("Process %x cancelled forced shutdown (Dll = %d)\n",
                                     CsrProcess->ClientId.UniqueProcess, i);
                            DbgBreakPoint();
                        }
#endif
 
                        /* Shutdown was cancelled, unlock and exit */
                        CsrReleaseProcessLock();
                        Status = STATUS_CANCELLED;
                        goto Quickie;
                    }
                }
            }
 
            /* No matches during the first try, so loop again */
            if (FirstTry && (Result == CsrShutdownNonCsrProcess))
            {
                FirstTry = FALSE;
                continue;
            }
 
            /* Second try, break out */
            break;
        }
 
        /* We've reached the final loop here, so dereference */
        if (i == CSR_SERVER_DLL_MAX)
            CsrLockedDereferenceProcess(CsrProcess);
    }
 
    /* Success path */
    CsrReleaseProcessLock();
    Status = STATUS_SUCCESS;
 
Quickie:
    /* Return to normal priority */
    CsrSetToNormalPriority();
 
    return Status;
}

Referenced by UserExitReactOS().

CsrUnhandledExceptionFilter()

EXCEPTION_DISPOSITION NTAPI CsrUnhandledExceptionFilter

(

IN PEXCEPTION_POINTERS

ExceptionInfo

)

Definition at line 643 of file server.c.

{
    SYSTEM_KERNEL_DEBUGGER_INFORMATION DebuggerInfo;
    EXCEPTION_DISPOSITION Result = EXCEPTION_EXECUTE_HANDLER;
    BOOLEAN OldValue;
    NTSTATUS Status;
    UNICODE_STRING ErrorSource;
    ULONG_PTR ErrorParameters[4];
    ULONG Response;
 
    DPRINT1("CsrUnhandledExceptionFilter called\n");
 
    /* Check if a debugger is installed */
    Status = NtQuerySystemInformation(SystemKernelDebuggerInformation,
                                      &DebuggerInfo,
                                      sizeof(DebuggerInfo),
                                      NULL);
 
    /* Check if this is Session 0, and the Debugger is Enabled */
    if ((NtCurrentPeb()->SessionId != 0) && (NT_SUCCESS(Status)) &&
        (DebuggerInfo.KernelDebuggerEnabled))
    {
        /* Call the Unhandled Exception Filter */
        Result = RtlUnhandledExceptionFilter(ExceptionInfo);
        if (Result != EXCEPTION_CONTINUE_EXECUTION)
        {
            /* We're going to raise an error. Get Shutdown Privilege first */
            Status = RtlAdjustPrivilege(SE_SHUTDOWN_PRIVILEGE,
                                        TRUE,
                                        TRUE,
                                        &OldValue);
 
            /* Use the Process token if that failed */
            if (Status == STATUS_NO_TOKEN)
            {
                Status = RtlAdjustPrivilege(SE_SHUTDOWN_PRIVILEGE,
                                            TRUE,
                                            FALSE,
                                            &OldValue);
            }
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("CsrUnhandledExceptionFilter(): RtlAdjustPrivilege(SE_SHUTDOWN_PRIVILEGE) failed, Status = 0x%08lx\n", Status);
                goto NoPrivilege;
            }
 
            /* Initialize our Name String */
            RtlInitUnicodeString(&ErrorSource, L"Windows SubSystem");
 
            /* Set the parameters */
            ErrorParameters[0] = (ULONG_PTR)&ErrorSource;
            ErrorParameters[1] = ExceptionInfo->ExceptionRecord->ExceptionCode;
            ErrorParameters[2] = (ULONG_PTR)ExceptionInfo->ExceptionRecord->ExceptionAddress;
            ErrorParameters[3] = (ULONG_PTR)ExceptionInfo->ContextRecord;
 
            /* Bugcheck */
            NtRaiseHardError(STATUS_SYSTEM_PROCESS_TERMINATED,
                             4,
                             1,
                             ErrorParameters,
                             OptionShutdownSystem,
                             &Response);
        }
 
NoPrivilege:
        /* Just terminate us */
        NtTerminateProcess(NtCurrentProcess(),
                           ExceptionInfo->ExceptionRecord->ExceptionCode);
    }
 
    return Result;
}

Referenced by CsrApiRequestThread(), and CsrLoadServerDll().

CsrUnlockProcess()

NTSTATUS NTAPI CsrUnlockProcess

(

IN PCSR_PROCESS

CsrProcess

)

Definition at line 1410 of file procsup.c.

{
    /* Dereference the process */
    CsrLockedDereferenceProcess(CsrProcess);
 
    /* Release the lock and return */
    CsrReleaseProcessLock();
    return STATUS_SUCCESS;
}

Referenced by CON_API_NOCONSOLE(), CSR_API(), CsrCreateRemoteThread(), CsrCreateThread(), and NotifyUserProcessForShutdown().

CsrUnlockThread()

NTSTATUS NTAPI CsrUnlockThread

(

IN PCSR_THREAD

CsrThread

)

Definition at line 1075 of file thredsup.c.

{
    /* Dereference the Thread */
    ASSERT(ProcessStructureListLocked());
    CsrLockedDereferenceThread(CsrThread);
 
    /* Release the lock and return */
    CsrReleaseProcessLock();
    return STATUS_SUCCESS;
}

Referenced by GetThreadConsoleDesktop().

CsrValidateMessageBuffer()

BOOLEAN NTAPI CsrValidateMessageBuffer	(	IN PCSR_API_MESSAGE	ApiMessage,
		IN PVOID *	Buffer,
		IN ULONG	ElementCount,
		IN ULONG	ElementSize
	)

Definition at line 1430 of file api.c.

{
    PCSR_CAPTURE_BUFFER CaptureBuffer = ApiMessage->CsrCaptureData;
    SIZE_T BufferDistance = (ULONG_PTR)Buffer - (ULONG_PTR)ApiMessage;
    ULONG PointerCount;
    PULONG_PTR OffsetPointer;
 
    /*
     * Check whether we have a valid buffer pointer, elements
     * of non-trivial size and that we don't overflow.
     */
    if (!Buffer || ElementSize == 0 ||
        (ULONGLONG)ElementCount * ElementSize > (ULONGLONG)MAXULONG)
    {
        return FALSE;
    }
 
    /* Check if didn't get a buffer and there aren't any arguments to check */
    // if (!*Buffer && (ElementCount * ElementSize == 0))
    if (!*Buffer && ElementCount == 0) // Here ElementSize != 0 therefore only ElementCount can be == 0
        return TRUE;
 
    /* Check if we have no capture buffer */
    if (!CaptureBuffer)
    {
        /* In this case, succeed only if the caller is CSRSS */
        if (NtCurrentTeb()->ClientId.UniqueProcess ==
            ApiMessage->Header.ClientId.UniqueProcess)
        {
            return TRUE;
        }
    }
    else
    {
        /* Make sure that there is still space left in the capture buffer */
        if ((CaptureBuffer->Size - (ULONG_PTR)*Buffer + (ULONG_PTR)CaptureBuffer) >=
            (ElementCount * ElementSize))
        {
            /* Perform the validation test */
            PointerCount  = CaptureBuffer->PointerCount;
            OffsetPointer = CaptureBuffer->PointerOffsetsArray;
            while (PointerCount--)
            {
                /*
                 * Find in the array, the pointer offset (from the
                 * API message) that corresponds to the buffer.
                 */
                if (*OffsetPointer == BufferDistance)
                {
                    return TRUE;
                }
                ++OffsetPointer;
            }
        }
    }
 
    /* Failure */
#ifdef CSR_DBG
    DPRINT1("CSRSRV: Bad message buffer %p\n", ApiMessage);
    if (NtCurrentPeb()->BeingDebugged) DbgBreakPoint();
#endif
    return FALSE;
}

Referenced by CON_API(), CON_API_NOCONSOLE(), CSR_API(), and CsrValidateMessageString().

CsrValidateMessageString()

BOOLEAN NTAPI CsrValidateMessageString	(	IN PCSR_API_MESSAGE	ApiMessage,
		IN PWSTR *	MessageString
	)

Definition at line 1517 of file api.c.

{
    if (MessageString)
    {
        return CsrValidateMessageBuffer(ApiMessage,
                                        (PVOID*)MessageString,
                                        wcslen(*MessageString) + 1,
                                        sizeof(WCHAR));
    }
    else
    {
        return FALSE;
    }
}