smloop.c File Reference

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

Include dependency graph for smloop.c:

Go to the source code of this file.

Classes
struct	_SMP_CLIENT_CONTEXT

Macros
#define	NDEBUG

Typedefs
typedef struct _SMP_CLIENT_CONTEXT	SMP_CLIENT_CONTEXT
typedef struct _SMP_CLIENT_CONTEXT *	PSMP_CLIENT_CONTEXT
typedef NTSTATUS(NTAPI *	PSM_API_HANDLER) (_In_ PSM_API_MSG SmApiMsg, _In_ PSMP_CLIENT_CONTEXT ClientContext, _In_ HANDLE SmApiPort)

Functions
NTSTATUS NTAPI	SmpCreateForeignSession (IN PSM_API_MSG SmApiMsg, IN PSMP_CLIENT_CONTEXT ClientContext, IN HANDLE SmApiPort)
NTSTATUS NTAPI	SmpSessionComplete (IN PSM_API_MSG SmApiMsg, IN PSMP_CLIENT_CONTEXT ClientContext, IN HANDLE SmApiPort)
NTSTATUS NTAPI	SmpTerminateForeignSession (IN PSM_API_MSG SmApiMsg, IN PSMP_CLIENT_CONTEXT ClientContext, IN HANDLE SmApiPort)
NTSTATUS NTAPI	SmpExecPgm (IN PSM_API_MSG SmApiMsg, IN PSMP_CLIENT_CONTEXT ClientContext, IN HANDLE SmApiPort)
NTSTATUS NTAPI	SmpLoadDeferedSubsystem (_In_ PSM_API_MSG SmApiMsg, _In_ PSMP_CLIENT_CONTEXT ClientContext, _In_ HANDLE SmApiPort)
NTSTATUS NTAPI	SmpStartCsr (IN PSM_API_MSG SmApiMsg, IN PSMP_CLIENT_CONTEXT ClientContext, IN HANDLE SmApiPort)
NTSTATUS NTAPI	SmpStopCsr (IN PSM_API_MSG SmApiMsg, IN PSMP_CLIENT_CONTEXT ClientContext, IN HANDLE SmApiPort)
NTSTATUS NTAPI	SmpHandleConnectionRequest (IN HANDLE SmApiPort, IN PSB_API_MSG SbApiMsg)
ULONG NTAPI	SmpApiLoop (_In_ PVOID Parameter)

Variables
volatile LONG	SmTotalApiThreads
HANDLE	SmUniqueProcessId
const PSM_API_HANDLER	SmpApiDispatch [SmpMaxApiNumber - SmpCreateForeignSessionApi]

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file smloop.c.

Typedef Documentation

PSM_API_HANDLER

typedef NTSTATUS(NTAPI * PSM_API_HANDLER) (_In_ PSM_API_MSG SmApiMsg, _In_ PSMP_CLIENT_CONTEXT ClientContext, _In_ HANDLE SmApiPort)

Definition at line 27 of file smloop.c.

PSMP_CLIENT_CONTEXT

typedef struct _SMP_CLIENT_CONTEXT * PSMP_CLIENT_CONTEXT

SMP_CLIENT_CONTEXT

typedef struct _SMP_CLIENT_CONTEXT SMP_CLIENT_CONTEXT

Function Documentation

SmpApiLoop()

ULONG NTAPI SmpApiLoop

(

_In_ PVOID

Parameter

)

Definition at line 437 of file smloop.c.

