#include "sacdrv.h"
#include <ndk/rtlfuncs.h>

Include dependency graph for util.c:

Functions
BOOLEAN NTAPI	SacTranslateUtf8ToUnicode (IN CHAR Utf8Char, IN PCHAR Utf8Buffer, OUT PWCHAR Utf8Value)

BOOLEAN NTAPI	SacTranslateUnicodeToUtf8 (IN PWCHAR SourceBuffer, IN ULONG SourceBufferLength, OUT PCHAR DestinationBuffer, IN ULONG DestinationBufferSize, OUT PULONG UTF8Count, OUT PULONG ProcessedCount)

PWCHAR NTAPI	GetMessage (IN ULONG MessageIndex)

NTSTATUS NTAPI	UTF8EncodeAndSend (IN PWCHAR String)

VOID NTAPI	SacFormatMessage (IN PWCHAR FormattedString, IN PWCHAR MessageString, IN ULONG MessageSize)

NTSTATUS NTAPI	PreloadGlobalMessageTable (IN PVOID ImageBase)

NTSTATUS NTAPI	TearDownGlobalMessageTable (VOID)

NTSTATUS NTAPI	GetRegistryValueBuffer (IN PCWSTR KeyName, IN PWCHAR ValueName, IN PKEY_VALUE_PARTIAL_INFORMATION *Buffer)

NTSTATUS NTAPI	SetRegistryValue (IN PCWSTR KeyName, IN PWCHAR ValueName, IN ULONG Type, IN PVOID Data, IN ULONG DataSize)

NTSTATUS NTAPI	CopyRegistryValueData (IN PVOID *Buffer, IN PKEY_VALUE_PARTIAL_INFORMATION PartialInfo)

NTSTATUS NTAPI	TranslateMachineInformationXML (IN PWCHAR *Buffer, IN PWCHAR ExtraData)

VOID NTAPI	InitializeMachineInformation (VOID)

NTSTATUS NTAPI	GetCommandConsoleLaunchingPermission (OUT PBOOLEAN Permission)

NTSTATUS NTAPI	ImposeSacCmdServiceStartTypePolicy (VOID)

VOID NTAPI	InitializeCmdEventInfo (VOID)

NTSTATUS NTAPI	RegisterBlueScreenMachineInformation (VOID)

VOID NTAPI	FreeMachineInformation (VOID)

BOOLEAN NTAPI	VerifyEventWaitable (IN HANDLE Handle, OUT PVOID WaitObject, OUT PVOID ActualWaitObject)

NTSTATUS NTAPI	SerialBufferGetChar (OUT PCHAR Char)

ULONG NTAPI	GetMessageLineCount (IN ULONG MessageIndex)

ULONG	ConvertAnsiToUnicode (IN PWCHAR pwch, IN PCHAR pch, IN ULONG length)

BOOLEAN	IsCmdEventRegistrationProcess (IN PFILE_OBJECT FileObject)

NTSTATUS	InvokeUserModeService (VOID)

NTSTATUS	TranslateMachineInformationText (IN PWCHAR Buffer)

NTSTATUS	CopyAndInsertStringAtInterval (IN PWCHAR SourceStr, IN ULONG Interval, IN PWCHAR InsertStr, OUT PWCHAR pDestStr)

NTSTATUS	RegisterSacCmdEvent (IN PVOID Object, IN PKEVENT SetupCmdEvent[])

NTSTATUS	UnregisterSacCmdEvent (IN PFILE_OBJECT FileObject)

Function Documentation

◆ ConvertAnsiToUnicode()

ULONG ConvertAnsiToUnicode	(	IN PWCHAR	pwch,
		IN PCHAR	pch,
		IN ULONG	length
	)

Definition at line 1251 of file util.c.

{
    return STATUS_NOT_IMPLEMENTED;
}

◆ CopyAndInsertStringAtInterval()

NTSTATUS CopyAndInsertStringAtInterval	(	IN PWCHAR	SourceStr,
		IN ULONG	Interval,
		IN PWCHAR	InsertStr,
		OUT PWCHAR	pDestStr
	)

Definition at line 1284 of file util.c.

{
    return STATUS_NOT_IMPLEMENTED;
}

◆ CopyRegistryValueData()

NTSTATUS NTAPI CopyRegistryValueData	(	IN PVOID *	Buffer,
		IN PKEY_VALUE_PARTIAL_INFORMATION	PartialInfo
	)

Definition at line 514 of file util.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    CHECK_PARAMETER1(Buffer);
    CHECK_PARAMETER2(PartialInfo);
 
    /* Allocate space for registry data */
    *Buffer = SacAllocatePool(PartialInfo->DataLength, GLOBAL_BLOCK_TAG);
    if (*Buffer)
    {
        /* Copy the data into the buffer */
        RtlCopyMemory(*Buffer, PartialInfo->Data, PartialInfo->DataLength);
    }
    else
    {
        /* Set the correct error code */
        SAC_DBG(SAC_DBG_UTIL, "SAC CopyRegistryValueBuffer: Failed ALLOCATE.\n");
        Status = STATUS_NO_MEMORY;
    }
 
    /* Return the result */
    return Status;
}

Referenced by ImposeSacCmdServiceStartTypePolicy(), and InitializeMachineInformation().

◆ FreeMachineInformation()

VOID NTAPI FreeMachineInformation ( VOID )

Definition at line 1156 of file util.c.

{
    ASSERT(MachineInformation);
 
    /* Free every cached string of machine information */
    if (MachineInformation->MachineName) SacFreePool(MachineInformation);
    if (MachineInformation->MachineGuid) SacFreePool(MachineInformation->MachineGuid);
    if (MachineInformation->ProcessorArchitecture) SacFreePool(MachineInformation->ProcessorArchitecture);
    if (MachineInformation->MajorVersion) SacFreePool(MachineInformation->MajorVersion);
    if (MachineInformation->BuildNumber) SacFreePool(MachineInformation->BuildNumber);
    if (MachineInformation->ProductType) SacFreePool(MachineInformation->ProductType);
    if (MachineInformation->ServicePack) SacFreePool(MachineInformation->ServicePack);
}

Referenced by FreeGlobalData().

◆ GetCommandConsoleLaunchingPermission()

NTSTATUS NTAPI GetCommandConsoleLaunchingPermission ( OUT PBOOLEAN Permission )

Definition at line 981 of file util.c.

{
    NTSTATUS Status;
    PKEY_VALUE_PARTIAL_INFORMATION Dummy;
 
    /* Assume success and read the key */
    *Permission = TRUE;
    Status = GetRegistryValueBuffer(L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\sacdrv",
                                    L"DisableCmdSessions",
                                    &Dummy);
    if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
    {
        /* The default is success */
        Status = STATUS_SUCCESS;
    }
    else
    {
        /* Only if the key is present and set, do we disable permission */
        if (NT_SUCCESS(Status)) *Permission = FALSE;
    }
 
    /* Return status */
    return Status;
}

