smclient.c

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS NT-Compatible Session Manager
 * LICENSE:     BSD 2-Clause License (https://spdx.org/licenses/BSD-2-Clause)
 * PURPOSE:     SMSS Client Library (SMLIB) Client Stubs
 * COPYRIGHT:   Copyright 2012-2013 Alex Ionescu <alex.ionescu@reactos.org>
 *              Copyright 2021 Hervé Poussineau <hpoussin@reactos.org>
 *              Copyright 2022 Hermès Bélusca-Maïto <hermes.belusca-maito@reactos.org>
 */
 
/* INCLUDES *******************************************************************/
 
#include "precomp.h"
 
#define NDEBUG
#include <debug.h>
 
/* FUNCTIONS ******************************************************************/
 
NTSTATUS
NTAPI
SmConnectToSm(
    _In_opt_ PUNICODE_STRING SbApiPortName,
    _In_opt_ HANDLE SbApiPort,
    _In_opt_ ULONG ImageType,
    _Out_ PHANDLE SmApiPort)
{
    NTSTATUS Status;
    SECURITY_QUALITY_OF_SERVICE SecurityQos;
    UNICODE_STRING PortName;
    SB_CONNECTION_INFO ConnectInfo = {0};
    ULONG ConnectInfoLength = sizeof(ConnectInfo);
 
    /* Setup the QoS structure */
    SecurityQos.ImpersonationLevel = SecurityIdentification;
    SecurityQos.ContextTrackingMode = SECURITY_DYNAMIC_TRACKING;
    SecurityQos.EffectiveOnly = TRUE;
 
    /* Set the SM API port name */
    RtlInitUnicodeString(&PortName, L"\\SmApiPort"); // SM_API_PORT_NAME
 
    /* Check if this is a client connecting to SMSS, or SMSS to itself */
    if (SbApiPortName)
    {
        /* A client SB port as well as an image type must be present */
        if (!SbApiPort || (ImageType == IMAGE_SUBSYSTEM_UNKNOWN))
            return STATUS_INVALID_PARAMETER_MIX;
 
        /* Validate SbApiPortName's length */
        if (SbApiPortName->Length >= sizeof(ConnectInfo.SbApiPortName))
            return STATUS_INVALID_PARAMETER;
 
        /* Copy the client port name, and NULL-terminate it */
        RtlCopyMemory(ConnectInfo.SbApiPortName,
                      SbApiPortName->Buffer,
                      SbApiPortName->Length);
        ConnectInfo.SbApiPortName[SbApiPortName->Length / sizeof(WCHAR)] = UNICODE_NULL;
 
        /* Save the subsystem type */
        ConnectInfo.SubsystemType = ImageType;
    }
    else
    {
        /* No client port, and the subsystem type is not set */
        ConnectInfo.SbApiPortName[0] = UNICODE_NULL;
        ConnectInfo.SubsystemType = IMAGE_SUBSYSTEM_UNKNOWN;
    }
 
    /* Connect to SMSS and exchange connection information */
    Status = NtConnectPort(SmApiPort,
                           &PortName,
                           &SecurityQos,
                           NULL,
                           NULL,
                           NULL,
                           &ConnectInfo,
                           &ConnectInfoLength);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("SmConnectToSm: Connect to Sm failed %lx\n", Status);
    }
#if (NTDDI_VERSION < NTDDI_VISTA)
    else
    {
        /* Treat a warning or informational status as success */
        Status = STATUS_SUCCESS;
    }
#endif
 
    /* Return if the connection was successful or not */
    return Status;
}
 
