reactos/sdk/lib/smlib/smutils.c

/*
 * PROJECT:     ReactOS SM Helper Library
 * LICENSE:     GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
 * PURPOSE:     Utility functions built around the client SM API
 * COPYRIGHT:   Copyright 2005 Emanuele Aliberti <ea@reactos.com>
 *              Copyright 2022 Hermès Bélusca-Maïto <hermes.belusca-maito@reactos.org>
 */

#include "precomp.h"

#define WIN32_NO_STATUS
#define _INC_WINDOWS
#define COM_NO_WINDOWS_H
#include <windef.h>
#include <winreg.h>

#define NTOS_MODE_USER
#include <ndk/cmfuncs.h>

#include <sm/helper.h>

#define NDEBUG
#include <debug.h>

#if DBG
BOOLEAN SmpDebug = TRUE;
#else
BOOLEAN SmpDebug = FALSE;
#endif

/**
 * @brief
 * This function is used to make the SM start an external process
 * under an already-loaded environment subsystem server.
 *
 * @param[in]   SmApiPort
 * Port handle returned by SmConnectToSm().
 *
 * @param[in]   Program
 * Fully qualified NT name of the executable to load.
 *
 * @return
 * Success status as handed by the SM reply; otherwise a failure
 * status code.
 *
 * @remark
 * Adapted from SMSS' SmpExecuteInitialCommand() and SmpExecuteImage().
 **/
NTSTATUS
NTAPI
SmExecuteProgram(
    _In_ HANDLE SmApiPort,
    _In_ PUNICODE_STRING Program /*,
    _Out_opt_ PRTL_USER_PROCESS_INFORMATION ProcessInformation*/)
{
    // ULONG MuSessionId;

    NTSTATUS Status;
    RTL_USER_PROCESS_INFORMATION ProcessInfo;
    PRTL_USER_PROCESS_PARAMETERS ProcessParameters;

    PUNICODE_STRING FileName = Program; // FIXME!
    PUNICODE_STRING Directory = NULL; // FIXME!
    PUNICODE_STRING CommandLine = NULL; // FIXME!

    PVOID SmpDefaultEnvironment = NtCurrentPeb()->ProcessParameters->Environment;
    // UNICODE_STRING SmpDefaultLibPath;

    DPRINT("SMLIB: %s(%p, '%wZ') called\n",
           __FUNCTION__, SmApiPort, Program);

    /* Parameters validation */
    if (!SmApiPort)
        return STATUS_INVALID_PARAMETER_1;
    if (!Program)
        return STATUS_INVALID_PARAMETER_2;

    /* Create parameters for the target process, using the current environment */
    Status = RtlCreateProcessParameters(&ProcessParameters,
                                        FileName,
                                        /* SmpDefaultLibPath.Length ?
                                        &SmpDefaultLibPath : */ NULL,
                                        Directory,
                                        CommandLine,
                                        SmpDefaultEnvironment,
                                        NULL,
                                        NULL,
                                        NULL,
                                        0);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("SMLIB: RtlCreateProcessParameters failed for %wZ - Status == %lx\n",
                FileName, Status);
        return Status;
    }

    /* Set the size field as required */
    ProcessInfo.Size = sizeof(ProcessInfo);

    /* Otherwise inherit the flag that was passed to SMSS itself */
    ProcessParameters->DebugFlags = SmpDebug;

    /* And always force NX for anything that SMSS launches */
    ProcessParameters->Flags |= RTL_USER_PROCESS_PARAMETERS_NX;

    /* Now create the process in suspended state */
    Status = RtlCreateUserProcess(FileName,
                                  OBJ_CASE_INSENSITIVE,
                                  ProcessParameters,
                                  NULL,
                                  NULL,
                                  NULL,
                                  FALSE,
                                  NULL,
                                  NULL,
                                  &ProcessInfo);
    RtlDestroyProcessParameters(ProcessParameters);
    if (!NT_SUCCESS(Status))
    {
        /* If we couldn't create it, fail back to the caller */
        DPRINT1("SMLIB: Failed load of %wZ - Status  == %lx\n",
                FileName, Status);
        return Status;
    }

    // /* Now duplicate the handle to this process */
    // Status = NtDuplicateObject(NtCurrentProcess(),
                               // ProcessInfo.ProcessHandle,
                               // NtCurrentProcess(),
                               // InitialCommandProcess,
                               // PROCESS_ALL_ACCESS,
                               // 0,
                               // 0);
    // if (!NT_SUCCESS(Status))
    // {
        // /* Kill it utterly if duplication failed */
        // DPRINT1("SMLIB: DupObject Failed. Status == %lx\n", Status);
        // NtTerminateProcess(ProcessInfo.ProcessHandle, Status);
        // NtResumeThread(ProcessInfo.ThreadHandle, NULL);
        // NtClose(ProcessInfo.ThreadHandle);
        // NtClose(ProcessInfo.ProcessHandle);
        // return Status;
    // }

    /* Call SM and wait for a reply */
    Status = SmExecPgm(SmApiPort, &ProcessInfo, TRUE);

    NtClose(ProcessInfo.ThreadHandle);
    NtClose(ProcessInfo.ProcessHandle);

    // if (ProcessInformation)
        // *ProcessInformation = ProcessInfo;

    DPRINT("SMLIB: %s returned (Status=0x%08lx)\n", __FUNCTION__, Status);
    return Status;
}

