session.c File Reference

#include "srv.h"
#include <debug.h>

Include dependency graph for session.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
NTSTATUS NTAPI	CsrInitializeNtSessionList (VOID)
PCSR_NT_SESSION NTAPI	CsrAllocateNtSession (IN ULONG SessionId)
VOID NTAPI	CsrReferenceNtSession (IN PCSR_NT_SESSION Session)
VOID NTAPI	CsrDereferenceNtSession (IN PCSR_NT_SESSION Session, IN NTSTATUS ExitStatus)
BOOLEAN NTAPI	CsrSbCreateSession (IN PSB_API_MSG ApiMessage)
BOOLEAN NTAPI	CsrSbForeignSessionComplete (IN PSB_API_MSG ApiMessage)
BOOLEAN NTAPI	CsrSbTerminateSession (IN PSB_API_MSG ApiMessage)
BOOLEAN NTAPI	CsrSbCreateProcess (IN PSB_API_MSG ApiMessage)
NTSTATUS NTAPI	CsrSbApiHandleConnectionRequest (IN PSB_API_MSG Message)
ULONG NTAPI	CsrSbApiRequestThread (_In_ PVOID Parameter)
	The CsrSbApiRequestThread routine handles incoming messages or connection requests on the SM API LPC Port.

Variables
RTL_CRITICAL_SECTION	CsrNtSessionLock
LIST_ENTRY	CsrNtSessionList
const PSB_API_ROUTINE	CsrServerSbApiDispatch [SbpMaxApiNumber - SbpCreateSession]

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file session.c.

Function Documentation

CsrAllocateNtSession()

PCSR_NT_SESSION NTAPI CsrAllocateNtSession

(

IN ULONG

SessionId

)

Definition at line 80 of file session.c.

{
    PCSR_NT_SESSION NtSession;
 
    /* Allocate an NT Session Object */
    NtSession = RtlAllocateHeap(CsrHeap, HEAP_ZERO_MEMORY, sizeof(CSR_NT_SESSION));
    if (NtSession)
    {
        /* Setup the Session Object */
        NtSession->SessionId = SessionId;
        NtSession->ReferenceCount = 1;
 
        /* Insert it into the Session List */
        CsrAcquireNtSessionLock();
        InsertHeadList(&CsrNtSessionList, &NtSession->SessionLink);
        CsrReleaseNtSessionLock();
    }
    else
    {
        ASSERT(NtSession != NULL);
    }
 
    /* Return the Session (or NULL) */
    return NtSession;
}

Referenced by CsrSbCreateSession().

CsrDereferenceNtSession()

VOID NTAPI CsrDereferenceNtSession	(	IN PCSR_NT_SESSION	Session,
		IN NTSTATUS	ExitStatus
	)

Definition at line 159 of file session.c.

{
    /* Acquire the lock */
    CsrAcquireNtSessionLock();
 
    /* Sanity checks */
    ASSERT(!IsListEmpty(&Session->SessionLink));
    ASSERT(Session->SessionId != 0);
    ASSERT(Session->ReferenceCount != 0);
 
    /* Dereference the Session Object */
    if ((--Session->ReferenceCount) == 0)
    {
        /* Remove it from the list */
        RemoveEntryList(&Session->SessionLink);
 
        /* Release the lock */
        CsrReleaseNtSessionLock();
 
        /* Tell SM that we're done here */
        SmSessionComplete(CsrSmApiPort, Session->SessionId, ExitStatus);
 
        /* Free the Session Object */
        RtlFreeHeap(CsrHeap, 0, Session);
    }
    else
    {
        /* Release the lock, the Session is still active */
        CsrReleaseNtSessionLock();
    }
}

Referenced by CsrProcessRefcountZero().

CsrInitializeNtSessionList()

NTSTATUS NTAPI CsrInitializeNtSessionList

(

VOID

)

Definition at line 56 of file session.c.

{
    /* Initialize the Session List */
    InitializeListHead(&CsrNtSessionList);
 
    /* Initialize the Session Lock */
    return RtlInitializeCriticalSection(&CsrNtSessionLock);
}