Referenced by InitializeGlobalData().

◆ GetMessage()

PWCHAR NTAPI GetMessage ( IN ULONG MessageIndex )

Definition at line 139 of file util.c.

{
    PSAC_MESSAGE_ENTRY MessageEntry;
    ULONG i;
    PWCHAR MessageData = NULL;
 
    /* Loop all cached messages */
    for (i = 0; i < GlobalMessageTableCount; i++)
    {
        /* Check if this one matches the index */
        MessageEntry = &GlobalMessageTable[i];
        if (MessageEntry->Index == MessageIndex)
        {
            /* It does, return the buffer */
            MessageData = MessageEntry->Buffer;
            break;
        }
    }
 
    /* We should always find it */
    if (!MessageData) ASSERT(FALSE);
    return MessageData;
}

◆ GetMessageLineCount()

ULONG NTAPI GetMessageLineCount ( IN ULONG MessageIndex )

Definition at line 1233 of file util.c.

{
    ULONG LineCount = 0;
    PWCHAR Buffer;
 
    /* Get the message buffer */
    Buffer = GetMessage(MessageIndex);
    if (Buffer)
    {
        /* Scan it looking for new lines, and increment the count each time */
        while (*Buffer) if (*Buffer++ == L'\n') ++LineCount;
    }
 
    /* Return the line count */
    return LineCount;
}

Referenced by PrintHelpMessage().

◆ GetRegistryValueBuffer()

NTSTATUS NTAPI GetRegistryValueBuffer	(	IN PCWSTR	KeyName,
		IN PWCHAR	ValueName,
		IN PKEY_VALUE_PARTIAL_INFORMATION *	Buffer
	)

Definition at line 392 of file util.c.

