smutils.c File Reference

#include "precomp.h"
#include <windef.h>
#include <winreg.h>
#include <ndk/cmfuncs.h>
#include <sm/helper.h>
#include <debug.h>

Include dependency graph for smutils.c:

Go to the source code of this file.

Macros
#define	WIN32_NO_STATUS
#define	_INC_WINDOWS
#define	COM_NO_WINDOWS_H
#define	NTOS_MODE_USER
#define	NDEBUG

Functions
NTSTATUS NTAPI	SmExecuteProgram (_In_ HANDLE SmApiPort, _In_ PUNICODE_STRING Program)
	This function is used to make the SM start an external process under an already-loaded environment subsystem server.
NTSTATUS NTAPI	SmLookupSubsystem (_In_ PWSTR Name, _Out_ PWSTR Data, _Inout_ PULONG DataLength, _Out_opt_ PULONG DataType, _In_opt_ PVOID Environment)
	Reads from the registry key \Registry\SYSTEM\CurrentControlSet\Control\Session Manager\SubSystems the value specified by Name.
NTSTATUS NTAPI	SmQueryInformation (_In_ HANDLE SmApiPort, _In_ SM_INFORMATION_CLASS SmInformationClass, _Inout_ PVOID Data, _In_ ULONG DataLength, _Inout_opt_ PULONG ReturnedDataLength)
	Retrieves information about subsystems registered with the SM.

Variables
BOOLEAN	SmpDebug = FALSE

Macro Definition Documentation

_INC_WINDOWS

#define _INC_WINDOWS

Definition at line 12 of file smutils.c.

COM_NO_WINDOWS_H

#define COM_NO_WINDOWS_H

Definition at line 13 of file smutils.c.

NDEBUG

#define NDEBUG

Definition at line 22 of file smutils.c.

NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 17 of file smutils.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 11 of file smutils.c.

Function Documentation

SmExecuteProgram()

NTSTATUS NTAPI SmExecuteProgram	(	_In_ HANDLE	SmApiPort,
		_In_ PUNICODE_STRING	Program
	)

This function is used to make the SM start an external process under an already-loaded environment subsystem server.

Parameters

[in]	SmApiPort	Port handle returned by SmConnectToSm().
[in]	Program	Fully qualified NT name of the executable to load.

Returns

Success status as handed by the SM reply; otherwise a failure status code.

Remarks

Adapted from SMSS' SmpExecuteInitialCommand() and SmpExecuteImage().

Definition at line 51 of file smutils.c.

{
    // 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;
}

SmLookupSubsystem()

NTSTATUS NTAPI SmLookupSubsystem	(	_In_ PWSTR	Name,
		_Out_ PWSTR	Data,
		_Inout_ PULONG	DataLength,
		_Out_opt_ PULONG	DataType,
		_In_opt_ PVOID	Environment
	)

Reads from the registry key \Registry\SYSTEM\CurrentControlSet\Control\Session Manager\SubSystems the value specified by Name.

Parameters

[in]	Name	Name of the program to run, that is a value's name in the SM registry key "SubSystems".
[out]	Data	What the registry gave back for Name.
[in,out]	DataLength	How much Data the registry returns.
[out]	DataType	Optional pointer to a variable that receives the type of data stored in the specified value.
[in]	Environment	Optional environment to be used to possibly expand Data before returning it back; if set to NULL, no expansion will be performed.

Returns

Success status if the specified subsystem existed and its information has been retrieved successfully; otherwise a failure status code.

Definition at line 188 of file smutils.c.

{
    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;
}

SmQueryInformation()

NTSTATUS NTAPI SmQueryInformation	(	_In_ HANDLE	SmApiPort,
		_In_ SM_INFORMATION_CLASS	SmInformationClass,
		_Inout_ PVOID	Data,
		_In_ ULONG	DataLength,
		_Inout_opt_ PULONG	ReturnedDataLength
	)

Retrieves information about subsystems registered with the SM.

Parameters

[in]	SmApiPort	Port handle returned by SmConnectToSm().
[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.
[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.
[in]	DataLength	Length in bytes of the Data buffer; it must be set and must match the SmInformationClass information size.
[in,out]	ReturnedDataLength	Optional pointer to storage to receive the size of the returned data.

Returns

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.

Remarks

This API is ReactOS-specific and not in NT.

Definition at line 369 of file smutils.c.

{
#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 */
}

Variable Documentation

SmpDebug

BOOLEAN SmpDebug = FALSE

Definition at line 28 of file smutils.c.

Referenced by SmExecuteProgram().