{
    HANDLE SmApiPort = (HANDLE)Parameter;
    NTSTATUS Status;
    PSMP_CLIENT_CONTEXT ClientContext;
    PSM_API_MSG ReplyMsg = NULL;
    SM_API_MSG RequestMsg;
    PROCESS_BASIC_INFORMATION ProcessInformation;
    LARGE_INTEGER Timeout;
 
    /* Increase the number of API threads for throttling code for later */
    _InterlockedExchangeAdd(&SmTotalApiThreads, 1);
 
    /* Mark us critical */
    RtlSetThreadIsCritical(TRUE, NULL, TRUE);
 
    /* Set the PID of the SM process itself for later checking */
    NtQueryInformationProcess(NtCurrentProcess(),
                              ProcessBasicInformation,
                              &ProcessInformation,
                              sizeof(ProcessInformation),
                              NULL);
    SmUniqueProcessId = (HANDLE)ProcessInformation.UniqueProcessId;
 
    /* Now process incoming messages */
    while (TRUE)
    {
        /* Begin waiting on a request */
        Status = NtReplyWaitReceivePort(SmApiPort,
                                        (PVOID*)&ClientContext,
                                        &ReplyMsg->h,
                                        &RequestMsg.h);
        if (Status == STATUS_NO_MEMORY)
        {
            /* Ran out of memory, so do a little timeout and try again */
            if (ReplyMsg) DPRINT1("SMSS: Failed to reply to calling thread, retrying.\n");
            Timeout.QuadPart = -50000000;
            NtDelayExecution(FALSE, &Timeout);
            continue;
        }
 
        /* Check what kind of request we received */
        switch (RequestMsg.h.u2.s2.Type)
        {
            /* A new connection */
            case LPC_CONNECTION_REQUEST:
                /* Create the right structures for it */
                SmpHandleConnectionRequest(SmApiPort, (PSB_API_MSG)&RequestMsg);
                ReplyMsg = NULL;
                break;
 
            /* A closed connection */
            case LPC_PORT_CLOSED:
                /* Destroy any state we had for this client */
                DPRINT1("Port closed\n");
                //if (ClientContext) SmpPushDeferredClientContext(ClientContext);
                ReplyMsg = NULL;
                break;
 
            /* An actual API message */
            default:
            {
                if (!ClientContext)
                {
                    ReplyMsg = NULL;
                    break;
                }
 
#if DBG
                DPRINT("SMSS: %s Api Request received from %lx.%lx\n",
                       SmpApiName[min(RequestMsg.ApiNumber, SmpMaxApiNumber)],
                       RequestMsg.h.ClientId.UniqueProcess,
                       RequestMsg.h.ClientId.UniqueThread);
#endif
 
                RequestMsg.ReturnValue = STATUS_PENDING;
 
                /* Check if the API is valid */
                if (RequestMsg.ApiNumber >= SmpMaxApiNumber)
                {
                    /* It isn't, fail */
                    DPRINT1("SMSS: Invalid Sm Api Number %lx\n", RequestMsg.ApiNumber);
                    Status = STATUS_NOT_IMPLEMENTED;
                }
                else if ((RequestMsg.ApiNumber <= SmpTerminateForeignSessionApi) &&
                         !(ClientContext->Subsystem))
                {
                    /* It's valid, but doesn't have a subsystem with it */
                    DPRINT1("SMSS: Invalid session API\n");
                    Status = STATUS_INVALID_PARAMETER;
                }
                else
                {
                    /* It's totally okay, so call the dispatcher for it */
                    _SEH2_TRY
                    {
                        Status = SmpApiDispatch[RequestMsg.ApiNumber](&RequestMsg,
                                                                      ClientContext,
                                                                      SmApiPort);
                    }
                    _SEH2_EXCEPT(SmpUnhandledExceptionFilter(_SEH2_GetExceptionInformation()))
                    {
                        ReplyMsg = NULL;
                        _SEH2_YIELD(break);
                    }
                    _SEH2_END;
                }
 
                /* Write the result value and return the message back */
                RequestMsg.ReturnValue = Status;
                ReplyMsg = &RequestMsg;
                break;
            }
        }
    }
 
    UNREACHABLE;
    return STATUS_UNSUCCESSFUL;
}

Referenced by SmpInit().

SmpCreateForeignSession()

NTSTATUS NTAPI SmpCreateForeignSession	(	IN PSM_API_MSG	SmApiMsg,
		IN PSMP_CLIENT_CONTEXT	ClientContext,
		IN HANDLE	SmApiPort
	)