/**
 * @brief
 * Reads from the registry key
 * \Registry\SYSTEM\CurrentControlSet\Control\Session Manager\SubSystems
 * the value specified by Name.
 *
 * @param[in]   Name
 * Name of the program to run, that is a value's name in
 * the SM registry key "SubSystems".
 *
 * @param[out]   Data
 * What the registry gave back for Name.
 *
 * @param[in,out]   DataLength
 * How much Data the registry returns.
 *
 * @param[out]   DataType
 * Optional pointer to a variable that receives the type of data
 * stored in the specified value.
 *
 * @param[in]   Environment
 * Optional environment to be used to possibly expand Data before
 * returning it back; if set to NULL, no expansion will be performed.
 *
 * @return
 * Success status if the specified subsystem existed and its information
 * has been retrieved successfully; otherwise a failure status code.
 **/
NTSTATUS
NTAPI
SmLookupSubsystem(
    _In_ PWSTR Name,
    _Out_ PWSTR Data,
    _Inout_ PULONG DataLength,
    _Out_opt_ PULONG DataType,
    _In_opt_ PVOID Environment)
{
    NTSTATUS Status;
    UNICODE_STRING usKeyName;
    OBJECT_ATTRIBUTES Oa;
    HANDLE hKey = NULL;

    UNICODE_STRING usValueName;
    PWCHAR KeyValueInformation = NULL;
    ULONG  KeyValueInformationLength = 1024;
    ULONG  ResultLength = 0;
    PKEY_VALUE_PARTIAL_INFORMATION kvpi;

    DPRINT("SMLIB: %s(Name='%S') called\n", __FUNCTION__, Name);

    /*
     * Prepare the key name to scan and
     * related object attributes.
     */
    RtlInitUnicodeString(&usKeyName,
        L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\SubSystems");

    InitializeObjectAttributes(&Oa,
                               &usKeyName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
    /*
     * Open the key. This MUST NOT fail, if the
     * request is for a legitimate subsystem.
     */
    Status = NtOpenKey(&hKey,
                       MAXIMUM_ALLOWED,
                       &Oa);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("%s: NtOpenKey failed (Status=0x%08lx)\n", __FUNCTION__, Status);
        return Status;
    }

    KeyValueInformation = RtlAllocateHeap(RtlGetProcessHeap(),
                                          0,
                                          KeyValueInformationLength);
    if (!KeyValueInformation)
    {
        NtClose(hKey);
        return STATUS_NO_MEMORY;
    }

    kvpi = (PKEY_VALUE_PARTIAL_INFORMATION)KeyValueInformation;
    RtlInitUnicodeString(&usValueName, Name);
    Status = NtQueryValueKey(hKey,
                             &usValueName,
                             KeyValuePartialInformation,
                             KeyValueInformation,
                             KeyValueInformationLength,
                             &ResultLength);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("%s: NtQueryValueKey failed (Status=0x%08lx)\n", __FUNCTION__, Status);

        RtlFreeHeap(RtlGetProcessHeap(), 0, KeyValueInformation);
        NtClose(hKey);

        return Status;
    }

    DPRINT("kvpi.TitleIndex = %lu\n", kvpi->TitleIndex);
    DPRINT("kvpi.Type       = %lu\n", kvpi->Type);
    DPRINT("kvpi.DataLength = %lu\n", kvpi->DataLength);

    if (Data && DataLength)
    {
        if (DataType)
            *DataType = kvpi->Type;

        if (Environment && (kvpi->Type == REG_EXPAND_SZ))
        {
            UNICODE_STRING Source;
            UNICODE_STRING Destination;
            PWCHAR DestinationBuffer = NULL;
            ULONG  Length;

            DPRINT("SMLIB: %s: value will be expanded\n", __FUNCTION__);

            Length = 2 * KeyValueInformationLength;
            DestinationBuffer = RtlAllocateHeap(RtlGetProcessHeap(),
                                                0,
                                                Length);
            if (!DestinationBuffer)
            {
                Status = STATUS_NO_MEMORY;
            }
            else
            {
                Source.Length = (USHORT)kvpi->DataLength;
                Source.MaximumLength = Source.Length;
                Source.Buffer = (PWCHAR)&kvpi->Data;

                RtlInitEmptyUnicodeString(&Destination,
                                          DestinationBuffer,
                                          (USHORT)Length);

                Length = 0;
                Status = RtlExpandEnvironmentStrings_U(Environment,
                                                       &Source,
                                                       &Destination,
                                                       &Length);
                if (NT_SUCCESS(Status))
                {
                    *DataLength = min(*DataLength, Destination.Length);
                    RtlCopyMemory(Data, Destination.Buffer, *DataLength);
                }
                RtlFreeHeap(RtlGetProcessHeap(), 0, DestinationBuffer);
            }
        }
        else
        {
            DPRINT("SMLIB: %s: value won't be expanded\n", __FUNCTION__);
            *DataLength = min(*DataLength, kvpi->DataLength);
            RtlCopyMemory(Data, &kvpi->Data, *DataLength);
        }
    }
    else
    {
        DPRINT1("SMLIB: %s: Data or DataLength is NULL!\n", __FUNCTION__);
        Status = STATUS_INVALID_PARAMETER;
    }

    RtlFreeHeap(RtlGetProcessHeap(), 0, KeyValueInformation);
    NtClose(hKey);

    return Status;
}