NTSTATUS
NTAPI
SmSendMsgToSm(
    _In_ HANDLE SmApiPort,
    _Inout_ PSM_API_MSG SmApiMsg)
{
    static ULONG RtlpSmMessageInfo[SmpMaxApiNumber] =
    {
        0 /*sizeof(SM_CREATE_FOREIGN_SESSION_MSG)*/,
        sizeof(SM_SESSION_COMPLETE_MSG),
        0 /*sizeof(SM_TERMINATE_FOREIGN_SESSION_MSG)*/,
        sizeof(SM_EXEC_PGM_MSG),
        sizeof(SM_LOAD_DEFERED_SUBSYSTEM_MSG),
        sizeof(SM_START_CSR_MSG),
        sizeof(SM_STOP_CSR_MSG),
    };
 
    NTSTATUS Status;
    ULONG DataLength;
 
    if (SmApiMsg->ApiNumber >= SmpMaxApiNumber)
        return STATUS_NOT_IMPLEMENTED;
 
    /* Obtain the necessary data length for this API */
    DataLength = RtlpSmMessageInfo[SmApiMsg->ApiNumber];
 
    /* Fill out the Port Message Header */
    // RtlZeroMemory(&SmApiMsg->h, sizeof(SmApiMsg->h));
    SmApiMsg->h.u2.ZeroInit = 0;
    /* DataLength = user_data_size + anything between
     * header and data, including intermediate padding */
    SmApiMsg->h.u1.s1.DataLength = (CSHORT)DataLength +
        FIELD_OFFSET(SM_API_MSG, u) - sizeof(SmApiMsg->h);
    /* TotalLength = sizeof(*SmApiMsg) on <= NT5.2, otherwise:
     * DataLength + header_size == user_data_size + FIELD_OFFSET(SM_API_MSG, u)
     * without structure trailing padding */
    SmApiMsg->h.u1.s1.TotalLength = SmApiMsg->h.u1.s1.DataLength + sizeof(SmApiMsg->h);
 
    /* Send the LPC message and wait for a reply */
    Status = NtRequestWaitReplyPort(SmApiPort, &SmApiMsg->h, &SmApiMsg->h);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("SmSendMsgToSm: NtRequestWaitReplyPort failed, Status: 0x%08lx\n", Status);
    }
    else
    {
        /* Return the real status */
        Status = SmApiMsg->ReturnValue;
    }
 
    return Status;
}
 
NTSTATUS
NTAPI
SmSessionComplete(
    _In_ HANDLE SmApiPort,
    _In_ ULONG SessionId,
    _In_ NTSTATUS SessionStatus)
{
    SM_API_MSG SmApiMsg = {0};
    PSM_SESSION_COMPLETE_MSG SessionComplete = &SmApiMsg.u.SessionComplete;
 
#if 0 //def _WIN64
    /* 64-bit SMSS needs to talk to 32-bit processes so do the LPC conversion */
    if (SmpIsWow64Process())
    {
        return SmpWow64SessionComplete(SmApiPort, SessionId, SessionStatus);
    }
#endif
 
    /* Set the message data */
    SessionComplete->SessionId = SessionId;
    SessionComplete->SessionStatus = SessionStatus;
 
    /* Send the message and wait for a reply */
    SmApiMsg.ApiNumber = SmpSessionCompleteApi;
    return SmSendMsgToSm(SmApiPort, &SmApiMsg);
}
 
NTSTATUS
NTAPI
SmExecPgm(
    _In_ HANDLE SmApiPort,
    _In_ PRTL_USER_PROCESS_INFORMATION ProcessInformation,
    _In_ BOOLEAN DebugFlag)
{
    NTSTATUS Status;
    SM_API_MSG SmApiMsg = {0};
    PSM_EXEC_PGM_MSG ExecPgm = &SmApiMsg.u.ExecPgm;
 
#if 0 //def _WIN64
    /* 64-bit SMSS needs to talk to 32-bit processes so do the LPC conversion */
    if (SmpIsWow64Process())
    {
        return SmpWow64ExecPgm(SmApiPort, ProcessInformation, DebugFlag);
    }
#endif
 
    /* Set the message data */
    ExecPgm->ProcessInformation = *ProcessInformation;
    ExecPgm->DebugFlag = DebugFlag;
 
    /* Send the message and wait for a reply */
    SmApiMsg.ApiNumber = SmpExecPgmApi;
    Status = SmSendMsgToSm(SmApiPort, &SmApiMsg);
 
    /* Close the handles that the parent passed in and return status */
    NtClose(ProcessInformation->ProcessHandle);
    NtClose(ProcessInformation->ThreadHandle);
    return Status;
}
 