Definition at line 40 of file smloop.c.

{
    DPRINT1("%s is not yet implemented\n", __FUNCTION__);
    return STATUS_NOT_IMPLEMENTED;
}

SmpExecPgm()

NTSTATUS NTAPI SmpExecPgm	(	IN PSM_API_MSG	SmApiMsg,
		IN PSMP_CLIENT_CONTEXT	ClientContext,
		IN HANDLE	SmApiPort
	)

Definition at line 70 of file smloop.c.

{
    HANDLE ProcessHandle;
    NTSTATUS Status;
    PSM_EXEC_PGM_MSG SmExecPgm;
    RTL_USER_PROCESS_INFORMATION ProcessInformation;
    OBJECT_ATTRIBUTES ObjectAttributes;
 
    /* Open the client process */
    InitializeObjectAttributes(&ObjectAttributes, NULL, 0, NULL, NULL);
    Status = NtOpenProcess(&ProcessHandle,
                           PROCESS_DUP_HANDLE,
                           &ObjectAttributes,
                           &SmApiMsg->h.ClientId);
    if (!NT_SUCCESS(Status))
    {
        /* Fail */
        DPRINT1("SmExecPgm: NtOpenProcess Failed %lx\n", Status);
        return Status;
    }
 
    /* Copy the process information out of the message */
    SmExecPgm = &SmApiMsg->u.ExecPgm;
    ProcessInformation = SmExecPgm->ProcessInformation;
 
    /* Duplicate the process handle */
    Status = NtDuplicateObject(ProcessHandle,
                               SmExecPgm->ProcessInformation.ProcessHandle,
                               NtCurrentProcess(),
                               &ProcessInformation.ProcessHandle,
                               PROCESS_ALL_ACCESS,
                               0,
                               0);
    if (!NT_SUCCESS(Status))
    {
        /* Close the handle and fail */
        NtClose(ProcessHandle);
        DPRINT1("SmExecPgm: NtDuplicateObject (Process) Failed %lx\n", Status);
        return Status;
    }
 
    /* Duplicate the thread handle */
    Status = NtDuplicateObject(ProcessHandle,
                               SmExecPgm->ProcessInformation.ThreadHandle,
                               NtCurrentProcess(),
                               &ProcessInformation.ThreadHandle,
                               THREAD_ALL_ACCESS,
                               0,
                               0);
    if (!NT_SUCCESS(Status))
    {
        /* Close both handles and fail */
        NtClose(ProcessInformation.ProcessHandle);
        NtClose(ProcessHandle);
        DPRINT1("SmExecPgm: NtDuplicateObject (Thread) Failed %lx\n", Status);
        return Status;
    }
 
    /* Close the process handle and call the internal client API */
    NtClose(ProcessHandle);
    return SmpSbCreateSession(NULL,
                              NULL,
                              &ProcessInformation,
                              0,
                              SmExecPgm->DebugFlag ? &SmApiMsg->h.ClientId : NULL);
}

SmpHandleConnectionRequest()

NTSTATUS NTAPI SmpHandleConnectionRequest	(	IN HANDLE	SmApiPort,
		IN PSB_API_MSG	SbApiMsg
	)

Definition at line 287 of file smloop.c.