/**
 * @brief
 * Retrieves information about subsystems registered with the SM.
 *
 * @param[in]   SmApiPort
 * Port handle returned by SmConnectToSm().
 *
 * @param[in]   SmInformationClass
 * An SM information class ID:
 * - SmBasicInformation:
 *   The number and list of registered subsystems. Data is returned
 *   in a SM_BASIC_INFORMATION structure.
 * - SmSubSystemInformation:
 *   Information about a particular registered subsystem. Data is
 *   returned in a SM_SUBSYSTEM_INFORMATION structure.
 *
 * @param[in,out]   Data
 * Pointer to storage for the information to request. Either a
 * SM_BASIC_INFORMATION or a SM_SUBSYSTEM_INFORMATION, depending
 * on the information class.
 *
 * @param[in]   DataLength
 * Length in bytes of the Data buffer; it must be set and must
 * match the SmInformationClass information size.
 *
 * @param[in,out]   ReturnedDataLength
 * Optional pointer to storage to receive the size of the returned data.
 *
 * @return
 * STATUS_SUCCESS when the information asked for has been retrieved.
 * STATUS_INVALID_PARAMETER_2 if an invalid information class has been provided.
 * STATUS_INFO_LENGTH_MISMATCH in case either DataLength was set to 0
 *   or to a value that does not match what the SmInformationClass requires.
 * Otherwise, a success status as handed by the SM reply, or a failure
 * status code.
 *
 * @remark
 * This API is ReactOS-specific and not in NT.
 */
NTSTATUS
NTAPI
SmQueryInformation(
    _In_ HANDLE SmApiPort,
    _In_ SM_INFORMATION_CLASS SmInformationClass,
    _Inout_ PVOID Data,
    _In_ ULONG DataLength,
    _Inout_opt_ PULONG ReturnedDataLength)
{
#if defined(__REACTOS__) && DBG
    NTSTATUS Status;
    SM_API_MSG SmApiMsg = {0};
    PSM_QUERYINFO_MSG QueryInfo = &SmApiMsg.u.QueryInfo;

    /* Marshal data in the port message */
    switch (SmInformationClass)
    {
        case SmBasicInformation:
            if (DataLength != sizeof(SM_BASIC_INFORMATION))
            {
                return STATUS_INFO_LENGTH_MISMATCH;
            }
            QueryInfo->SmInformationClass = SmBasicInformation;
            QueryInfo->DataLength = DataLength;
            QueryInfo->BasicInformation.SubSystemCount = 0;
            break;

        case SmSubSystemInformation:
            if (DataLength != sizeof(SM_SUBSYSTEM_INFORMATION))
            {
                return STATUS_INFO_LENGTH_MISMATCH;
            }
            QueryInfo->SmInformationClass = SmSubSystemInformation;
            QueryInfo->DataLength = DataLength;
            QueryInfo->SubSystemInformation.SubSystemId =
                ((PSM_SUBSYSTEM_INFORMATION)Data)->SubSystemId;
            break;

        default:
            return STATUS_INVALID_PARAMETER_2;
    }

    /* SM API to invoke */
    SmApiMsg.ApiNumber = SM_API_QUERY_INFORMATION;

    /* NOTE: Repurpose the DataLength variable */
    DataLength = sizeof(SM_QUERYINFO_MSG);

    /* Fill out the Port Message Header */
    // SmApiMsg.h.u2.s2.Type = LPC_NEW_MESSAGE;
    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("SMLIB: %s: NtRequestWaitReplyPort failed, Status: 0x%08lx\n",
                __FUNCTION__, Status);
        return Status;
    }

    /* Unmarshal data */
    RtlCopyMemory(Data,
                  &QueryInfo->BasicInformation,
                  QueryInfo->DataLength);

    /* Use caller provided storage to store data size */
    if (ReturnedDataLength)
        *ReturnedDataLength = QueryInfo->DataLength;

    /* Return the real status */
    return SmApiMsg.ReturnValue;
#else
    return STATUS_NOT_IMPLEMENTED;
#endif /* defined(__REACTOS__) && DBG */
}

/* EOF */