{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING DestinationString;
    HANDLE Handle;
    ULONG ResultLength = 0;
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC GetRegistryValueBuffer: Entering.\n");
    CHECK_PARAMETER1(KeyName);
    CHECK_PARAMETER2(ValueName);
 
    /* Open the specified key */
    RtlInitUnicodeString(&DestinationString, KeyName);
    InitializeObjectAttributes(&ObjectAttributes,
                               &DestinationString,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
    Status = ZwOpenKey(&Handle,
                       KEY_WRITE | SYNCHRONIZE | KEY_READ,
                       &ObjectAttributes);
    if (!NT_SUCCESS(Status))
    {
        /* Bail out on failure */
        SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC GetRegistryValueBuffer: failed ZwOpenKey: %X.\n", Status);
        return Status;
    }
 
    /* Query the size of the key */
    RtlInitUnicodeString(&DestinationString, ValueName);
    Status = ZwQueryValueKey(Handle,
                             &DestinationString,
                             KeyValuePartialInformation,
                             NULL,
                             0,
                             &ResultLength);
    if (!ResultLength)
        goto Quit;
 
    /* Allocate the buffer for the partial info structure and our integer data */
    ResultLength += sizeof(ULONG);
    *Buffer = SacAllocatePool(ResultLength, GLOBAL_BLOCK_TAG);
    if (!*Buffer)
    {
        SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC GetRegistryValueBuffer: failed allocation\n");
        goto Quit;
    }
 
    /* Now read the data */
    Status = ZwQueryValueKey(Handle,
                             &DestinationString,
                             KeyValuePartialInformation,
                             *Buffer,
                             ResultLength,
                             &ResultLength);
    if (!NT_SUCCESS(Status))
    {
        /* Free the buffer if we couldn't read the data */
        SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC GetRegistryValueBuffer: failed ZwQueryValueKey: %X.\n", Status);
        SacFreePool(*Buffer);
    }
 
Quit:
    /* Close the handle and exit */
    ZwClose(Handle);
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC GetRegistryValueBuffer: Exiting.\n");
    return Status;
}

Referenced by GetCommandConsoleLaunchingPermission(), ImposeSacCmdServiceStartTypePolicy(), and InitializeMachineInformation().

◆ ImposeSacCmdServiceStartTypePolicy()

NTSTATUS NTAPI ImposeSacCmdServiceStartTypePolicy ( VOID )

Definition at line 1008 of file util.c.

{
    NTSTATUS Status;
    PKEY_VALUE_PARTIAL_INFORMATION Buffer = NULL;
    PULONG Data;
 
    /* Read the service start type*/
    Status = GetRegistryValueBuffer(L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\sacsvr",
                                    L"Start",
                                    &Buffer);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* If there's no start type, fail, as this is unusual */
    if (!Buffer) return STATUS_UNSUCCESSFUL;
 
    /* Read the value */
    Status = CopyRegistryValueData((PVOID*)&Data, Buffer);
    SacFreePool(Buffer);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Check what the current start type is */
    switch (*Data)
    {
        /* It's boot, system, or disabled */
        case 1:
        case 2:
        case 4:
            /* Leave it as is */
            return Status;
 
        case 3:
 
            /* It's set to automatic, set it to system instead */
            *Data = 2;
            Status = SetRegistryValue(L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\sacsvr",
                                      L"Start",
                                      REG_DWORD,
                                      Data,
                                      sizeof(ULONG));
            if (!NT_SUCCESS(Status))
            {
                SAC_DBG(SAC_DBG_INIT, "SAC ImposeSacCmdServiceStartTypePolicy: Failed SetRegistryValue: %X\n", Status);
            }
            break;
 
        default:
            ASSERT(FALSE);
    }
 
    return Status;
}

Referenced by InitializeGlobalData().

◆ InitializeCmdEventInfo()

VOID NTAPI InitializeCmdEventInfo ( VOID )

Definition at line 1062 of file util.c.

{
    /* Check if we were already initialized */
    if (HaveUserModeServiceCmdEventInfo)
    {
        /* Full state expected */
        ASSERT(RequestSacCmdEventObjectBody);
        ASSERT(RequestSacCmdSuccessEventObjectBody);
        ASSERT(RequestSacCmdFailureEventObjectBody);
 
        /* Dereference each wait object in turn */
        if (RequestSacCmdEventObjectBody)
        {
            ObDereferenceObject(RequestSacCmdEventObjectBody);
        }
 
        if (RequestSacCmdSuccessEventObjectBody)
        {
            ObDereferenceObject(RequestSacCmdSuccessEventObjectBody);
        }
 
        if (RequestSacCmdFailureEventObjectBody)
        {
            ObDereferenceObject(RequestSacCmdFailureEventObjectBody);
        }
    }
 
    /* Claer everything */
    RequestSacCmdEventObjectBody = NULL;
    RequestSacCmdEventWaitObjectBody = NULL;
    RequestSacCmdSuccessEventObjectBody = NULL;
    RequestSacCmdSuccessEventWaitObjectBody = NULL;
    RequestSacCmdFailureEventObjectBody = NULL;
    RequestSacCmdFailureEventWaitObjectBody = NULL;
    ServiceProcessFileObject = NULL;
 
    /* Reset state */
    HaveUserModeServiceCmdEventInfo = FALSE;
}

Referenced by InitializeGlobalData().

◆ InitializeMachineInformation()

VOID NTAPI InitializeMachineInformation ( VOID )

Definition at line 692 of file util.c.

{
    NTSTATUS Status;
    PWCHAR GuidString, MajorVersion, ServicePack, BuildNumber, MessageBuffer;
    PWCHAR ProductType;
    ULONG SuiteTypeMessage;
    BOOLEAN SetupInProgress = FALSE;
    GUID SystemGuid;
    SIZE_T RealSize, Size, OutputSize;
    PKEY_VALUE_PARTIAL_INFORMATION PartialInfo;
    RTL_OSVERSIONINFOEXW VersionInformation;
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC Initialize Machine Information : Entering.\n");
 
    /* Don't do anything if we already queried this */
    if (MachineInformation)
    {
        SAC_DBG(SAC_DBG_MACHINE, "SAC Initialize Machine Information:: MachineInformationBuffer already initialized.\n");
        return;
    }
 
    /* Allocate the machine information */
    MachineInformation = SacAllocatePool(sizeof(*MachineInformation),
                                         GLOBAL_BLOCK_TAG);
    if (!MachineInformation)
    {
        goto Fail;
    }
 
    /* Zero it out for now */
    RtlZeroMemory(MachineInformation, sizeof(*MachineInformation));
 
    /* Query OS version */
    RtlZeroMemory(&VersionInformation, sizeof(VersionInformation));
    VersionInformation.dwOSVersionInfoSize = sizeof(VersionInformation);
    Status = RtlGetVersion((PRTL_OSVERSIONINFOW)&VersionInformation);
    if (!NT_SUCCESS(Status))
    {
        SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC InitializeMachineInformation: Exiting (2).\n");
        goto Fail;
    }
 
    /* Check if setup is in progress */
    Status = GetRegistryValueBuffer(L"\\Registry\\Machine\\System\\Setup",
                                    L"SystemSetupInProgress",
                                    &PartialInfo);
    if (NT_SUCCESS(Status))
    {
        /* The key is there, is the value set? */
        if (*(PULONG)PartialInfo->Data) SetupInProgress = TRUE;
        SacFreePool(PartialInfo);
        if (SetupInProgress)
        {
            /* Yes, so we'll use a special hostname to identify this */
            MessageBuffer = GetMessage(SAC_UNINITIALIZED_MSG);
            Size = wcslen(MessageBuffer);
            ASSERT(Size > 0);
            RealSize = Size * sizeof(WCHAR) + sizeof(UNICODE_NULL);
 
            /* Make room for it and copy it in there */
            MachineInformation->MachineName = SacAllocatePool(RealSize,
                                                              GLOBAL_BLOCK_TAG);
            if (MachineInformation->MachineName)
            {
                wcscpy(MachineInformation->MachineName, MessageBuffer);
            }
        }
    }
 
    /* If we are not in setup mode, or if we failed to check... */
    if (!SetupInProgress)
    {
        /* Query the computer name */
        Status = GetRegistryValueBuffer(L"\\Registry\\Machine\\System\\"
                                        L"CurrentControlSet\\Control\\"
                                        L"ComputerName\\ComputerName",
                                        L"ComputerName",
                                        &PartialInfo);
        if (!NT_SUCCESS(Status))
        {
            /* It's not critical, but we won't have it */
            SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC InitializeMachineInformation: Failed to get machine name.\n");
        }
        else
        {
            /* We have the name, copy it from the registry */
            Status = CopyRegistryValueData((PVOID*)&MachineInformation->
                                           MachineName,
                                           PartialInfo);
            SacFreePool(PartialInfo);
            if (!NT_SUCCESS(Status))
            {
                SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC InitializeMachineInformation: Exiting (20).\n");
                goto Fail;
            }
        }
    }
 
    /* Next step, try to get the machine GUID */
    RtlZeroMemory(&SystemGuid, sizeof(SystemGuid));
    OutputSize = sizeof(SystemGuid);
    Status = HeadlessDispatch(HeadlessCmdQueryGUID,
                              NULL,
                              0,
                              &SystemGuid,
                              &OutputSize);
    if (!NT_SUCCESS(Status))
    {
        SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC InitializeMachineInformation: Failed to get Machine GUID.\n");
    }
    else
    {
        /* We have it -- make room for it */
        GuidString = SacAllocatePool(0x50, GLOBAL_BLOCK_TAG);
        if (!GuidString)
        {
            SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC InitializeMachineInformation: Exiting (31).\n");
            goto Fail;
        }
 
        /* Build the string with the GUID in it, and save the ppointer to it */
        swprintf(GuidString,
                 L"%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
                 SystemGuid.Data1,
                 SystemGuid.Data2,
                 SystemGuid.Data3,
                 SystemGuid.Data4[0],
                 SystemGuid.Data4[1],
                 SystemGuid.Data4[2],
                 SystemGuid.Data4[3],
                 SystemGuid.Data4[4],
                 SystemGuid.Data4[5],
                 SystemGuid.Data4[6],
                 SystemGuid.Data4[7]);
        MachineInformation->MachineGuid = GuidString;
    }
 
    /* Next, query the processor architecture */
    Status = GetRegistryValueBuffer(L"\\Registry\\Machine\\System\\"
                                    L"CurrentControlSet\\Control\\"
                                    L"Session Manager\\Environment",
                                    L"PROCESSOR_ARCHITECTURE",
                                    &PartialInfo);
    if (!NT_SUCCESS(Status))
    {
        /* It's not critical, but we won't have it */
        SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC InitializeMachineInformation: Exiting (30).\n");
    }
    else
    {
        /* We have it! Copy the value from the registry */
        Status = CopyRegistryValueData((PVOID*)&MachineInformation->
                                       ProcessorArchitecture,
                                       PartialInfo);
        SacFreePool(PartialInfo);
        if (!NT_SUCCESS(Status))
        {
            SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC InitializeMachineInformation: Exiting (30).\n");
            goto Fail;
        }
    }
 
    /* Now allocate a buffer for the OS version number */
    MajorVersion = SacAllocatePool(0x18, GLOBAL_BLOCK_TAG);
    if (!MajorVersion)
    {
        SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC InitializeMachineInformation: Exiting (50).\n");
        goto Fail;
    }
 
    /* Build the buffer and set a pointer to it */
    swprintf(MajorVersion,
             L"%d.%d",
             VersionInformation.dwMajorVersion,
             VersionInformation.dwMinorVersion);
    MachineInformation->MajorVersion = MajorVersion;
 
    /* Now allocate a buffer for the OS build number */
    BuildNumber = SacAllocatePool(0xC, GLOBAL_BLOCK_TAG);
    if (!BuildNumber)
    {
        SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC InitializeMachineInformation: Exiting (60).\n");
        goto Fail;
    }
 
    /* Build the buffer and set a pointer to it */
    swprintf(BuildNumber, L"%d", VersionInformation.dwBuildNumber);
    MachineInformation->BuildNumber = BuildNumber;
 
    /* Now check what kind of SKU this is */
    if (ExVerifySuite(DataCenter))
    {
        SuiteTypeMessage = SAC_DATACENTER_SUITE_MSG;
    }
    else if (ExVerifySuite(EmbeddedNT))
    {
        SuiteTypeMessage = SAC_EMBEDDED_SUITE_MSG;
    }
    else if (ExVerifySuite(Enterprise))
    {
        SuiteTypeMessage = SAC_ENTERPRISE_SUITE_MSG;
    }
    else
    {
        /* Unknown or perhaps a client SKU */
        SuiteTypeMessage = SAC_NO_SUITE_MSG;
    }
 
    /* Get the string that corresponds to the SKU type */
    MessageBuffer = GetMessage(SuiteTypeMessage);
    if (!MessageBuffer)
    {
        /* We won't have it, but this isn't critical */
        SAC_DBG(SAC_DBG_INIT, "SAC InitializeMachineInformation: Failed to get product type.\n");
    }
    else
    {
        /* Calculate the size we need to hold the string */
        Size = wcslen(MessageBuffer);
        ASSERT(Size > 0);
        RealSize = Size * sizeof(WCHAR) + sizeof(UNICODE_NULL);
 
        /* Allocate a buffer for it */
        ProductType = SacAllocatePool(RealSize, GLOBAL_BLOCK_TAG);
        if (!ProductType)
        {
            SAC_DBG(SAC_DBG_INIT, "SAC InitializeMachineInformation: Failed product type memory allocation.\n");
            goto Fail;
        }
 
        /* Copy the string and set the pointer */
        RtlCopyMemory(ProductType, MessageBuffer, RealSize);
        MachineInformation->ProductType = ProductType;
    }
 
    /* Check if this is a SP version or RTM version */
    if (VersionInformation.wServicePackMajor)
    {
        /* This is a service pack, allocate a buffer for the version */
        ServicePack = SacAllocatePool(0x18, GLOBAL_BLOCK_TAG);
        if (ServicePack)
        {
            /* Build the buffer and set a pointer to it */
            swprintf(ServicePack,
                     L"%d.%d",
                     VersionInformation.wServicePackMajor,
                     VersionInformation.wServicePackMinor);
            MachineInformation->ServicePack = ServicePack;
 
            /* We've collected all the machine info and are done! */
            return;
        }
 
        /* This is the failure path */
        SAC_DBG(SAC_DBG_INIT, "SAC InitializeMachineInformation: Failed service pack memory allocation.\n");
    }
    else
    {
        /* Get a generic string that indicates there's no service pack */
        MessageBuffer = GetMessage(SAC_NO_DATA_MSG);
        Size = wcslen(MessageBuffer);
        ASSERT(Size > 0);
        RealSize = Size * sizeof(WCHAR) + sizeof(UNICODE_NULL);
 
        /* Allocate memory for the "no service pack" string */
        ServicePack = SacAllocatePool(RealSize, GLOBAL_BLOCK_TAG);
        if (ServicePack)
        {
            /* Copy the buffer and set a pointer to it */
            RtlCopyMemory(ServicePack, MessageBuffer, RealSize);
            MachineInformation->ServicePack = ServicePack;
 
            /* We've collected all the machine info and are done! */
            return;
        }
 
        SAC_DBG(SAC_DBG_INIT, "SAC InitializeMachineInformation: Failed service pack memory allocation.\n");
    }
 
Fail:
    /* In the failure path, always cleanup the machine information buffer */
    if (MachineInformation)
    {
        SacFreePool(MachineInformation);
    }
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC Initialize Machine Information : Exiting with error.\n");
}

Referenced by InitializeGlobalData().

◆ InvokeUserModeService()

NTSTATUS InvokeUserModeService ( VOID )

Definition at line 1269 of file util.c.

{
    return STATUS_NOT_IMPLEMENTED;
}

◆ IsCmdEventRegistrationProcess()

BOOLEAN IsCmdEventRegistrationProcess ( IN PFILE_OBJECT FileObject )

Definition at line 1261 of file util.c.

{
    return FALSE;
}

◆ PreloadGlobalMessageTable()

NTSTATUS NTAPI PreloadGlobalMessageTable ( IN PVOID ImageBase )

Definition at line 280 of file util.c.

{
    NTSTATUS Status, Status2;
    ULONG MessageId, TotalLength, TextSize, i;
    PWCHAR StringBuffer;
    PMESSAGE_RESOURCE_ENTRY MessageEntry;
    PAGED_CODE();
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC PreloadGlobalMessageTable: Entering.\n");
 
    /* Nothing to do if we already have a table */
    Status = STATUS_SUCCESS;
    if (GlobalMessageTable) goto Exit;
 
    /* Loop through up to 200 messages */
    TotalLength = 0;
    for (MessageId = 1; MessageId != SAC_MAX_MESSAGES; MessageId++)
    {
        /* Find this message ID in the string table*/
        Status2 = RtlFindMessage(ImageBase,
                                 11,
                                 LANG_NEUTRAL,
                                 MessageId,
                                 &MessageEntry);
        if (NT_SUCCESS(Status2))
        {
            /* Make sure it's Unicode */
            ASSERT(MessageEntry->Flags & MESSAGE_RESOURCE_UNICODE);
 
            /* Remove the space taken up by the OS header, and add our own */
            TotalLength += MessageEntry->Length -
                           FIELD_OFFSET(MESSAGE_RESOURCE_ENTRY, Text) +
                           sizeof(SAC_MESSAGE_ENTRY);
 
            /* One more in the table */
            GlobalMessageTableCount++;
        }
    }
 
    /* We should've found at least one message... */
    if (!TotalLength)
    {
        /* Bail out otherwise */
        SAC_DBG(SAC_DBG_INIT, "SAC PreloadGlobalMessageTable: No Messages.\n");
        Status = STATUS_INVALID_PARAMETER;
        goto Exit;
    }
 
    /* Allocate space for the buffers and headers */
    GlobalMessageTable = SacAllocatePool(TotalLength, GLOBAL_BLOCK_TAG);
    if (!GlobalMessageTable)
    {
        /* Bail out if we couldn't allocate it */
        Status = STATUS_NO_MEMORY;
        goto Exit;
    }
 
    /* All the buffers are going to be at the end of the table */
    StringBuffer = (PWCHAR)(&GlobalMessageTable[GlobalMessageTableCount]);
 
    /* Now loop over our entries again */
    for (i = 0, MessageId = 1; MessageId != SAC_MAX_MESSAGES; MessageId++)
    {
        /* Make sure the message is still there...! */
        Status2 = RtlFindMessage(ImageBase,
                                 11,
                                 LANG_NEUTRAL,
                                 MessageId,
                                 &MessageEntry);
        if (NT_SUCCESS(Status2))
        {
            /* Write the entry in the message table*/
            GlobalMessageTable[i].Index = MessageId;
            GlobalMessageTable[i].Buffer = StringBuffer;
 
            /* The structure includes the size of the header, elide it */
            TextSize = MessageEntry->Length -
                       FIELD_OFFSET(MESSAGE_RESOURCE_ENTRY, Text);
 
            /* Format the message into the entry. It should be same or smaller */
            SacFormatMessage(StringBuffer, (PWCHAR)MessageEntry->Text, TextSize);
            ASSERT((ULONG)(wcslen(StringBuffer)*sizeof(WCHAR)) <= TextSize);
 
            /* Move to the next buffer space */
            StringBuffer += (TextSize / sizeof(WCHAR));
 
            /* Move to the next entry, make sure the status is full success */
            i++;
            Status = STATUS_SUCCESS;
        }
    }
 
Exit:
    /* All done, return the status code */
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC TearDownGlobalMessageTable: Exiting with status 0x%0x\n", Status);
    return Status;
}

Referenced by InitializeGlobalData().

◆ RegisterBlueScreenMachineInformation()

NTSTATUS NTAPI RegisterBlueScreenMachineInformation ( VOID )

Definition at line 1104 of file util.c.

{
    PWCHAR XmlBuffer;
    PHEADLESS_CMD_SET_BLUE_SCREEN_DATA BsBuffer;
    SIZE_T Length, HeaderLength, TotalLength;
    NTSTATUS Status;
    ULONG i;
 
    /* Create the XML buffer and make sure it's OK */
    Status = TranslateMachineInformationXML(&XmlBuffer, NULL);
    CHECK_PARAMETER_WITH_STATUS(NT_SUCCESS(Status), Status);
    CHECK_PARAMETER_WITH_STATUS(XmlBuffer, STATUS_UNSUCCESSFUL);
 
    /* Compute the sizes and allocate a buffer for it */
    Length = wcslen(XmlBuffer);
    HeaderLength = strlen("MACHINEINFO");
    TotalLength = HeaderLength +
                  Length +
                  sizeof(*BsBuffer) +
                  2 * sizeof(ANSI_NULL);
    BsBuffer = SacAllocatePool(TotalLength, GLOBAL_BLOCK_TAG);
    CHECK_PARAMETER_WITH_STATUS(BsBuffer, STATUS_NO_MEMORY);
 
    /* Copy the XML property name */
    strcpy((PCHAR)BsBuffer->Data, "MACHINEINFO");
    BsBuffer->ValueIndex = HeaderLength + sizeof(ANSI_NULL);
 
    /* Copy the data and NULL-terminate it */
    for (i = 0; i < Length; i++)
    {
        BsBuffer->Data[BsBuffer->ValueIndex + i] = XmlBuffer[i];
    }
    BsBuffer->Data[BsBuffer->ValueIndex + i] = ANSI_NULL;
 
    /* Let the OS save the buffer for later */
    Status = HeadlessDispatch(HeadlessCmdSetBlueScreenData,
                              BsBuffer,
                              TotalLength,
                              NULL,
                              NULL);
 
    /* Failure or not, we don't need this anymore */
    SacFreePool(BsBuffer);
    SacFreePool(XmlBuffer);
 
    /* Return the result */
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC Initialize Machine Information: Exiting.\n");
    return Status;
}

Referenced by InitializeGlobalData().

◆ RegisterSacCmdEvent()

NTSTATUS RegisterSacCmdEvent	(	IN PVOID	Object,
		IN PKEVENT	SetupCmdEvent[]
	)

Definition at line 1295 of file util.c.

{
    return STATUS_NOT_IMPLEMENTED;
}

◆ SacFormatMessage()

VOID NTAPI SacFormatMessage	(	IN PWCHAR	FormattedString,
		IN PWCHAR	MessageString,
		IN ULONG	MessageSize
	)

Definition at line 202 of file util.c.

{
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC SacFormatMessage: Entering.\n");
 
    /* Check if any of the parameters are NULL or zero */
    if (!(MessageString) || !(FormattedString) || !(MessageSize))
    {
        SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC SacFormatMessage: Exiting with invalid parameters.\n");
        return;
    }
 
    /* Keep going as long as there's still characters */
    while ((MessageString[0]) && (MessageSize))
    {
        /* Is it a non-formatting character? */
        if (MessageString[0] != L'%')
        {
            /* Just write it back into the buffer and keep going */
            *FormattedString++ = MessageString[0];
            MessageString++;
        }
        else
        {
            /* Go over the format characters we recognize */
            switch (MessageString[1])
            {
                case L'0':
                    *FormattedString = UNICODE_NULL;
                    return;
 
                case L'%':
                    *FormattedString++ = L'%';
                    break;
 
                case L'\\':
                    *FormattedString++ = L'\r';
                    *FormattedString++ = L'\n';
                    break;
 
                case L'r':
                    *FormattedString++ = L'\r';
                    break;
 
                case L'b':
                    *FormattedString++ = L' ';
                    break;
 
                case L'.':
                    *FormattedString++ = L'.';
                    break;
 
                case L'!':
                    *FormattedString++ = L'!';
                    break;
 
                default:
                    /* Only move forward one character */
                    MessageString--;
                    break;
            }
 
            /* Move forward two characters */
            MessageString += 2;
        }
 
        /* Move to the next character*/
        MessageSize--;
    }
 
    /* All done */
    *FormattedString = UNICODE_NULL;
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC SacFormatMessage: Exiting.\n");
}

Referenced by PreloadGlobalMessageTable().

◆ SacTranslateUnicodeToUtf8()

BOOLEAN NTAPI SacTranslateUnicodeToUtf8	(	IN PWCHAR	SourceBuffer,
		IN ULONG	SourceBufferLength,
		OUT PCHAR	DestinationBuffer,
		IN ULONG	DestinationBufferSize,
		OUT PULONG	UTF8Count,
		OUT PULONG	ProcessedCount
	)

Definition at line 91 of file util.c.

{
    *UTF8Count = 0;
    *ProcessedCount = 0;
 
    while ((*SourceBuffer) &&
           (*UTF8Count < DestinationBufferSize) &&
           (*ProcessedCount < SourceBufferLength))
    {
        if (*SourceBuffer & 0xFF80)
        {
            if (*SourceBuffer & 0xF800)
            {
                if ((*UTF8Count + 3) >= DestinationBufferSize) break;
                DestinationBuffer[*UTF8Count] = ((*SourceBuffer >> 12) & 0xF) | 0xE0;
                ++*UTF8Count;
                DestinationBuffer[*UTF8Count] = ((*SourceBuffer >> 6) & 0x3F) | 0x80;
            }
            else
            {
                if ((*UTF8Count + 2) >= DestinationBufferSize) break;
                DestinationBuffer[*UTF8Count] = ((*SourceBuffer >> 6) & 31) | 0xC0;
            }
            ++*UTF8Count;
            DestinationBuffer[*UTF8Count] = (*SourceBuffer & 0x3F) | 0x80;
        }
        else
        {
            DestinationBuffer[*UTF8Count] = (*SourceBuffer & 0x7F);
        }
 
        ++*UTF8Count;
        ++*ProcessedCount;
        ++SourceBuffer;
    }
 
    ASSERT(*ProcessedCount <= SourceBufferLength);
    ASSERT(*UTF8Count <= DestinationBufferSize);
    return TRUE;
}

Referenced by UTF8EncodeAndSend(), VTUTF8ChannelOEcho(), and VTUTF8ChannelOFlush().

◆ SacTranslateUtf8ToUnicode()

BOOLEAN NTAPI SacTranslateUtf8ToUnicode	(	IN CHAR	Utf8Char,
		IN PCHAR	Utf8Buffer,
		OUT PWCHAR	Utf8Value
	)

Definition at line 41 of file util.c.

{
    ULONG i;
 
    /* Find out how many valid characters we have in the buffer */
    i = 0;
    while (Utf8Buffer[i++] && (i < 3));
 
    /* If we have at least 3, shift everything by a byte */
    if (i >= 3)
    {
        /* The last input character goes at the end */
        Utf8Buffer[0] = Utf8Buffer[1];
        Utf8Buffer[1] = Utf8Buffer[2];
        Utf8Buffer[2] = Utf8Char;
    }
    else
    {
        /* We don't have more than 3 characters, place the input at the index */
        Utf8Buffer[i] = Utf8Char;
    }
 
    /* Print to debugger */
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "SacTranslateUtf8ToUnicode - About to decode the UTF8 buffer.\n");
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "                                  UTF8[0]: 0x%02lx UTF8[1]: 0x%02lx UTF8[2]: 0x%02lx\n",
            Utf8Buffer[0],
            Utf8Buffer[1],
            Utf8Buffer[2]);
 
    /* Is this a simple ANSI character? */
    if (!(Utf8Char & 0x80))
    {
        /* Return it as Unicode, nothing left to do */
        SAC_DBG(SAC_DBG_ENTRY_EXIT, "SACDRV: SacTranslateUTf8ToUnicode - Case1\n");
        *Utf8Value = (WCHAR)Utf8Char;
        Utf8Buffer[0] = Utf8Buffer[1];
        Utf8Buffer[1] = Utf8Buffer[2];
        Utf8Buffer[2] = UNICODE_NULL;
        return TRUE;
    }
 
    /* Anything else is not yet supported */
    ASSERT(FALSE);
    return FALSE;
}