{
    BOOLEAN Accept = TRUE;
    HANDLE PortHandle, ProcessHandle;
    ULONG SessionId;
    UNICODE_STRING SubsystemPort;
    PSMP_CLIENT_CONTEXT ClientContext;
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    REMOTE_PORT_VIEW PortView;
    SECURITY_QUALITY_OF_SERVICE SecurityQos;
    PSMP_SUBSYSTEM CidSubsystem, TypeSubsystem;
 
    /* Initialize QoS data */
    SecurityQos.ImpersonationLevel = SecurityIdentification;
    SecurityQos.ContextTrackingMode = SECURITY_DYNAMIC_TRACKING;
    SecurityQos.EffectiveOnly = TRUE;
 
    /* Check if this is SM connecting to itself */
    if (SbApiMsg->h.ClientId.UniqueProcess == SmUniqueProcessId)
    {
        /* No need to get any handle -- assume session 0 */
        ProcessHandle = NULL;
        SessionId = 0;
    }
    else
    {
        /* Reference the foreign process */
        InitializeObjectAttributes(&ObjectAttributes, NULL, 0, NULL, NULL);
        Status = NtOpenProcess(&ProcessHandle,
                               PROCESS_QUERY_INFORMATION,
                               &ObjectAttributes,
                               &SbApiMsg->h.ClientId);
        if (!NT_SUCCESS(Status)) Accept = FALSE;
 
        /* Get its session ID */
        SmpGetProcessMuSessionId(ProcessHandle, &SessionId);
    }
 
    /* See if we already know about the caller's subsystem */
    CidSubsystem = SmpLocateKnownSubSysByCid(&SbApiMsg->h.ClientId);
    if ((CidSubsystem) && (Accept))
    {
        /* Check if we already have a subsystem for this kind of image */
        TypeSubsystem = SmpLocateKnownSubSysByType(SessionId,
                                                   SbApiMsg->ConnectionInfo.SubsystemType);
        if (TypeSubsystem == CidSubsystem)
        {
            /* Someone is trying to take control of an existing subsystem, fail */
            Accept = FALSE;
            DPRINT1("SMSS: Connection from SubSystem rejected\n");
            DPRINT1("SMSS: Image type already being served\n");
        }
        else
        {
            /* Set this image type as the type for this subsystem */
            CidSubsystem->ImageType = SbApiMsg->ConnectionInfo.SubsystemType;
        }
 
        /* Drop the reference we had acquired */
        if (TypeSubsystem) SmpDereferenceSubsystem(TypeSubsystem);
    }
 
    /* Check if we'll be accepting the connection */
    if (Accept)
    {
        /* We will, so create a client context for it */
        ClientContext = RtlAllocateHeap(SmpHeap, 0, sizeof(SMP_CLIENT_CONTEXT));
        if (ClientContext)
        {
            ClientContext->ProcessHandle = ProcessHandle;
            ClientContext->Subsystem = CidSubsystem;
            ClientContext->Reserved = NULL;
            ClientContext->PortHandle = NULL;
        }
        else
        {
            /* Failed to allocate a client context, so reject the connection */
            DPRINT1("Rejecting connection due to lack of memory\n");
            Accept = FALSE;
        }
    }
    else
    {
        /* Use a bogus context since we're going to reject the message */
        ClientContext = (PSMP_CLIENT_CONTEXT)SbApiMsg;
    }
 
    /* Now send the actual accept reply (which could be a rejection) */
    PortView.Length = sizeof(PortView);
    Status = NtAcceptConnectPort(&PortHandle,
                                 ClientContext,
                                 &SbApiMsg->h,
                                 Accept,
                                 NULL,
                                 &PortView);
    if (!(Accept) || !(NT_SUCCESS(Status)))
    {
        /* Close the process handle, reference the subsystem, and exit */
        DPRINT1("Accept failed or rejected: %lx\n", Status);
        if (ClientContext != (PVOID)SbApiMsg) RtlFreeHeap(SmpHeap, 0, ClientContext);
        if (ProcessHandle) NtClose(ProcessHandle);
        if (CidSubsystem) SmpDereferenceSubsystem(CidSubsystem);
        return Status;
    }
 
    /* Save the port handle now that we've accepted it */
    if (ClientContext) ClientContext->PortHandle = PortHandle;
    if (CidSubsystem) CidSubsystem->PortHandle = PortHandle;
 
    /* Complete the port connection */
    Status = NtCompleteConnectPort(PortHandle);
    if ((NT_SUCCESS(Status)) && (CidSubsystem))
    {
        /* This was an actual subsystem, so connect back to it */
        SbApiMsg->ConnectionInfo.SbApiPortName[119] = UNICODE_NULL;
        RtlCreateUnicodeString(&SubsystemPort,
                               SbApiMsg->ConnectionInfo.SbApiPortName);
        Status = NtConnectPort(&CidSubsystem->SbApiPort,
                               &SubsystemPort,
                               &SecurityQos,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("SMSS: Connect back to Sb %wZ failed %lx\n", &SubsystemPort, Status);
        }
        RtlFreeUnicodeString(&SubsystemPort);
 
        /* Now that we're connected, signal the event handle */
        NtSetEvent(CidSubsystem->Event, NULL);
    }
    else if (CidSubsystem)
    {
        /* We failed to complete the connection, so clear the port handle */
        DPRINT1("Completing the connection failed: %lx\n", Status);
        CidSubsystem->PortHandle = NULL;
    }
 
    /* Dereference the subsystem and return the result */
    if (CidSubsystem) SmpDereferenceSubsystem(CidSubsystem);
    return Status;
}