NTSTATUS
NTAPI
SmLoadDeferedSubsystem(
    _In_ HANDLE SmApiPort,
    _In_ PUNICODE_STRING DeferedSubsystem)
{
    SM_API_MSG SmApiMsg = {0};
    PSM_LOAD_DEFERED_SUBSYSTEM_MSG LoadDefered = &SmApiMsg.u.LoadDefered;
 
#if 0 //def _WIN64
    /* 64-bit SMSS needs to talk to 32-bit processes so do the LPC conversion */
    if (SmpIsWow64Process())
    {
        return SmpWow64LoadDeferedSubsystem(SmApiPort, DeferedSubsystem);
    }
#endif
 
    /* Validate DeferedSubsystem's length */
    if (DeferedSubsystem->Length > sizeof(LoadDefered->Buffer))
        return STATUS_INVALID_PARAMETER;
 
    /* Set the message data */
    /* Buffer stores a counted non-NULL-terminated UNICODE string */
    LoadDefered->Length = DeferedSubsystem->Length;
    RtlCopyMemory(LoadDefered->Buffer,
                  DeferedSubsystem->Buffer,
                  DeferedSubsystem->Length);
 
    /* Send the message and wait for a reply */
    SmApiMsg.ApiNumber = SmpLoadDeferedSubsystemApi;
    return SmSendMsgToSm(SmApiPort, &SmApiMsg);
}
 
NTSTATUS
NTAPI
SmStartCsr(
    _In_ HANDLE SmApiPort,
    _Out_ PULONG pMuSessionId,
    _In_opt_ PUNICODE_STRING CommandLine,
    _Out_ PHANDLE pWindowsSubSysProcessId,
    _Out_ PHANDLE pInitialCommandProcessId)
{
    NTSTATUS Status;
    SM_API_MSG SmApiMsg = {0};
    PSM_START_CSR_MSG StartCsr = &SmApiMsg.u.StartCsr;
 
#if 0 //def _WIN64
    /* 64-bit SMSS needs to talk to 32-bit processes so do the LPC conversion */
    if (SmpIsWow64Process())
    {
        return SmpWow64StartCsr(SmApiPort,
                                pMuSessionId,
                                CommandLine,
                                pWindowsSubSysProcessId,
                                pInitialCommandProcessId);
    }
#endif
 
    /* Set the message data */
    if (CommandLine)
    {
        /* Validate CommandLine's length */
        if (CommandLine->Length > sizeof(StartCsr->Buffer))
            return STATUS_INVALID_PARAMETER;
 
        /* Buffer stores a counted non-NULL-terminated UNICODE string */
        StartCsr->Length = CommandLine->Length;
        RtlCopyMemory(StartCsr->Buffer,
                      CommandLine->Buffer,
                      CommandLine->Length);
    }
    else
    {
        StartCsr->Length = 0;
    }
 
    /* Send the message and wait for a reply */
    SmApiMsg.ApiNumber = SmpStartCsrApi;
    Status = SmSendMsgToSm(SmApiPort, &SmApiMsg);
 
    /* Give back information to caller */
    *pMuSessionId = StartCsr->MuSessionId;
    *pWindowsSubSysProcessId = StartCsr->WindowsSubSysProcessId;
    *pInitialCommandProcessId = StartCsr->SmpInitialCommandProcessId;
 
    return Status;
}
 
NTSTATUS
NTAPI
SmStopCsr(
    _In_ HANDLE SmApiPort,
    _In_ ULONG MuSessionId)
{
    SM_API_MSG SmApiMsg = {0};
 
#if 0 //def _WIN64
    /* 64-bit SMSS needs to talk to 32-bit processes so do the LPC conversion */
    if (SmpIsWow64Process())
    {
        return SmpWow64StopCsr(SmApiPort, MuSessionId);
    }
#endif
 
    /* Set the message data */
    SmApiMsg.u.StopCsr.MuSessionId = MuSessionId;
 
    /* Send the message and wait for a reply */
    SmApiMsg.ApiNumber = SmpStopCsrApi;
    return SmSendMsgToSm(SmApiPort, &SmApiMsg);
}