Referenced by VTUTF8ChannelIWrite().

◆ SerialBufferGetChar()

NTSTATUS NTAPI SerialBufferGetChar ( OUT PCHAR Char )

Definition at line 1212 of file util.c.

{
    /* Check if nothing's been produced yet */
    if (SerialPortConsumerIndex == SerialPortProducerIndex)
    {
        return STATUS_NO_DATA_DETECTED;
    }
 
    /* Consume the produced character and clear it*/
    *Char = SerialPortBuffer[SerialPortConsumerIndex];
    SerialPortBuffer[SerialPortConsumerIndex] = ANSI_NULL;
 
    /* Advance the index and return success */
    _InterlockedExchange(&SerialPortConsumerIndex,
                         (SerialPortConsumerIndex + 1) &
                         (SAC_SERIAL_PORT_BUFFER_SIZE - 1));
    return STATUS_SUCCESS;
}

Referenced by ConMgrSerialPortConsumer().

◆ SetRegistryValue()

NTSTATUS NTAPI SetRegistryValue	(	IN PCWSTR	KeyName,
		IN PWCHAR	ValueName,
		IN ULONG	Type,
		IN PVOID	Data,
		IN ULONG	DataSize
	)

Definition at line 465 of file util.c.

{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING DestinationString;
    HANDLE Handle;
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC SetRegistryValue: Entering.\n");
    CHECK_PARAMETER1(KeyName);
    CHECK_PARAMETER2(ValueName);
    CHECK_PARAMETER4(Data);
 
    /* Open the specified key */
    RtlInitUnicodeString(&DestinationString, KeyName);
    InitializeObjectAttributes(&ObjectAttributes,
                               &DestinationString,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
    Status = ZwOpenKey(&Handle,
                       KEY_WRITE | SYNCHRONIZE | KEY_READ,
                       &ObjectAttributes);
    if (!NT_SUCCESS(Status))
    {
        /* Bail out on failure */
        SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC SetRegistryValue: failed ZwOpenKey: %X.\n", Status);
        return Status;
    }
 
    /* Set the specified value */
    RtlInitUnicodeString(&DestinationString, ValueName);
    Status = ZwSetValueKey(Handle, &DestinationString, 0, Type, Data, DataSize);
    if (!NT_SUCCESS(Status))
    {
        /* Print error on failure */
        SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC SetRegistryValue: failed ZwSetValueKey: %X.\n", Status);
    }
 
    /* Close the handle and exit */
    ZwClose(Handle);
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC SetRegistryValue: Exiting.\n");
    return Status;
}

Referenced by ImposeSacCmdServiceStartTypePolicy().

◆ TearDownGlobalMessageTable()

NTSTATUS NTAPI TearDownGlobalMessageTable ( VOID )

Definition at line 379 of file util.c.

{
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC TearDownGlobalMessageTable: Entering.\n");
 
    /* Free the table if one existed */
    if (GlobalMessageTable) SacFreePool(GlobalMessageTable);
 
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC TearDownGlobalMessageTable: Exiting\n");
    return STATUS_SUCCESS;
}

Referenced by FreeGlobalData(), and InitializeGlobalData().

◆ TranslateMachineInformationText()

NTSTATUS TranslateMachineInformationText ( IN PWCHAR Buffer )

Definition at line 1277 of file util.c.

{
    return STATUS_NOT_IMPLEMENTED;
}

◆ TranslateMachineInformationXML()

NTSTATUS NTAPI TranslateMachineInformationXML	(	IN PWCHAR *	Buffer,
		IN PWCHAR	ExtraData
	)

Definition at line 541 of file util.c.

{
    NTSTATUS Status;
    SIZE_T Size;
    PWCHAR p;
    CHECK_PARAMETER1(Buffer);
 
    /* Start by believing the world is beautiful */
    Status = STATUS_SUCCESS;
 
    /* First, the header */
    Size = wcslen(L"<machine-info>\r\n");
 
    /* Do we have a machine name? */
    if (MachineInformation->MachineName)
    {
        /* Go and add it in */
        Size += wcslen(MachineInformation->MachineName);
        Size += wcslen(L"<name>%s</name>\r\n");
    }
 
    /* Do we have a GUID? */
    if (MachineInformation->MachineGuid)
    {
        /* Go and add it in */
        Size += wcslen(MachineInformation->MachineGuid);
        Size += wcslen(L"<guid>%s</guid>\r\n");
    }
 
    /* Do we know the processor? */
    if (MachineInformation->ProcessorArchitecture)
    {
        /* Go and add it in */
        Size += wcslen(MachineInformation->ProcessorArchitecture);
        Size += wcslen(L"<processor-architecture>%s</processor-architecture>\r\n");
    }
 
    /* Do we have the version? */
    if (MachineInformation->MajorVersion)
    {
        /* Go and add it in */
        Size += wcslen(MachineInformation->MajorVersion);
        Size += wcslen(L"<os-version>%s</os-version>\r\n");
    }
 
    /* Do we have the build? */
    if (MachineInformation->BuildNumber)
    {
        /* Go and add it in */
        Size += wcslen(MachineInformation->BuildNumber);
        Size += wcslen(L"<os-build-number>%s</os-build-number>\r\n");
    }
 
    /* Do we have the product type? */
    if (MachineInformation->ProductType)
    {
        /* Go and add it in */
        Size += wcslen(MachineInformation->ProductType);
        Size += wcslen(L"<os-product>%s</os-product>\r\n");
    }
 
    /* Do we have a service pack? */
    if (MachineInformation->ServicePack)
    {
        /* Go and add it in */
        Size += wcslen(MachineInformation->ServicePack);
        Size += wcslen(L"<os-service-pack>%s</os-service-pack>\r\n");
    }
 
    /* Anything else we need to know? Add it in too */
    if (ExtraData) Size += wcslen(ExtraData);
 
    /* Finally, add the footer */
    Size += wcslen(L"</machine-info>\r\n");
 
    /* Convert to bytes and add a NULL */
    Size += sizeof(ANSI_NULL);
    Size *= sizeof(WCHAR);
 
    /* Allocate space for the buffer */
    p = SacAllocatePool(Size, GLOBAL_BLOCK_TAG);
    *Buffer = p;
    if (!p) return STATUS_NO_MEMORY;
 
    wcscpy(p, L"<machine-info>\r\n");
    p += wcslen(L"<machine-info>\r\n");
 
    if (MachineInformation->MachineName)
    {
        p += swprintf(p,
                      L"<name>%s</name>\r\n",
                      MachineInformation->MachineName);
    }
 
    if (MachineInformation->MachineGuid)
    {
        p += swprintf(p,
                      L"<guid>%s</guid>\r\n",
                      MachineInformation->MachineGuid);
    }
 
    if (MachineInformation->ProcessorArchitecture)
    {
        p += swprintf(p,
                      L"<processor-architecture>%s</processor-architecture>\r\n",
                      MachineInformation->ProcessorArchitecture);
    }
 
    if (MachineInformation->MajorVersion)
    {
        p += swprintf(p,
                      L"<os-version>%s</os-version>\r\n",
                      MachineInformation->MajorVersion);
    }
 
    if (MachineInformation->BuildNumber)
    {
        p += swprintf(p,
                      L"<os-build-number>%s</os-build-number>\r\n",
                      MachineInformation->BuildNumber);
    }
 
    if (MachineInformation->ProductType)
    {
        p += swprintf(p,
                      L"<os-product>%s</os-product>\r\n",
                      MachineInformation->ProductType);
    }
 
    if (MachineInformation->ServicePack)
    {
        p += swprintf(p,
                      L"<os-service-pack>%s</os-service-pack>\r\n",
                      MachineInformation->ServicePack);
    }
 
    if (ExtraData)
    {
        wcscpy(p, ExtraData);
        p += wcslen(ExtraData);
    }
 
    wcscpy(p, L"</machine-info>\r\n");
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "MachineInformation: %S\n", *Buffer);
    ASSERT((((ULONG)wcslen(*Buffer) + 1) * sizeof(WCHAR)) <= Size);
    return Status;
}