Referenced by SmpApiLoop().

SmpLoadDeferedSubsystem()

NTSTATUS NTAPI SmpLoadDeferedSubsystem	(	_In_ PSM_API_MSG	SmApiMsg,
		_In_ PSMP_CLIENT_CONTEXT	ClientContext,
		_In_ HANDLE	SmApiPort
	)

Definition at line 141 of file smloop.c.

{
    NTSTATUS Status = STATUS_OBJECT_NAME_NOT_FOUND;
    PSM_LOAD_DEFERED_SUBSYSTEM_MSG SmLoadDefered = &SmApiMsg->u.LoadDefered;
    UNICODE_STRING DeferedSubsystem;
    ULONG MuSessionId;
    PLIST_ENTRY NextEntry;
    PSMP_REGISTRY_VALUE RegEntry;
 
    /* Validate DeferedSubsystem's length */
    if ((SmLoadDefered->Length <= 0) ||
        (SmLoadDefered->Length > sizeof(SmLoadDefered->Buffer)))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Get the name of the subsystem to start */
    DeferedSubsystem.Length = (USHORT)SmLoadDefered->Length;
    DeferedSubsystem.MaximumLength = DeferedSubsystem.Length;
    DeferedSubsystem.Buffer = SmLoadDefered->Buffer;
 
    /* Find a subsystem responsible for this session */
    SmpGetProcessMuSessionId(ClientContext->ProcessHandle, &MuSessionId);
    if (!SmpCheckDuplicateMuSessionId(MuSessionId))
    {
        DPRINT1("SMSS: Deferred subsystem load (%wZ) for MuSessionId %u, status=0x%x\n",
                &DeferedSubsystem, MuSessionId, Status);
        return Status;
    }
 
    /* Now process the deferred subsystems list */
    for (NextEntry = SmpSubSystemsToDefer.Flink;
         NextEntry != &SmpSubSystemsToDefer;
         NextEntry = NextEntry->Flink)
    {
        /* Get each entry and check if it's the subsystem we are looking for */
        RegEntry = CONTAINING_RECORD(NextEntry, SMP_REGISTRY_VALUE, Entry);
        if (RtlEqualUnicodeString(&RegEntry->Name, &DeferedSubsystem, TRUE))
        {
            // TODO: One may want to extra-flag the command for
            // specific POSIX or OS2 processing...
 
            /* Load the deferred subsystem */
            Status = SmpExecuteCommand(&RegEntry->Value,
                                       MuSessionId,
                                       NULL,
                                       SMP_SUBSYSTEM_FLAG);
            if (!NT_SUCCESS(Status))
                DPRINT1("SMSS: Subsystem execute failed (%wZ)\n", &RegEntry->Value);
 
            break;
        }
    }
 
    /* Return status */
    return Status;
}

SmpSessionComplete()