Referenced by CsrServerInitialization().

CsrReferenceNtSession()

VOID NTAPI CsrReferenceNtSession

(

IN PCSR_NT_SESSION

Session

)

Definition at line 121 of file session.c.

{
    /* Acquire the lock */
    CsrAcquireNtSessionLock();
 
    /* Sanity checks */
    ASSERT(!IsListEmpty(&Session->SessionLink));
    ASSERT(Session->SessionId != 0);
    ASSERT(Session->ReferenceCount != 0);
 
    /* Increase the reference count */
    Session->ReferenceCount++;
 
    /* Release the lock */
    CsrReleaseNtSessionLock();
}

Referenced by CsrCreateProcess().

CsrSbApiHandleConnectionRequest()

NTSTATUS NTAPI CsrSbApiHandleConnectionRequest

(

IN PSB_API_MSG

Message

)

Definition at line 437 of file session.c.

{
    NTSTATUS Status;
    REMOTE_PORT_VIEW RemotePortView;
    HANDLE hPort;
 
    /* Set the Port View Structure Length */
    RemotePortView.Length = sizeof(REMOTE_PORT_VIEW);
 
    /* Accept the connection */
    Status = NtAcceptConnectPort(&hPort,
                                 NULL,
                                 &Message->h,
                                 TRUE,
                                 NULL,
                                 &RemotePortView);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CSRSS: Sb Accept Connection failed %lx\n", Status);
        return Status;
    }
 
    /* Complete the Connection */
    Status = NtCompleteConnectPort(hPort);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CSRSS: Sb Complete Connection failed %lx\n",Status);
    }
 
    /* Return status */
    return Status;
}

Referenced by CsrSbApiRequestThread().

CsrSbApiRequestThread()

ULONG NTAPI CsrSbApiRequestThread

(

_In_ PVOID

Parameter

)

The CsrSbApiRequestThread routine handles incoming messages or connection requests on the SM API LPC Port.

Parameters

[in]

Parameter

System-default user-defined parameter. Unused.

Returns

The thread exit code, if the thread is terminated.

Definition at line 483 of file session.c.

{
    NTSTATUS Status;
    SB_API_MSG ReceiveMsg;
    PSB_API_MSG ReplyMsg = NULL;
    PVOID PortContext;
    ULONG MessageType;
 
    /* Start the loop */
    while (TRUE)
    {
        /* Wait for a message to come in */
        Status = NtReplyWaitReceivePort(CsrSbApiPort,
                                        &PortContext,
                                        &ReplyMsg->h,
                                        &ReceiveMsg.h);
 
        /* Check if we didn't get success */
        if (Status != STATUS_SUCCESS)
        {
            /* If we only got a warning, keep going */
            if (NT_SUCCESS(Status)) continue;
 
            /* We failed big time, so start out fresh */
            ReplyMsg = NULL;
            DPRINT1("CSRSS: ReceivePort failed - Status == %X\n", Status);
            continue;
        }
 
        /* Save the message type */
        MessageType = ReceiveMsg.h.u2.s2.Type;
 
        /* Check if this is a connection request */
        if (MessageType == LPC_CONNECTION_REQUEST)
        {
            /* Handle connection request */
            CsrSbApiHandleConnectionRequest(&ReceiveMsg);
 
            /* Start over */
            ReplyMsg = NULL;
            continue;
        }
 
        /* Check if the port died */
        if (MessageType == LPC_PORT_CLOSED)
        {
            /* Close the handle if we have one */
            if (PortContext) NtClose((HANDLE)PortContext);
 
            /* Client died, start over */
            ReplyMsg = NULL;
            continue;
        }
        else if (MessageType == LPC_CLIENT_DIED)
        {
            /* Client died, start over */
            ReplyMsg = NULL;
            continue;
        }
 
        /* This is an actual API message */
#if DBG
        DPRINT("CSRSS: %s Session Api Request received from %lx.%lx\n",
               CsrServerSbApiName[min(ReceiveMsg.ApiNumber, SbpMaxApiNumber)],
               ReceiveMsg.h.ClientId.UniqueProcess,
               ReceiveMsg.h.ClientId.UniqueThread);
#endif
 
        /* Reuse the message */
        ReplyMsg = &ReceiveMsg;
 
        /* Make sure that the API is supported */
        if (ReceiveMsg.ApiNumber < SbpMaxApiNumber)
        {
            /* Call the API */
            if (!CsrServerSbApiDispatch[ReceiveMsg.ApiNumber](&ReceiveMsg))
            {
#if DBG
                DPRINT1("CSRSS: %s Session Api called and failed\n",
                        CsrServerSbApiName[ReceiveMsg.ApiNumber]);
#endif
                /* It failed, so return nothing */
                ReplyMsg = NULL;
            }
        }
        else
        {
            /* This API number is not supported */
            DPRINT1("CSRSS: Invalid Sb Api Number %lx\n", ReceiveMsg.ApiNumber);
            /* The NT behaviour is to reset it to the Maximum API ID */
            ReceiveMsg.ApiNumber = SbpMaxApiNumber;
            ReplyMsg->ReturnValue = STATUS_NOT_IMPLEMENTED;
        }
    }
 
    UNREACHABLE;
    return STATUS_UNSUCCESSFUL;
}