Referenced by InitializeDeviceData(), and RegisterBlueScreenMachineInformation().

◆ UnregisterSacCmdEvent()

NTSTATUS UnregisterSacCmdEvent ( IN PFILE_OBJECT FileObject )

Definition at line 1304 of file util.c.

{
    return STATUS_NOT_IMPLEMENTED;
}

◆ UTF8EncodeAndSend()

NTSTATUS NTAPI UTF8EncodeAndSend ( IN PWCHAR String )

Definition at line 165 of file util.c.

{
    ULONG ProcessedCount, Utf8Count, i;
    NTSTATUS Status = STATUS_SUCCESS;
 
    /* Call the translator routine */
    if (SacTranslateUnicodeToUtf8(String,
                                  wcslen(String),
                                  Utf8ConversionBuffer,
                                  Utf8ConversionBufferSize,
                                  &Utf8Count,
                                  &ProcessedCount))
    {
        /* Loop every character */
        for (i = 0; i < Utf8Count; i++)
        {
            /* Send it to the terminal */
            Status = HeadlessDispatch(HeadlessCmdPutData,
                                      &Utf8ConversionBuffer[i],
                                      sizeof(Utf8ConversionBuffer[i]),
                                      NULL,
                                      NULL);
            if (!NT_SUCCESS(Status)) break;
        }
    }
    else
    {
        /* Conversion failed */
        Status = STATUS_UNSUCCESSFUL;
    }
 
    /* All done */
    return Status;
}