NTSTATUS NTAPI SmpSessionComplete	(	IN PSM_API_MSG	SmApiMsg,
		IN PSMP_CLIENT_CONTEXT	ClientContext,
		IN HANDLE	SmApiPort
	)

Definition at line 50 of file smloop.c.

{
    DPRINT1("%s is not yet implemented\n", __FUNCTION__);
    return STATUS_NOT_IMPLEMENTED;
}

SmpStartCsr()

NTSTATUS NTAPI SmpStartCsr	(	IN PSM_API_MSG	SmApiMsg,
		IN PSMP_CLIENT_CONTEXT	ClientContext,
		IN HANDLE	SmApiPort
	)

Definition at line 204 of file smloop.c.

{
    PSM_START_CSR_MSG SmStartCsr = &SmApiMsg->u.StartCsr;
    UNICODE_STRING InitialCommand;
    HANDLE InitialCommandProcess, InitialCommandProcessId, WindowsSubSysProcessId;
    NTSTATUS Status;
 
    Status = SmpLoadSubSystemsForMuSession(&SmStartCsr->MuSessionId,
                                           &WindowsSubSysProcessId,
                                           &InitialCommand);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("SMSS: SmpLoadSubSystemsForMuSession failed with status 0x%08x\n", Status);
        return Status;
    }
 
    if (SmStartCsr->Length)
    {
        InitialCommand.Length = InitialCommand.MaximumLength = SmStartCsr->Length;
        InitialCommand.Buffer = SmStartCsr->Buffer;
    }
 
    Status = SmpExecuteInitialCommand(SmStartCsr->MuSessionId,
                                      &InitialCommand,
                                      &InitialCommandProcess,
                                      &InitialCommandProcessId);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("SMSS: SmpExecuteInitialCommand failed with status 0x%08x\n", Status);
        /* FIXME: undo effects of SmpLoadSubSystemsForMuSession */
        ASSERT(FALSE);
        return Status;
    }
 
    NtClose(InitialCommandProcess);
 
    SmStartCsr->WindowsSubSysProcessId = WindowsSubSysProcessId;
    SmStartCsr->SmpInitialCommandProcessId = InitialCommandProcessId;
 
    return STATUS_SUCCESS;
}

SmpStopCsr()

NTSTATUS NTAPI SmpStopCsr	(	IN PSM_API_MSG	SmApiMsg,
		IN PSMP_CLIENT_CONTEXT	ClientContext,
		IN HANDLE	SmApiPort
	)

Definition at line 250 of file smloop.c.

{
    DPRINT1("%s is not yet implemented\n", __FUNCTION__);
    return STATUS_NOT_IMPLEMENTED;
}

SmpTerminateForeignSession()

NTSTATUS NTAPI SmpTerminateForeignSession	(	IN PSM_API_MSG	SmApiMsg,
		IN PSMP_CLIENT_CONTEXT	ClientContext,
		IN HANDLE	SmApiPort
	)

Definition at line 60 of file smloop.c.

{
    DPRINT1("%s is not yet implemented\n", __FUNCTION__);
    return STATUS_NOT_IMPLEMENTED;
}

Variable Documentation

SmpApiDispatch

const PSM_API_HANDLER SmpApiDispatch[SmpMaxApiNumber - SmpCreateForeignSessionApi]

Initial value:

=
{
    SmpCreateForeignSession,
    SmpSessionComplete,
    SmpTerminateForeignSession,
    SmpExecPgm,
    SmpLoadDeferedSubsystem,
    SmpStartCsr,
    SmpStopCsr
}

Definition at line 258 of file smloop.c.

Referenced by SmpApiLoop().

SmTotalApiThreads

volatile LONG SmTotalApiThreads

Definition at line 33 of file smloop.c.

Referenced by SmpApiLoop().

SmUniqueProcessId

HANDLE SmUniqueProcessId

Definition at line 34 of file smloop.c.

Referenced by SmpApiLoop(), and SmpHandleConnectionRequest().