Referenced by CsrSbApiPortInitialize().

CsrSbCreateProcess()

BOOLEAN NTAPI CsrSbCreateProcess

(

IN PSB_API_MSG

ApiMessage

)

Definition at line 413 of file session.c.

{
    ApiMessage->ReturnValue = STATUS_NOT_IMPLEMENTED;
    return TRUE;
}

CsrSbCreateSession()

BOOLEAN NTAPI CsrSbCreateSession

(

IN PSB_API_MSG

ApiMessage

)

Definition at line 211 of file session.c.

{
    PSB_CREATE_SESSION_MSG CreateSession = &ApiMessage->u.CreateSession;
    HANDLE hProcess, hThread;
    PCSR_PROCESS CsrProcess;
    PCSR_THREAD CsrThread;
    PCSR_SERVER_DLL ServerDll;
    PVOID ProcessData;
    NTSTATUS Status;
    KERNEL_USER_TIMES KernelTimes;
    ULONG i;
 
    /* Save the Process and Thread Handles */
    hProcess = CreateSession->ProcessInfo.ProcessHandle;
    hThread = CreateSession->ProcessInfo.ThreadHandle;
 
    /* Lock the Processes */
    CsrAcquireProcessLock();
 
    /* Allocate a new process */
    CsrProcess = CsrAllocateProcess();
    if (!CsrProcess)
    {
        /* Fail */
        ApiMessage->ReturnValue = STATUS_NO_MEMORY;
        CsrReleaseProcessLock();
        return TRUE;
    }
 
    /* Set the Exception Port for us */
    Status = NtSetInformationProcess(hProcess,
                                     ProcessExceptionPort,
                                     &CsrApiPort,
                                     sizeof(CsrApiPort));
 
    /* Check for success */
    if (!NT_SUCCESS(Status))
    {
        /* Fail the request */
        CsrDeallocateProcess(CsrProcess);
        CsrReleaseProcessLock();
 
        /* Strange as it seems, NTSTATUSes are actually returned */
        return (BOOLEAN)STATUS_NO_MEMORY;
    }
 
    /* Get the Create Time */
    Status = NtQueryInformationThread(hThread,
                                      ThreadTimes,
                                      &KernelTimes,
                                      sizeof(KernelTimes),
                                      NULL);
 
    /* Check for success */
    if (!NT_SUCCESS(Status))
    {
        /* Fail the request */
        CsrDeallocateProcess(CsrProcess);
        CsrReleaseProcessLock();
 
        /* Strange as it seems, NTSTATUSes are actually returned */
        return (BOOLEAN)Status;
    }
 
    /* Allocate a new Thread */
    CsrThread = CsrAllocateThread(CsrProcess);
    if (!CsrThread)
    {
        /* Fail the request */
        CsrDeallocateProcess(CsrProcess);
        CsrReleaseProcessLock();
 
        ApiMessage->ReturnValue = STATUS_NO_MEMORY;
        return TRUE;
    }
 
    /* Setup the Thread Object */
    CsrThread->CreateTime = KernelTimes.CreateTime;
    CsrThread->ClientId = CreateSession->ProcessInfo.ClientId;
    CsrThread->ThreadHandle = hThread;
    ProtectHandle(hThread);
    CsrThread->Flags = 0;
 
    /* Insert it into the Process List */
    Status = CsrInsertThread(CsrProcess, CsrThread);
    if (!NT_SUCCESS(Status))
    {
        /* Bail out */
        CsrDeallocateProcess(CsrProcess);
        CsrDeallocateThread(CsrThread);
        CsrReleaseProcessLock();
 
        /* Strange as it seems, NTSTATUSes are actually returned */
        return (BOOLEAN)Status;
    }
 
    /* Setup Process Data */
    CsrProcess->ClientId = CreateSession->ProcessInfo.ClientId;
    CsrProcess->ProcessHandle = hProcess;
    CsrProcess->NtSession = CsrAllocateNtSession(CreateSession->SessionId);
 
    /* Set the Process Priority */
    CsrSetBackgroundPriority(CsrProcess);
 
    /* Get the first data location */
    ProcessData = &CsrProcess->ServerData[CSR_SERVER_DLL_MAX];
 
    /* Loop every DLL */
    for (i = 0; i < CSR_SERVER_DLL_MAX; i++)
    {
        /* Get the current Server */
        ServerDll = CsrLoadedServerDll[i];
 
        /* Check if the DLL is loaded and has Process Data */
        if (ServerDll && ServerDll->SizeOfProcessData)
        {
            /* Write the pointer to the data */
            CsrProcess->ServerData[i] = ProcessData;
 
            /* Move to the next data location */
            ProcessData = (PVOID)((ULONG_PTR)ProcessData +
                                  ServerDll->SizeOfProcessData);
        }
        else
        {
            /* Nothing for this Process */
            CsrProcess->ServerData[i] = NULL;
        }
    }
 
    /* Insert the Process */
    CsrInsertProcess(NULL, CsrProcess);
 
    /* Activate the Thread */
    ApiMessage->ReturnValue = NtResumeThread(hThread, NULL);
 
    /* Release lock and return */
    CsrReleaseProcessLock();
    return TRUE;
}