Referenced by InitializeDeviceData().

◆ VerifyEventWaitable()

BOOLEAN NTAPI VerifyEventWaitable	(	IN HANDLE	Handle,
		OUT PVOID *	WaitObject,
		OUT PVOID *	ActualWaitObject
	)

Definition at line 1172 of file util.c.

{
    PVOID Object;
    NTSTATUS Status;
    POBJECT_TYPE ObjectType;
 
    /* Reference the object */
    Status = ObReferenceObjectByHandle(Handle,
                                       EVENT_ALL_ACCESS,
                                       NULL,
                                       KernelMode,
                                       &Object,
                                       NULL);
    *WaitObject = Object;
    if (!NT_SUCCESS(Status))
    {
        SAC_DBG(SAC_DBG_INIT, "SAC VerifyEventWaitable: Unable to reference event object (%lx)\n", Status);
        return FALSE;
    }
 
    /* Check if the object itself is NOT being used */
    ObjectType = OBJECT_TO_OBJECT_HEADER(Object)->Type;
    if (ObjectType->TypeInfo.UseDefaultObject == FALSE)
    {
        /* Get the actual object that's being used for the wait */
        *ActualWaitObject = (PVOID)((ULONG_PTR)Object +
                                    (ULONG_PTR)ObjectType->DefaultObject);
        return TRUE;
    }
 
    /* Drop the reference we took */
    SAC_DBG(SAC_DBG_INIT, "SAC VerifyEventWaitable: event object not waitable!\n");
    ObDereferenceObject(*WaitObject);
    return FALSE;
}

Variable Documentation

◆ GlobalMessageTable

PSAC_MESSAGE_ENTRY GlobalMessageTable

Definition at line 31 of file util.c.

Referenced by GetMessage(), PreloadGlobalMessageTable(), and TearDownGlobalMessageTable().

◆ GlobalMessageTableCount

ULONG GlobalMessageTableCount

Definition at line 32 of file util.c.

Referenced by GetMessage(), and PreloadGlobalMessageTable().

◆ HaveUserModeServiceCmdEventInfo

BOOLEAN HaveUserModeServiceCmdEventInfo

Definition at line 29 of file util.c.

Referenced by InitializeCmdEventInfo().

◆ MachineInformation

PSAC_MACHINE_INFO MachineInformation

Definition at line 20 of file util.c.

Referenced by FreeMachineInformation(), InitializeMachineInformation(), and TranslateMachineInformationXML().

◆ RequestSacCmdEventObjectBody

PVOID RequestSacCmdEventObjectBody

Definition at line 22 of file util.c.

Referenced by InitializeCmdEventInfo().

◆ RequestSacCmdEventWaitObjectBody

PKEVENT RequestSacCmdEventWaitObjectBody

Definition at line 23 of file util.c.

Referenced by InitializeCmdEventInfo().

◆ RequestSacCmdFailureEventObjectBody