CsrSbForeignSessionComplete()

BOOLEAN NTAPI CsrSbForeignSessionComplete

(

IN PSB_API_MSG

ApiMessage

)

Definition at line 368 of file session.c.

{
    /* Deprecated/Unimplemented in NT */
    ApiMessage->ReturnValue = STATUS_NOT_IMPLEMENTED;
    return TRUE;
}

CsrSbTerminateSession()

BOOLEAN NTAPI CsrSbTerminateSession

(

IN PSB_API_MSG

ApiMessage

)

Definition at line 391 of file session.c.

{
    ApiMessage->ReturnValue = STATUS_NOT_IMPLEMENTED;
    return TRUE;
}

Variable Documentation

CsrNtSessionList

LIST_ENTRY CsrNtSessionList

Definition at line 19 of file session.c.

Referenced by CsrAllocateNtSession(), and CsrInitializeNtSessionList().

CsrNtSessionLock

RTL_CRITICAL_SECTION CsrNtSessionLock

Definition at line 18 of file session.c.

Referenced by CsrInitializeNtSessionList().

CsrServerSbApiDispatch

const PSB_API_ROUTINE CsrServerSbApiDispatch[SbpMaxApiNumber - SbpCreateSession]

Initial value:

=
{
    CsrSbCreateSession,
    CsrSbTerminateSession,
    CsrSbForeignSessionComplete,
    CsrSbCreateProcess
}

Definition at line 21 of file session.c.

Referenced by CsrSbApiRequestThread().