PVOID RequestSacCmdFailureEventObjectBody

Definition at line 26 of file util.c.

Referenced by InitializeCmdEventInfo().

◆ RequestSacCmdFailureEventWaitObjectBody

PKEVENT RequestSacCmdFailureEventWaitObjectBody

Definition at line 27 of file util.c.

Referenced by InitializeCmdEventInfo().

◆ RequestSacCmdSuccessEventObjectBody

PVOID RequestSacCmdSuccessEventObjectBody

Definition at line 24 of file util.c.

Referenced by InitializeCmdEventInfo().

◆ RequestSacCmdSuccessEventWaitObjectBody

PKEVENT RequestSacCmdSuccessEventWaitObjectBody

Definition at line 25 of file util.c.

Referenced by InitializeCmdEventInfo().

◆ SerialPortBuffer

PCHAR SerialPortBuffer

Definition at line 35 of file util.c.

Referenced by FreeGlobalData(), InitializeGlobalData(), SerialBufferGetChar(), and TimerDpcRoutine().

◆ SerialPortConsumerIndex

LONG SerialPortConsumerIndex

Definition at line 34 of file util.c.

Referenced by SerialBufferGetChar().

◆ SerialPortProducerIndex

LONG SerialPortProducerIndex

Definition at line 34 of file util.c.

Referenced by SerialBufferGetChar().

◆ ServiceProcessFileObject

PFILE_OBJECT ServiceProcessFileObject

Definition at line 28 of file util.c.

Referenced by InitializeCmdEventInfo().

◆ Utf8ConversionBuffer

PCHAR Utf8ConversionBuffer

Definition at line 17 of file util.c.

Referenced by InitializeGlobalData(), UTF8EncodeAndSend(), VTUTF8ChannelOEcho(), and VTUTF8ChannelOFlush().

◆ Utf8ConversionBufferSize

ULONG Utf8ConversionBufferSize = PAGE_SIZE

Definition at line 18 of file util.c.

Referenced by InitializeGlobalData(), UTF8EncodeAndSend(), VTUTF8ChannelOEcho(), and VTUTF8ChannelOFlush().

Variables
PCHAR	Utf8ConversionBuffer

ULONG	Utf8ConversionBufferSize = PAGE_SIZE

PSAC_MACHINE_INFO	MachineInformation

PVOID	RequestSacCmdEventObjectBody

PKEVENT	RequestSacCmdEventWaitObjectBody

PVOID	RequestSacCmdSuccessEventObjectBody

PKEVENT	RequestSacCmdSuccessEventWaitObjectBody

PVOID	RequestSacCmdFailureEventObjectBody

PKEVENT	RequestSacCmdFailureEventWaitObjectBody

PFILE_OBJECT	ServiceProcessFileObject

BOOLEAN	HaveUserModeServiceCmdEventInfo

PSAC_MESSAGE_ENTRY	GlobalMessageTable

ULONG	GlobalMessageTableCount

LONG	SerialPortConsumerIndex

LONG	SerialPortProducerIndex

PCHAR	SerialPortBuffer

Functions

Variables

Function Documentation

◆ ConvertAnsiToUnicode()

◆ CopyAndInsertStringAtInterval()

◆ CopyRegistryValueData()

◆ FreeMachineInformation()

◆ GetCommandConsoleLaunchingPermission()

◆ GetMessage()

◆ GetMessageLineCount()

◆ GetRegistryValueBuffer()

◆ ImposeSacCmdServiceStartTypePolicy()

◆ InitializeCmdEventInfo()

◆ InitializeMachineInformation()

◆ InvokeUserModeService()

◆ IsCmdEventRegistrationProcess()

◆ PreloadGlobalMessageTable()

◆ RegisterBlueScreenMachineInformation()

◆ RegisterSacCmdEvent()

◆ SacFormatMessage()

◆ SacTranslateUnicodeToUtf8()

◆ SacTranslateUtf8ToUnicode()

◆ SerialBufferGetChar()

◆ SetRegistryValue()

◆ TearDownGlobalMessageTable()

◆ TranslateMachineInformationText()

◆ TranslateMachineInformationXML()

◆ UnregisterSacCmdEvent()

◆ UTF8EncodeAndSend()

◆ VerifyEventWaitable()

Variable Documentation

◆ GlobalMessageTable

◆ GlobalMessageTableCount

◆ HaveUserModeServiceCmdEventInfo

◆ MachineInformation

◆ RequestSacCmdEventObjectBody

◆ RequestSacCmdEventWaitObjectBody

◆ RequestSacCmdFailureEventObjectBody

◆ RequestSacCmdFailureEventWaitObjectBody

◆ RequestSacCmdSuccessEventObjectBody

◆ RequestSacCmdSuccessEventWaitObjectBody

◆ SerialPortBuffer

◆ SerialPortConsumerIndex

◆ SerialPortProducerIndex

◆ ServiceProcessFileObject

◆ Utf8ConversionBuffer

◆ Utf8ConversionBufferSize