windows-server-2003/drivers/sac/driver/util.c

/*++

Copyright (c) 1989  Microsoft Corporation

Module Name:

    util.c

Abstract:

    Utility routines for sac driver

Author:

    Andrew Ritz (andrewr) - 15 June, 2000

Revision History:

    added new utils: Brian Guarraci (briangu) - 2001

--*/

#include "sac.h"
#include <guiddef.h>
      
VOID
AppendMessage(
    PWSTR       OutPutBuffer,
    ULONG       MessageId,
    PWSTR       ValueBuffer OPTIONAL
    );

NTSTATUS
InsertRegistrySzIntoMachineInfoBuffer(
    PWSTR       KeyName,
    PWSTR       ValueName,
    ULONG       MessageId
    );

#ifdef ALLOC_PRAGMA
#pragma alloc_text( INIT, PreloadGlobalMessageTable )
#pragma alloc_text( INIT, AppendMessage )
#pragma alloc_text( INIT, InsertRegistrySzIntoMachineInfoBuffer )
#pragma alloc_text( INIT, InitializeMachineInformation )
#endif

//
// (see comments in sac.h)
//
PUCHAR  Utf8ConversionBuffer;
ULONG   Utf8ConversionBufferSize = MEMORY_INCREMENT;
WCHAR   IncomingUnicodeValue;
UCHAR   IncomingUtf8ConversionBuffer[3];

//
// Message Table routines.  We load all of our message table entries into a 
// global non-paged structure so that we can send text to HeadlessDispatch at
// any time.
//

typedef struct _MESSAGE_TABLE_ENTRY {
    ULONG             MessageId;
    PCWSTR             MessageText;
} MESSAGE_TABLE_ENTRY, *PMESSAGE_TABLE_ENTRY;

PMESSAGE_TABLE_ENTRY GlobalMessageTable;
ULONG          GlobalMessageTableCount;

#define MESSAGE_INITIAL 1
#define MESSAGE_FINAL 200

//
// Prototypes
//
extern
BOOLEAN
ExVerifySuite(
    SUITE_TYPE SuiteType
    );

ULONG
ConvertAnsiToUnicode(
    OUT PWSTR   pwch,
    IN  PSTR    pch,
    IN  ULONG   cchMax
    )
/*++

Routine Description:

    Convert an ansi character string into unicode.
    
Arguments:

    pwch    - the unicode string
    pch     - the ansi string
    cchMax  - the max length to copy (including null termination)      

Return Value:

    # of characters converted (not including null termination)

--*/
{
    ULONG   Count;

    ASSERT_STATUS(pch, 0);
    ASSERT_STATUS(pwch, 0);

    Count = 0;

    while ((*pch != '\0') && (Count < (cchMax-1))) {
    
        *pwch = (WCHAR)(*pch);
        pwch++;
        pch++;

        Count++;
    }

    *pwch = UNICODE_NULL;

    return Count;
}
            
NTSTATUS
RegisterSacCmdEvent(
    IN PFILE_OBJECT             FileObject,
    IN PSAC_CMD_SETUP_CMD_EVENT SetupCmdEvent
    )
/*++

Routine Description:

    This routine populates the sac cmd event info specified by
    the user-mode service responsible for responding to requests
    to launch a command console session.
    
Arguments:

    FileObject      - the FileObject ptr for the driver handle object
                      used by the registering process
    SetupCmdEvent   - the event info                
                    
Return Value:

    Status       

Security:

    Interface:
    
        external --> internal
    
    this routine does not prevent reregistration of the cmd event info
    this behavior should be handled by the caller
           
--*/
{
    NTSTATUS    Status;
    BOOLEAN     b;

    ASSERT_STATUS(SetupCmdEvent, STATUS_INVALID_PARAMETER_1);

    //
    // Protect the SAC Cmd Event Info
    //
    KeWaitForMutexObject(
        &SACCmdEventInfoMutex, 
        Executive,
        KernelMode,
        FALSE,
        NULL
        );
    
    do {

        //
        // make sure there isn't a service already regiseterd
        //
        if (UserModeServiceHasRegisteredCmdEvent()) {
            Status = STATUS_UNSUCCESSFUL;
            break;
        }

        //
        // Reset our info to the initial condition
        //
        // Note: this cleans up the cmd event info if present
        //
        InitializeCmdEventInfo();
        

#if ENABLE_SERVICE_FILE_OBJECT_CHECKING
        //
        // get a reference to the registering process's driver handle
        // file object so we can make sure that an unregister IOCTL
        // comes from the same process.
        //
        Status = ObReferenceObjectByPointer(
            FileObject,
            GENERIC_READ,
            *IoFileObjectType,
            KernelMode
            );

        if (!NT_SUCCESS(Status)) {
            break;
        }
        
        ServiceProcessFileObject = FileObject;
#else
        UNREFERENCED_PARAMETER(FileObject);
#endif
        
        //
        // test and aqcuire the RequestSacCmdEvent event handle
        //
        b = VerifyEventWaitable(
            SetupCmdEvent->RequestSacCmdEvent,
            &RequestSacCmdEventObjectBody,
            &RequestSacCmdEventWaitObjectBody
            );

        if(!b) {
            Status = STATUS_INVALID_HANDLE;
            break;
        }

        //
        // test and aqcuire the RequestSacCmdSuccessEvent event handle
        //
        b = VerifyEventWaitable(
            SetupCmdEvent->RequestSacCmdSuccessEvent,
            &RequestSacCmdSuccessEventObjectBody,
            &RequestSacCmdSuccessEventWaitObjectBody
            );

        if(!b) {
            Status = STATUS_INVALID_HANDLE;
            ObDereferenceObject(RequestSacCmdEventObjectBody);
            break;
        }

        //
        // test and aqcuire the RequestSacCmdFailureEvent event handle
        //
        b = VerifyEventWaitable(
            SetupCmdEvent->RequestSacCmdFailureEvent,
            &RequestSacCmdFailureEventObjectBody,
            &RequestSacCmdFailureEventWaitObjectBody
            );

        if(!b) {
            Status = STATUS_INVALID_HANDLE;
            ObDereferenceObject(RequestSacCmdEventObjectBody);
            ObDereferenceObject(RequestSacCmdSuccessEventWaitObjectBody);
            break;
        }

        //
        // declare that we indeed have the user-mode service info
        //
        HaveUserModeServiceCmdEventInfo = TRUE;

        //
        // We have successfully registered teh SAC Cmd Event Info
        //
        Status = STATUS_SUCCESS;
    
    } while (FALSE);

    KeReleaseMutex(&SACCmdEventInfoMutex, FALSE);

    return Status;
}

#if ENABLE_SERVICE_FILE_OBJECT_CHECKING

BOOLEAN
IsCmdEventRegistrationProcess(
    IN PFILE_OBJECT     FileObject
    )
/*++

Routine Description:

    This routine purges the previously registered sac cmd event info.
    
    Note: This should be called when the user-mode service shuts down.

Arguments:

    FileObject      - the FileObject ptr for the driver handle object
                      used by the registering process
    
Return Value:

    Status    
        
--*/
{
    BOOLEAN bIsRegistrationProcess;
    
    //
    // Default
    //
    bIsRegistrationProcess = FALSE;

    //
    // Protect the SAC Cmd Event Info
    //
    KeWaitForMutexObject(
        &SACCmdEventInfoMutex, 
        Executive,
        KernelMode,
        FALSE,
        NULL
        );
    
    do {
        
        //
        // exit if there is no service registered
        //
        if (! UserModeServiceHasRegisteredCmdEvent()) {
            break;
        }

        //
        // make sure the calling process is the same
        // that registered
        //
        if (FileObject == ServiceProcessFileObject) {
            bIsRegistrationProcess = TRUE;
            break;
        }

    } while (FALSE);

    KeReleaseMutex(&SACCmdEventInfoMutex, FALSE);

    return bIsRegistrationProcess;
}

#endif

NTSTATUS
UnregisterSacCmdEvent(
    IN PFILE_OBJECT     FileObject
    )
/*++

Routine Description:

    This routine purges the previously registered sac cmd event info.
    
    Note: This should be called when the user-mode service shuts down.

Arguments:
    
    FileObject      - the FileObject ptr for the driver handle object
                      used by the registering process

Return Value:

    Status    
        
--*/
{
    NTSTATUS    Status;

    //
    // Protect the SAC Cmd Event Info
    //
    KeWaitForMutexObject(
        &SACCmdEventInfoMutex, 
        Executive,
        KernelMode,
        FALSE,
        NULL
        );
    
    do {
        
        //
        // exit if there is no service registered
        //
        if (! UserModeServiceHasRegisteredCmdEvent()) {
            Status = STATUS_UNSUCCESSFUL;
            break;
        }

#if ENABLE_SERVICE_FILE_OBJECT_CHECKING

        //
        // make sure the calling process is the same
        // that registered
        //
        if (FileObject != ServiceProcessFileObject) {
            Status = STATUS_UNSUCCESSFUL;
            break;
        }

        //
        // since we are unregistering, 
        // we no longer need to hold a reference to 
        // the driver handle object
        //
        ObDereferenceObject(FileObject);

#else
        UNREFERENCED_PARAMETER(FileObject);
#endif
        
        //
        // Reset our info to the initial condition
        //
        InitializeCmdEventInfo();

        Status = STATUS_SUCCESS;
        
    } while (FALSE);

    KeReleaseMutex(&SACCmdEventInfoMutex, FALSE);

    return Status;
}

VOID
InitializeCmdEventInfo(
    VOID
    )
/*++

Routine Description:

    Initialize the Cmd Console Event Information.  
    
Arguments:

    NONE

Return Value:

    NONE

--*/
{
    
    //
    // Dereference the wait objects if we have them
    //
    if (HaveUserModeServiceCmdEventInfo) {
        
        ASSERT(RequestSacCmdEventObjectBody);
        ASSERT(RequestSacCmdSuccessEventObjectBody);
        ASSERT(RequestSacCmdFailureEventObjectBody);

        if (RequestSacCmdEventObjectBody) {
            ObDereferenceObject(RequestSacCmdEventObjectBody);
        }
        
        if (RequestSacCmdSuccessEventObjectBody) {
            ObDereferenceObject(RequestSacCmdSuccessEventObjectBody);
        }
        
        if (RequestSacCmdFailureEventObjectBody) {
            ObDereferenceObject(RequestSacCmdFailureEventObjectBody);
        }
    }
    
    //
    // reset the cmd console event information
    //
    RequestSacCmdEventObjectBody = NULL;
    RequestSacCmdEventWaitObjectBody = NULL;
    RequestSacCmdSuccessEventObjectBody = NULL;
    RequestSacCmdSuccessEventWaitObjectBody = NULL;
    RequestSacCmdFailureEventObjectBody = NULL;
    RequestSacCmdFailureEventWaitObjectBody = NULL;
    
#if ENABLE_SERVICE_FILE_OBJECT_CHECKING
    //
    // reset the process file object ptr
    //
    ServiceProcessFileObject = NULL;
#endif

    //
    // declare that we do NOT have the user-mode service info
    //
    HaveUserModeServiceCmdEventInfo = FALSE;
}

BOOLEAN
VerifyEventWaitable(
    IN  HANDLE  hEvent,
    OUT PVOID  *EventObjectBody,
    OUT PVOID  *EventWaitObjectBody
    )
/*++

Routine Description:

    This routine extracts the waitable object from the 
    specified event object.  It also verifies that there
    is a waitable object present.
    
    Note: if successful, this routine returns with the
          reference count incremented on the event object.
          The caller is responsible for releasing this
          object.                                              
                                              
Arguments:

    hEvent              - The handle to the event object
    EventObjectBody     - The event object
    EventWaitObjectBody - The waitiable object
    
Return Value:

    TRUE    - event is waitable
    FALSE   - otherwise

Security:

    This routine operates on event objects referred by event handles from
    usermode.

--*/
{
    POBJECT_HEADER ObjectHeader;
    NTSTATUS Status;

    //
    // Reference the event and verify that it is waitable.
    //
    Status = ObReferenceObjectByHandle(
                hEvent,
                EVENT_ALL_ACCESS,
                NULL,
                KernelMode,
                EventObjectBody,
                NULL
                );

    if(!NT_SUCCESS(Status)) {
        IF_SAC_DEBUG(
            SAC_DEBUG_FAILS, 
            KdPrint(("SAC VerifyEventWaitable: Unable to reference event object (%lx)\n",Status))
            );
        return(FALSE);
    }

    ObjectHeader = OBJECT_TO_OBJECT_HEADER(*EventObjectBody);
    if(!ObjectHeader->Type->TypeInfo.UseDefaultObject) {

        *EventWaitObjectBody = (PVOID)((PCHAR)(*EventObjectBody) +
                              (ULONG_PTR)ObjectHeader->Type->DefaultObject);

    } else {
        IF_SAC_DEBUG(
            SAC_DEBUG_FAILS, 
            KdPrint(("SAC VerifyEventWaitable: event object not waitable!\n"))
            );
        ObDereferenceObject(*EventObjectBody);
        return(FALSE);
    }

    return(TRUE);
}

NTSTATUS
InvokeUserModeService(
    VOID
    )
/*++

Routine Description:

    This routine manages the interaction with the user-mode service responsible
    for launching the cmd console channel.
    
Arguments:

    None

Return Value:

    STATUS_SUCCESS  - if cmd console was successfully launched by user-mode service
    
    otherwise, error status

--*/
{
    NTSTATUS        Status;
    LARGE_INTEGER   TimeOut;
    HANDLE          EventArray[ 2 ];

    //
    // setup the event array
    //
    enum { 
        SAC_CMD_LAUNCH_SUCCESS = 0,
        SAC_CMD_LAUNCH_FAILURE
        };
    
    ASSERT_STATUS(RequestSacCmdEventObjectBody != NULL, STATUS_INVALID_HANDLE);
    ASSERT_STATUS(RequestSacCmdSuccessEventWaitObjectBody != NULL, STATUS_INVALID_HANDLE);
    ASSERT_STATUS(RequestSacCmdFailureEventWaitObjectBody != NULL, STATUS_INVALID_HANDLE);

#if ENABLE_CMD_SESSION_PERMISSION_CHECKING

    //
    // If we are not able to launch cmd sessions,
    // then return status unsuccessful.
    //
    if (! IsCommandConsoleLaunchingEnabled()) {
        return STATUS_UNSUCCESSFUL;
    }
    
#endif

    //
    // Since we don't know if the user-mode app will serice our request properly
    // we have to timeout on the Serviced event.
    //
    TimeOut.QuadPart = Int32x32To64((LONG)90000, -1000);

    //
    // Populate the event array with events we want to catch from user-mode
    //
    EventArray[ 0 ] = RequestSacCmdSuccessEventWaitObjectBody;
    EventArray[ 1 ] = RequestSacCmdFailureEventWaitObjectBody;

    //
    // Set the event indicating that the communication buffer is
    // ready for the user-mode process. Because this is a synchronization
    // event, it automatically resets after releasing the waiting
    // user-mode thread.  Note that we specify WaitNext to prevent the
    // race condition between setting this synchronization event and
    // waiting on the next one.
    //
    IF_SAC_DEBUG(SAC_DEBUG_FUNC_TRACE, 
                      KdPrint(("SAC InvokeUserModeService: Sending Notification Event\n")));
    
    KeSetEvent(RequestSacCmdEventObjectBody,EVENT_INCREMENT,TRUE);

    //
    // Wait for the user-mode process to indicate that it is done
    // processing the request.  We wait in user mode so that we can be 
    // interrupted if necessary -- say, by an exit APC.
    //
    
    IF_SAC_DEBUG(
        SAC_DEBUG_FUNC_TRACE, 
        KdPrint(("SAC InvokeUserModeService: Waiting for Serviced Event.\n"))
        );
    
    Status = KeWaitForMultipleObjects ( 
        sizeof(EventArray)/sizeof(HANDLE), 
        EventArray,
        WaitAny,
        Executive,
        UserMode,
        FALSE, 
        &TimeOut,
        NULL
        );
    
    switch (Status)
    {
    case SAC_CMD_LAUNCH_SUCCESS:
        Status = STATUS_SUCCESS;
        break;
    
    case SAC_CMD_LAUNCH_FAILURE:
        Status = STATUS_UNSUCCESSFUL;
        break;
    
    case STATUS_TIMEOUT:
        
        IF_SAC_DEBUG(
            SAC_DEBUG_FUNC_TRACE, 
            KdPrint(("SAC InvokeUserModeService: KeWaitForMultipleObject timed-out %lx\n",Status))
            );
        
        //
        // We don't want to "reset" the cmd console event info
        // if the service times out for the following reason:
        //
        //    The service may still be functional, but just unable
        //    to respond because of machine load.  We don't want
        //    to remove it's registration and have it think it's
        //    still registered, making the service useless.
        //
        NOTHING;

        break;
    
    default:
        IF_SAC_DEBUG(
            SAC_DEBUG_FAILS, 
            KdPrint(("SAC InvokeUserModeService: KeWaitForMultipleObject returns %lx\n",Status))
            );
        
        Status = STATUS_UNSUCCESSFUL;

        break;
    }

    //
    // Return the status
    //
    return(Status);
}

VOID
SacFormatMessage(
    PWSTR       OutputString,
    PWSTR       InputString,
    ULONG       InputStringLength
    )
/*++

Routine Description:

    This routine parses the InputString for any control characters in the
    message, then converts those control characters.
    
Arguments:

    OutputString      - holds formatted string.

    InputString       - original unformatted string.

    InputStringLength - length of unformatted string.


Return Value:

    NONE

--*/
{

    IF_SAC_DEBUG(SAC_DEBUG_FUNC_TRACE, 
                      KdPrint(("SAC SacFormatMessage: Entering.\n")));


    if( (InputString == NULL) ||
        (OutputString == NULL) ||
        (InputStringLength == 0) ) {

        IF_SAC_DEBUG(SAC_DEBUG_FUNC_TRACE, 
                      KdPrint(("SAC SacFormatMessage: Exiting with invalid parameters.\n")));

        return;
    }



    while( (*InputString != L'\0') &&
           (InputStringLength) ) {
        if( *InputString == L'%' ) {
            
            //
            // Possibly a control sequence.
            //
            if( *(InputString+1) == L'0' ) {

                *OutputString = L'\0';
                OutputString++;
                goto SacFormatMessage_Done;

            } else if( *(InputString+1) == L'%' ) {

                *OutputString = L'%';
                OutputString++;
                InputString += 2;

            } else if( *(InputString+1) == L'\\' ) {

                *OutputString = L'\r';
                OutputString++;
                *OutputString = L'\n';
                OutputString++;
                InputString += 2;

            } else if( *(InputString+1) == L'r' ) {

                *OutputString = L'\r';
                InputString += 2;
                OutputString++;

            } else if( *(InputString+1) == L'b' ) {

                *OutputString = L' ';
                InputString += 2;
                OutputString++;

            } else if( *(InputString+1) == L'.' ) {

                *OutputString = L'.';
                InputString += 2;
                OutputString++;

            } else if( *(InputString+1) == L'!' ) {

                *OutputString = L'!';
                InputString += 2;
                OutputString++;

            } else {

                //
                // Don't know what this is.  eat the '%' character.
                //
                InputString += 1;
            }
    
        } else {

            *OutputString++ = *InputString++;
        }

        InputStringLength--;

    }


    IF_SAC_DEBUG(SAC_DEBUG_FUNC_TRACE, 
                      KdPrint(("SAC SacFormatMessage: Exiting.\n")));

SacFormatMessage_Done:

    return;
}


NTSTATUS
PreloadGlobalMessageTable(
    PVOID ImageBase
    )
/*++

Routine Description:

    This routine loads all of our message table entries into a global
    structure and 
    
Arguments:

    ImageBase - pointer to image base for locating resources

Return Value:

    NTSTATUS code indicating outcome.

--*/
{
    ULONG Count,EntryCount;
    SIZE_T TotalSizeInBytes = 0;
    NTSTATUS Status;
    PMESSAGE_RESOURCE_ENTRY messageEntry;
    PWSTR pStringBuffer;
    
    PAGED_CODE( );

    IF_SAC_DEBUG(SAC_DEBUG_FUNC_TRACE, KdPrint(("SAC PreloadGlobalMessageTable: Entering.\n")));


    // 
    // if it already exists, then just return success
    //
    if (GlobalMessageTable != NULL) {
        Status = STATUS_SUCCESS;
        goto exit;
    }

    ASSERT( MESSAGE_FINAL > MESSAGE_INITIAL );

    //
    // get the total required size for the table.
    //
    for (Count = MESSAGE_INITIAL; Count != MESSAGE_FINAL ; Count++) {
        
        Status = RtlFindMessage(ImageBase,
                                11, // RT_MESSAGETABLE
                                LANG_NEUTRAL,
                                Count,
                                &messageEntry
                               );

        if (NT_SUCCESS(Status)) {
            //
            // add it on to our total size.
            //
            // the messageEntry size contains the structure size + the size of the text.
            //
            ASSERT(messageEntry->Flags & MESSAGE_RESOURCE_UNICODE);
            TotalSizeInBytes += sizeof(MESSAGE_TABLE_ENTRY) + 
                                (messageEntry->Length - FIELD_OFFSET(MESSAGE_RESOURCE_ENTRY, Text));
            GlobalMessageTableCount +=1;        
        }
            
    }


    if (TotalSizeInBytes == 0) {
        IF_SAC_DEBUG(
            SAC_DEBUG_FAILS,
            KdPrint(("SAC PreloadGlobalMessageTable: No Messages.\n")));
        Status = STATUS_INVALID_PARAMETER;
        goto exit;
    }

    //
    // Allocate space for the table.
    //
    GlobalMessageTable = (PMESSAGE_TABLE_ENTRY) ALLOCATE_POOL( TotalSizeInBytes, GENERAL_POOL_TAG);
    if (!GlobalMessageTable) {
        Status = STATUS_NO_MEMORY;
        goto exit;
    }

    //
    // go through again, this time filling out the table with actual data
    //
    pStringBuffer = (PWSTR)((ULONG_PTR)GlobalMessageTable + 
                        (ULONG_PTR)(sizeof(MESSAGE_TABLE_ENTRY)*GlobalMessageTableCount));
    EntryCount = 0;
    for (Count = MESSAGE_INITIAL ; Count != MESSAGE_FINAL ; Count++) {
        Status = RtlFindMessage(ImageBase,
                                11, // RT_MESSAGETABLE
                                LANG_NEUTRAL,
                                Count,
                                &messageEntry
                               );

        if (NT_SUCCESS(Status)) {
            ULONG TextSize = messageEntry->Length - FIELD_OFFSET(MESSAGE_RESOURCE_ENTRY, Text);
            GlobalMessageTable[EntryCount].MessageId = Count;
            GlobalMessageTable[EntryCount].MessageText = pStringBuffer;

            //
            // Send the message through our Formatting filter as it passes
            // into our global message structure.
            //
            SacFormatMessage( pStringBuffer, (PWSTR)messageEntry->Text, TextSize );

            ASSERT( (ULONG)(wcslen(pStringBuffer)*sizeof(WCHAR)) <= TextSize );

            pStringBuffer = (PWSTR)((ULONG_PTR)pStringBuffer + (ULONG_PTR)(TextSize));
            EntryCount += 1;
        }
    }

    Status = STATUS_SUCCESS;
                    
exit:
    IF_SAC_DEBUG(
        SAC_DEBUG_FUNC_TRACE, 
        KdPrint(("SAC PreloadGlobalMessageTable: Exiting with status 0x%0x.\n",
                Status)));

    return(Status);

}

NTSTATUS
TearDownGlobalMessageTable(
    VOID
    ) 
{
    IF_SAC_DEBUG(SAC_DEBUG_FUNC_TRACE, KdPrint(("SAC PreloadGlobalMessageTable: Entering.\n")));
    
    SAFE_FREE_POOL( &GlobalMessageTable );

    IF_SAC_DEBUG(
        SAC_DEBUG_FUNC_TRACE, 
        KdPrint(("SAC TearDownGlobalMessageTable: Exiting\n")));

    return(STATUS_SUCCESS);
}

PCWSTR
GetMessage(
    ULONG MessageId
    )
{
    PMESSAGE_TABLE_ENTRY pMessageTable;
    ULONG Count;
    
    if (!GlobalMessageTable) {
        return(NULL);
    }

    for (Count = 0; Count < GlobalMessageTableCount; Count++) {
        pMessageTable = &GlobalMessageTable[Count];
        if (pMessageTable->MessageId == MessageId) {
            return(pMessageTable->MessageText);
        }
    }

    ASSERT( FALSE );
    return(NULL);

}

NTSTATUS
UTF8EncodeAndSend(
    PCWSTR  OutputBuffer
    )
/*++

Routine Description:

    This is a convenience routine to simplify
    UFT8 encoding and sending a Unicode string.

Arguments:

    OutputBuffer    - the string to send

Return Value:

    Status

--*/
{
    NTSTATUS    Status;
    BOOLEAN     bStatus;
    ULONG       i;
    ULONG       TranslatedCount;
    ULONG       UTF8TranslationSize;

    Status = STATUS_SUCCESS;

    do {

        //
        // Display the output buffer
        //
        bStatus = SacTranslateUnicodeToUtf8(
            OutputBuffer,
            (ULONG)wcslen(OutputBuffer),
            (PUCHAR)Utf8ConversionBuffer,
            Utf8ConversionBufferSize,
            &UTF8TranslationSize,
            &TranslatedCount
            );
        
        if (! bStatus) {
            Status = STATUS_UNSUCCESSFUL;
            break;
        }

        //
        // Iterate through the uft8 buffer since
        // we can't be sure headless dispatch can
        // handle our entire string.
        //
        for (i = 0; i < UTF8TranslationSize; i ++) {

            Status = HeadlessDispatch(
                HeadlessCmdPutData,
                (PUCHAR)&(Utf8ConversionBuffer[i]),
                sizeof(UCHAR),
                NULL,
                NULL
                );
            if (! NT_SUCCESS(Status)) {
                break;
            }

        }
    
    } while ( FALSE );

    return Status;
}

BOOLEAN
SacTranslateUtf8ToUnicode(
    UCHAR  IncomingByte,
    UCHAR  *ExistingUtf8Buffer,
    WCHAR  *DestinationUnicodeVal
    )
/*++

Routine Description:

    Takes IncomingByte and concatenates it onto ExistingUtf8Buffer.
    Then attempts to decode the new contents of ExistingUtf8Buffer.

Arguments:

    IncomingByte -          New character to be appended onto
                            ExistingUtf8Buffer.


    ExistingUtf8Buffer -    running buffer containing incomplete UTF8
                            encoded unicode value.  When it gets full,
                            we'll decode the value and return the
                            corresponding Unicode value.

                            Note that if we *do* detect a completed UTF8
                            buffer and actually do a decode and return a
                            Unicode value, then we will zero-fill the
                            contents of ExistingUtf8Buffer.


    DestinationUnicodeVal - receives Unicode version of the UTF8 buffer.

                            Note that if we do *not* detect a completed
                            UTF8 buffer and thus can not return any data
                            in DestinationUnicodeValue, then we will
                            zero-fill the contents of DestinationUnicodeVal.


Return Value:

    TRUE - We received a terminating character for our UTF8 buffer and will
           return a decoded Unicode value in DestinationUnicode.

    FALSE - We haven't yet received a terminating character for our UTF8
            buffer.

--*/

{
//    ULONG Count = 0;
    ULONG i = 0;
    BOOLEAN ReturnValue = FALSE;



    //
    // Insert our byte into ExistingUtf8Buffer.
    //
    i = 0;
    do {
        if( ExistingUtf8Buffer[i] == 0 ) {
            ExistingUtf8Buffer[i] = IncomingByte;
            break;
        }

        i++;
    } while( i < 3 );

    //
    // If we didn't get to actually insert our IncomingByte,
    // then someone sent us a fully-qualified UTF8 buffer.
    // This means we're about to drop IncomingByte.
    //
    // Drop the zero-th byte, shift everything over by one
    // and insert our new character.
    //
    // This implies that we should *never* need to zero out
    // the contents of ExistingUtf8Buffer unless we detect
    // a completed UTF8 packet.  Otherwise, assume one of
    // these cases:
    // 1. We started listening mid-stream, so we caught the
    //    last half of a UTF8 packet.  In this case, we'll
    //    end up shifting the contents of ExistingUtf8Buffer
    //    until we detect a proper UTF8 start byte in the zero-th
    //    position.
    // 2. We got some garbage character, which would invalidate
    //    a UTF8 packet.  By using the logic below, we would
    //    end up disregarding that packet and waiting for
    //    the next UTF8 packet to come in.
    if( i >= 3 ) {
        ExistingUtf8Buffer[0] = ExistingUtf8Buffer[1];
        ExistingUtf8Buffer[1] = ExistingUtf8Buffer[2];
        ExistingUtf8Buffer[2] = IncomingByte;
    }

    //
    // Attempt to convert the UTF8 buffer
    //
    // UTF8 decodes to Unicode in the following fashion:
    // If the high-order bit is 0 in the first byte:
    //      0xxxxxxx yyyyyyyy zzzzzzzz decodes to a Unicode value of 00000000 0xxxxxxx
    //
    // If the high-order 3 bits in the first byte == 6:
    //      110xxxxx 10yyyyyy zzzzzzzz decodes to a Unicode value of 00000xxx xxyyyyyy
    //
    // If the high-order 3 bits in the first byte == 7:
    //      1110xxxx 10yyyyyy 10zzzzzz decodes to a Unicode value of xxxxyyyy yyzzzzzz
    //
    IF_SAC_DEBUG(
        SAC_DEBUG_FUNC_TRACE, 
        KdPrint(("SACDRV: SacTranslateUtf8ToUnicode - About to decode the UTF8 buffer.\n" ))
        );

    IF_SAC_DEBUG(
        SAC_DEBUG_FUNC_TRACE, 
        KdPrint(("                                  UTF8[0]: 0x%02lx UTF8[1]: 0x%02lx UTF8[2]: 0x%02lx\n",
            ExistingUtf8Buffer[0],
            ExistingUtf8Buffer[1],
            ExistingUtf8Buffer[2] ))
        );
    

    if( (ExistingUtf8Buffer[0] & 0x80) == 0 ) {

        IF_SAC_DEBUG(
            SAC_DEBUG_FUNC_TRACE, 
            KdPrint(("SACDRV: SacTranslateUtf8ToUnicode - Case1\n" ))
            );

        //
        // First case described above.  Just return the first byte
        // of our UTF8 buffer.
        //
        *DestinationUnicodeVal = (WCHAR)(ExistingUtf8Buffer[0]);


        //
        // We used 1 byte.  Discard that byte and shift everything
        // in our buffer over by 1.
        //
        ExistingUtf8Buffer[0] = ExistingUtf8Buffer[1];
        ExistingUtf8Buffer[1] = ExistingUtf8Buffer[2];
        ExistingUtf8Buffer[2] = 0;

        ReturnValue = TRUE;

    } else if( (ExistingUtf8Buffer[0] & 0xE0) == 0xC0 ) {

        IF_SAC_DEBUG(
            SAC_DEBUG_FUNC_TRACE, 
            KdPrint(("SACDRV: SacTranslateUtf8ToUnicode - 1st byte of UTF8 buffer says Case2\n"))
            );

        //
        // Second case described above.  Decode the first 2 bytes of
        // of our UTF8 buffer.
        //
        if( (ExistingUtf8Buffer[1] & 0xC0) == 0x80 ) {

            IF_SAC_DEBUG(
                SAC_DEBUG_FUNC_TRACE, 
                KdPrint(("SACDRV: SacTranslateUtf8ToUnicode - 2nd byte of UTF8 buffer says Case2.\n"))
                );

            // upper byte: 00000xxx
            *DestinationUnicodeVal = ((ExistingUtf8Buffer[0] >> 2) & 0x07);
            *DestinationUnicodeVal = *DestinationUnicodeVal << 8;

            // high bits of lower byte: xx000000
            *DestinationUnicodeVal |= ((ExistingUtf8Buffer[0] & 0x03) << 6);

            // low bits of lower byte: 00yyyyyy
            *DestinationUnicodeVal |= (ExistingUtf8Buffer[1] & 0x3F);


            //
            // We used 2 bytes.  Discard those bytes and shift everything
            // in our buffer over by 2.
            //
            ExistingUtf8Buffer[0] = ExistingUtf8Buffer[2];
            ExistingUtf8Buffer[1] = 0;
            ExistingUtf8Buffer[2] = 0;

            ReturnValue = TRUE;

        }
    } else if( (ExistingUtf8Buffer[0] & 0xF0) == 0xE0 ) {

        IF_SAC_DEBUG(
            SAC_DEBUG_FUNC_TRACE, 
            KdPrint(("SACDRV: SacTranslateUtf8ToUnicode - 1st byte of UTF8 buffer says Case3\n" ))
            );

        //
        // Third case described above.  Decode the all 3 bytes of
        // of our UTF8 buffer.
        //

        if( (ExistingUtf8Buffer[1] & 0xC0) == 0x80 ) {

            IF_SAC_DEBUG(
                SAC_DEBUG_FUNC_TRACE, 
                KdPrint(("SACDRV: SacTranslateUtf8ToUnicode - 2nd byte of UTF8 buffer says Case3\n" ))
                );

            if( (ExistingUtf8Buffer[2] & 0xC0) == 0x80 ) {

                IF_SAC_DEBUG(
                    SAC_DEBUG_FUNC_TRACE, 
                    KdPrint(("SACDRV: SacTranslateUtf8ToUnicode - 3rd byte of UTF8 buffer says Case3\n" ))
                    );

                // upper byte: xxxx0000
                *DestinationUnicodeVal = ((ExistingUtf8Buffer[0] << 4) & 0xF0);

                // upper byte: 0000yyyy
                *DestinationUnicodeVal |= ((ExistingUtf8Buffer[1] >> 2) & 0x0F);

                *DestinationUnicodeVal = *DestinationUnicodeVal << 8;

                // lower byte: yy000000
                *DestinationUnicodeVal |= ((ExistingUtf8Buffer[1] << 6) & 0xC0);

                // lower byte: 00zzzzzz
                *DestinationUnicodeVal |= (ExistingUtf8Buffer[2] & 0x3F);

                //
                // We used all 3 bytes.  Zero out the buffer.
                //
                ExistingUtf8Buffer[0] = 0;
                ExistingUtf8Buffer[1] = 0;
                ExistingUtf8Buffer[2] = 0;

                ReturnValue = TRUE;

            }
        }
    }

    return ReturnValue;
}

BOOLEAN
SacTranslateUnicodeToUtf8(
    IN  PCWSTR   SourceBuffer,
    IN  ULONG    SourceBufferLength,
    IN  PUCHAR   DestinationBuffer,
    IN  ULONG    DestinationBufferSize,
    OUT PULONG   UTF8Count,
    OUT PULONG   ProcessedCount
    )
/*++

Routine Description:

    This routine translates a Unicode string into a UFT8
    encoded string.

    Note: if the destination buffer is not large enough to hold
          the entire encoded UFT8 string, then it will contain
          as much as can fit.
          
    TODO: this routine should return some notification if
          the entire Unicode string was not encoded.       
              
Arguments:

    SourceBuffer            - the source Unicode string
    SourceBufferLength      - the # of characters the caller wants to translate
                              note: a NULL termination overrides this 
    DestinationBuffer       - the destination for the UTF8 string
    DestinationBufferSize   - the size of the destination buffer                 
    UTF8Count               - on exit, contains the # of resulting UTF8 characters
    ProcessedCount          - on exit, contains the # of processed Unicode characters
                   
Return Value:

    Status

--*/
{
    
    //
    // Init
    //
    *UTF8Count = 0;
    *ProcessedCount = 0;

    //
    // convert into UTF8 for actual transmission
    //
    // UTF-8 encodes 2-byte Unicode characters as follows:
    // If the first nine bits are zero (00000000 0xxxxxxx), encode it as one byte 0xxxxxxx
    // If the first five bits are zero (00000yyy yyxxxxxx), encode it as two bytes 110yyyyy 10xxxxxx
    // Otherwise (zzzzyyyy yyxxxxxx), encode it as three bytes 1110zzzz 10yyyyyy 10xxxxxx
    //
    
    //
    // Process until one of the specified conditions is met
    //
    while (*SourceBuffer && 
           (*UTF8Count < DestinationBufferSize) &&
           (*ProcessedCount < SourceBufferLength)
           ) {

        if( (*SourceBuffer & 0xFF80) == 0 ) {
            
            //
            // if the top 9 bits are zero, then just
            // encode as 1 byte.  (ASCII passes through unchanged).
            //
            DestinationBuffer[(*UTF8Count)++] = (UCHAR)(*SourceBuffer & 0x7F);
        
        } else if( (*SourceBuffer & 0xF800) == 0 ) {
            
            //
            // see if we pass the end of the buffer
            //
            if ((*UTF8Count + 2) >= DestinationBufferSize) {
                break;
            }

            //
            // if the top 5 bits are zero, then encode as 2 bytes
            //
            DestinationBuffer[(*UTF8Count)++] = (UCHAR)((*SourceBuffer >> 6) & 0x1F) | 0xC0;
            DestinationBuffer[(*UTF8Count)++] = (UCHAR)(*SourceBuffer & 0xBF) | 0x80;
        
        } else {
            
            //
            // see if we pass the end of the buffer
            //
            if ((*UTF8Count + 3) >= DestinationBufferSize) {
                break;
            }
            
            //
            // encode as 3 bytes
            //
            DestinationBuffer[(*UTF8Count)++] = (UCHAR)((*SourceBuffer >> 12) & 0xF) | 0xE0;
            DestinationBuffer[(*UTF8Count)++] = (UCHAR)((*SourceBuffer >> 6) & 0x3F) | 0x80;
            DestinationBuffer[(*UTF8Count)++] = (UCHAR)(*SourceBuffer & 0xBF) | 0x80;
        
        }
        
        //
        // Advance the # of characters processed
        //
        (*ProcessedCount)++;
        
        //
        // Advanced to the next character to process
        //
        SourceBuffer += 1;
    
    }

    //
    // Sanity checks
    //
    ASSERT(*ProcessedCount <= SourceBufferLength);
    ASSERT(*UTF8Count <= DestinationBufferSize);

    return(TRUE);

}

VOID
AppendMessage(
    PWSTR       OutPutBuffer,
    ULONG       MessageId,
    PWSTR       ValueBuffer OPTIONAL
    )
/*++

Routine Description:

    This function will insert the valuestring into the specified message, then
    concatenate the resulting string onto the OutPutBuffer.

Arguments:
    
    OutPutBuffer    The resulting String.

    MessageId       ID of the formatting message to use.

    ValueBUffer     Value string to be inserted into the message.

Return Value:

    NONE

--*/
{
    PWSTR       MyTemporaryBuffer = NULL;
    PCWSTR      p;

    IF_SAC_DEBUG(SAC_DEBUG_FUNC_TRACE, 
                      KdPrint(("SAC AppendMessage: Entering.\n")));

    p = GetMessage(MessageId);

    if( p == NULL ) {
        return;
    }

    if( ValueBuffer == NULL ) {

        wcscat( OutPutBuffer, p );

    } else {

        MyTemporaryBuffer = (PWSTR)(wcschr(OutPutBuffer, L'\0'));
        if( MyTemporaryBuffer == NULL ) {
            MyTemporaryBuffer = OutPutBuffer;
        }

        swprintf( MyTemporaryBuffer, p, ValueBuffer );
    }

    IF_SAC_DEBUG(SAC_DEBUG_FUNC_TRACE, 
                      KdPrint(("SAC AppendMessage: Entering.\n")));

    return;
}


NTSTATUS
GetRegistryValueBuffer(
    PWSTR       KeyName,
    PWSTR       ValueName,
    PKEY_VALUE_PARTIAL_INFORMATION* ValueBuffer
    )
/*++

Routine Description:

    This function will go query the registry and pull the specified Value.

Arguments:
    
    KeyName         Name of the registry key we'll be querying.

    ValueName       Name of the registry value we'll be querying.

    ValueBuffer     On success, contains value 

Return Value:

    NTSTATUS.

--*/
{
    NTSTATUS            Status = STATUS_SUCCESS;
    ULONG               KeyValueLength;
    OBJECT_ATTRIBUTES   Obja;
    UNICODE_STRING      UnicodeString;
    HANDLE              KeyHandle;

    IF_SAC_DEBUG(
        SAC_DEBUG_FUNC_TRACE, 
        KdPrint(("SAC GetRegistryValueBuffer: Entering.\n"))
        );

    ASSERT_STATUS(KeyName, STATUS_INVALID_PARAMETER_1);
    ASSERT_STATUS(ValueName, STATUS_INVALID_PARAMETER_2);
    
    do {

        //
        // Get the reg key handle
        //
        INIT_OBJA( &Obja, &UnicodeString, KeyName );

        Status = ZwOpenKey( 
            &KeyHandle,
            KEY_READ,
            &Obja 
            );

        if( !NT_SUCCESS(Status) ) {

            IF_SAC_DEBUG(
                SAC_DEBUG_FUNC_TRACE, 
                KdPrint(("SAC GetRegistryValueBuffer: failed ZwOpenKey: %X\n", Status))
                );

            return Status;

        }

        //
        // Get the value buffer size
        //
        RtlInitUnicodeString( &UnicodeString, ValueName );
        
        KeyValueLength = 0;
        
        Status = ZwQueryValueKey( 
            KeyHandle,
            &UnicodeString,
            KeyValuePartialInformation,
            (PVOID)NULL,
            0,
            &KeyValueLength 
            );

        if( KeyValueLength == 0 ) {
            
            IF_SAC_DEBUG(
                SAC_DEBUG_FUNC_TRACE, 
                KdPrint(("SAC GetRegistryValueBuffer: failed ZwQueryValueKey: %X\n", Status))
                );
            
            break;
        }

        //
        // Allocate the value buffer
        //
        KeyValueLength += 4;

        *ValueBuffer = (PKEY_VALUE_PARTIAL_INFORMATION)ALLOCATE_POOL( KeyValueLength, GENERAL_POOL_TAG );

        if( *ValueBuffer == NULL ) {
            
            IF_SAC_DEBUG(
                SAC_DEBUG_FUNC_TRACE, 
                KdPrint(("SAC GetRegistryValueBuffer: failed allocation\n"))
                );
            
            break;
        }

        //
        // Get the value
        //
        Status = ZwQueryValueKey( 
            KeyHandle,
            &UnicodeString,
            KeyValuePartialInformation,
            *ValueBuffer,
            KeyValueLength,
            &KeyValueLength 
            );

        if( !NT_SUCCESS(Status) ) {

            IF_SAC_DEBUG(
                SAC_DEBUG_FUNC_TRACE, 
                KdPrint(("SAC GetRegistryValueBuffer: failed ZwQueryValueKey: %X\n", Status))
                );

            FREE_POOL( ValueBuffer );
            
            break;
        
        }
    
    } while ( FALSE );

    //
    // We are done with the reg key
    //
    NtClose(KeyHandle);

    IF_SAC_DEBUG(
        SAC_DEBUG_FUNC_TRACE, 
        KdPrint(("SAC GetRegistryValueBuffer: Exiting.\n"))
        );

    return Status;

}

NTSTATUS
SetRegistryValue(
    IN PWSTR    KeyName,
    IN PWSTR    ValueName,
    IN ULONG    Type,
    IN PVOID    Data,
    IN ULONG    DataSize
    )
/*++

Routine Description:

    This function will set the specified registry key value.

Arguments:
    
    KeyName         Name of the registry key we'll be querying.
    ValueName       Name of the registry value we'll be querying.
    Type            Registry value type
    Data            New value data
    DataSize        Size of the new value data

Return Value:

    NTSTATUS.

--*/
{
    NTSTATUS            Status;
    OBJECT_ATTRIBUTES   Obja;
    UNICODE_STRING      UnicodeString;
    HANDLE              KeyHandle;

    IF_SAC_DEBUG(
        SAC_DEBUG_FUNC_TRACE, 
        KdPrint(("SAC SetRegistryValue: Entering.\n"))
        );

    ASSERT_STATUS(KeyName, STATUS_INVALID_PARAMETER_1);
    ASSERT_STATUS(ValueName, STATUS_INVALID_PARAMETER_2);
    ASSERT_STATUS(Data, STATUS_INVALID_PARAMETER_4);

    do {

        //
        // Get the reg key handle
        //
        INIT_OBJA( &Obja, &UnicodeString, KeyName );

        Status = ZwOpenKey( 
            &KeyHandle,
            KEY_WRITE,
            &Obja 
            );

        if( !NT_SUCCESS(Status) ) {

            IF_SAC_DEBUG(
                SAC_DEBUG_FUNC_TRACE, 
                KdPrint(("SAC SetRegistryValue: failed ZwOpenKey: %X.\n", Status))
                );
                
            return Status;

        }

        //
        // Set the value 
        //
        RtlInitUnicodeString( &UnicodeString, ValueName );

        Status = ZwSetValueKey( 
            KeyHandle,
            &UnicodeString,
            0,
            Type,
            Data,
            DataSize
            );

        if( !NT_SUCCESS(Status) ) {

            IF_SAC_DEBUG(
                SAC_DEBUG_FUNC_TRACE, 
                KdPrint(("SAC SetRegistryValue: failed ZwSetValueKey: %X\n", Status))
                );

            break;
        
        }
    
    } while ( FALSE );

    //
    // We are done with the reg key
    //
    NtClose(KeyHandle);
    
    IF_SAC_DEBUG(
        SAC_DEBUG_FUNC_TRACE, 
        KdPrint(("SAC SetRegistryValue: Exiting.\n"))
        );

    return Status;

}

NTSTATUS
CopyRegistryValueData(
    PVOID*                          Dest,
    PKEY_VALUE_PARTIAL_INFORMATION  ValueBuffer
    )
/*++

Routine Description:

    This routine allocates and copies the specified registry value data 

Arguments:

    Dest        - on success, contains the value data copy
    ValueBuffer - contains the value data    
    
Return Value:

    Status                                         
                                         
--*/
{
    NTSTATUS    Status;

    Status = STATUS_SUCCESS;

    ASSERT_STATUS(Dest, STATUS_INVALID_PARAMETER_1);
    ASSERT_STATUS(ValueBuffer, STATUS_INVALID_PARAMETER_2);
    
    do {

        *Dest = (PVOID)ALLOCATE_POOL(ValueBuffer->DataLength, GENERAL_POOL_TAG);

        if (*Dest == NULL) {
            IF_SAC_DEBUG(SAC_DEBUG_FUNC_TRACE, KdPrint(("SAC CopyRegistryValueBuffer: Failed ALLOCATE.\n")));
            Status = STATUS_NO_MEMORY;
            break;
        }

        RtlCopyMemory(*Dest, ValueBuffer->Data, ValueBuffer->DataLength);
    
    } while (FALSE);

    return Status;

}

NTSTATUS
TranslateMachineInformationText(
    PWSTR*  Buffer
    )
/*++

Routine Description:

    This routine creates a formated text string representing 
    the current machine info
    
Arguments:
    
    Buffer          - Contains the machine info string

Return Value:

    Status

--*/
{
    NTSTATUS    Status;
    PCWSTR      pwStr;
    PWSTR       pBuffer;
    ULONG       len;
    ULONG       Size;

#define MITEXT_SPRINTF(_s,_t)               \
    pwStr = GetMessage(_s);                 \
    if (pwStr && MachineInformation->_t) {  \
        len = swprintf(                     \
            pBuffer,                        \
            pwStr,                          \
            MachineInformation->_t          \
            );                              \
        pBuffer += len;                     \
    }                                       

#define MITEXT_LENGTH(_s,_t)                \
    pwStr = GetMessage(_s);                 \
    if (pwStr && MachineInformation->_t) {  \
        len += (ULONG)wcslen(MachineInformation->_t) + (ULONG)wcslen(pwStr);  \
    }                                       

    ASSERT_STATUS(Buffer, STATUS_INVALID_PARAMETER_1);

    //
    // default: we succeeded
    //
    Status = STATUS_SUCCESS;

    //
    // Assemble the machine info
    //
    do {

        //
        // compute the length of the final string so
        // we know how much memory to allocate
        //
        {
            len = 0;

            MITEXT_LENGTH(SAC_MACHINEINFO_COMPUTERNAME,            MachineName);
            MITEXT_LENGTH(SAC_MACHINEINFO_GUID,                    GUID);
            MITEXT_LENGTH(SAC_MACHINEINFO_PROCESSOR_ARCHITECTURE,  ProcessorArchitecture);
            MITEXT_LENGTH(SAC_MACHINEINFO_OS_VERSION,              OSVersion);
            MITEXT_LENGTH(SAC_MACHINEINFO_OS_BUILD,                OSBuildNumber);
            MITEXT_LENGTH(SAC_MACHINEINFO_OS_PRODUCTTYPE,          OSProductType);
            MITEXT_LENGTH(SAC_MACHINEINFO_SERVICE_PACK,            OSServicePack);

            //
            // compute the size; include NULL termination
            //
            Size = (len + 1) * sizeof(WCHAR);
        }
        
        *Buffer = ALLOCATE_POOL(Size, GENERAL_POOL_TAG);
        if( *Buffer == NULL ) {
            Status = STATUS_NO_MEMORY;
            break;
        }

        pBuffer = *Buffer;

        MITEXT_SPRINTF(SAC_MACHINEINFO_COMPUTERNAME,            MachineName);
        MITEXT_SPRINTF(SAC_MACHINEINFO_GUID,                    GUID);
        MITEXT_SPRINTF(SAC_MACHINEINFO_PROCESSOR_ARCHITECTURE,  ProcessorArchitecture);
        MITEXT_SPRINTF(SAC_MACHINEINFO_OS_VERSION,              OSVersion);
        MITEXT_SPRINTF(SAC_MACHINEINFO_OS_BUILD,                OSBuildNumber);
        MITEXT_SPRINTF(SAC_MACHINEINFO_OS_PRODUCTTYPE,          OSProductType);
        MITEXT_SPRINTF(SAC_MACHINEINFO_SERVICE_PACK,            OSServicePack);

        ASSERT((ULONG)((wcslen(*Buffer) + 1) * sizeof(WCHAR)) <= Size);

    } while ( FALSE );
    
    if (!NT_SUCCESS(Status) && *Buffer != NULL) {
        FREE_POOL(Buffer);
        *Buffer = NULL;
    } 

    return Status;
}


NTSTATUS
TranslateMachineInformationXML(
    OUT PWSTR*  Buffer,
    IN  PWSTR   AdditionalInfo
    )
/*++

Routine Description:

    This routine creates an XML string representing the current machine info
    
Arguments:
    
    Buffer          - Contains the machine info string
    AdditionalInfo  - Additional Machine Info wanted to be included by caller   
                      Note: additional info should be a well-formed xml string:
                            e.g. <uptime>01:01:01</uptime>

Return Value:

    Status

--*/
{
    NTSTATUS    Status;
    PCWSTR      pwStr;
    PWSTR       pBuffer;
    ULONG       len;
    ULONG       Size;

#define MIXML_SPRINTF(_s,_t)                \
    pwStr = _s;                             \
    if (pwStr && MachineInformation->_t) {  \
        len = swprintf(                     \
            pBuffer,                        \
            pwStr,                          \
            MachineInformation->_t          \
            );                              \
        pBuffer += len;                     \
    }                                       

#define XML_MACHINEINFO_HEADER                      L"<machine-info>\r\n"
#define XML_MACHINEINFO_NAME                        L"<name>%s</name>\r\n"
#define XML_MACHINEINFO_GUID                        L"<guid>%s</guid>\r\n"        
#define XML_MACHINEINFO_PROCESSOR_ARCHITECTURE      L"<processor-architecture>%s</processor-architecture>\r\n"
#define XML_MACHINEINFO_OS_VERSION                  L"<os-version>%s</os-version>\r\n"
#define XML_MACHINEINFO_OS_BUILD                    L"<os-build-number>%s</os-build-number>\r\n"
#define XML_MACHINEINFO_OS_PRODUCTTYPE              L"<os-product>%s</os-product>\r\n"
#define XML_MACHINEINFO_SERVICE_PACK                L"<os-service-pack>%s</os-service-pack>\r\n"
#define XML_MACHINEINFO_FOOTER                      L"</machine-info>\r\n"

    ASSERT_STATUS(Buffer, STATUS_INVALID_PARAMETER_1);
    
    //
    // default: we succeeded
    //
    Status = STATUS_SUCCESS;

    //
    // Assemble the machine info
    //
    do {

        //
        // compute the length of the final string so
        // we know how much memory to allocate
        //
        {
            len = (ULONG)wcslen(XML_MACHINEINFO_HEADER);

            if (MachineInformation->MachineName) {
                len += (ULONG)wcslen(MachineInformation->MachineName);
                len += (ULONG)wcslen(XML_MACHINEINFO_NAME);
            }
            if (MachineInformation->GUID) {
                len += (ULONG)wcslen(MachineInformation->GUID);
                len += (ULONG)wcslen(XML_MACHINEINFO_GUID);
            }
            if (MachineInformation->ProcessorArchitecture) {
                len += (ULONG)wcslen(MachineInformation->ProcessorArchitecture);
                len += (ULONG)wcslen(XML_MACHINEINFO_PROCESSOR_ARCHITECTURE);
            }
            if (MachineInformation->OSVersion) {
                len += (ULONG)wcslen(MachineInformation->OSVersion);
                len += (ULONG)wcslen(XML_MACHINEINFO_OS_VERSION);
            }
            if (MachineInformation->OSBuildNumber) {
                len += (ULONG)wcslen(MachineInformation->OSBuildNumber);
                len += (ULONG)wcslen(XML_MACHINEINFO_OS_BUILD);
            }
            if (MachineInformation->OSProductType) {
                len += (ULONG)wcslen(MachineInformation->OSProductType);
                len += (ULONG)wcslen(XML_MACHINEINFO_OS_PRODUCTTYPE);
            }
            if (MachineInformation->OSServicePack) {
                len += (ULONG)wcslen(MachineInformation->OSServicePack);
                len += (ULONG)wcslen(XML_MACHINEINFO_SERVICE_PACK);
            }

            //
            // If the caller passed additional machine info, 
            // then account for the additional len
            //
            if (AdditionalInfo) {
                len += (ULONG)wcslen(AdditionalInfo);
            }

            len += (ULONG)wcslen(XML_MACHINEINFO_FOOTER);

            //
            // compute the size; include NULL termination
            //
            Size = (len + 1) * sizeof(WCHAR);
        }

        //
        // Allocate the machine info buffer
        //
        *Buffer = ALLOCATE_POOL(Size, GENERAL_POOL_TAG);
        if( *Buffer == NULL ) {
            Status = STATUS_NO_MEMORY;
            break;
        }

        pBuffer = *Buffer;

        len = (ULONG)wcslen(XML_MACHINEINFO_HEADER);
        wcscpy(pBuffer, XML_MACHINEINFO_HEADER);
        pBuffer += len;

        MIXML_SPRINTF(XML_MACHINEINFO_NAME,                    MachineName);
        MIXML_SPRINTF(XML_MACHINEINFO_GUID,                    GUID);
        MIXML_SPRINTF(XML_MACHINEINFO_PROCESSOR_ARCHITECTURE,  ProcessorArchitecture);
        MIXML_SPRINTF(XML_MACHINEINFO_OS_VERSION,              OSVersion);
        MIXML_SPRINTF(XML_MACHINEINFO_OS_BUILD,                OSBuildNumber);
        MIXML_SPRINTF(XML_MACHINEINFO_OS_PRODUCTTYPE,          OSProductType);
        MIXML_SPRINTF(XML_MACHINEINFO_SERVICE_PACK,            OSServicePack);

        //
        // If present, include the additional info
        //
        if (AdditionalInfo) {
            
            len = (ULONG)wcslen(AdditionalInfo);
            wcscpy(pBuffer, AdditionalInfo);
            pBuffer += len;                     
        
        }

        wcscpy(pBuffer, XML_MACHINEINFO_FOOTER);

        ASSERT((((ULONG)wcslen(*Buffer) + 1) * sizeof(WCHAR)) <= Size);

    } while ( FALSE );
    
    if (!NT_SUCCESS(Status) && *Buffer != NULL) {
        FREE_POOL(Buffer);
        *Buffer = NULL;
    }

    return Status;
}

NTSTATUS
RegisterBlueScreenMachineInformation(
    VOID
    )
/*++

Routine Description:

    This routine populates Headless Dispatch Blue Screen handler
    with the XML representation machine information
    
Arguments:
    
    None.

Return Value:

    Status

--*/
{
    
    PHEADLESS_CMD_SET_BLUE_SCREEN_DATA BSBuffer;
    PWSTR       XMLBuffer;
    ULONG       XMLBufferLength;
    NTSTATUS    Status;
    ULONG       Size;
    PSTR        XML_TAG = "MACHINEINFO";
    ULONG       XML_TAG_LENGTH;

    //
    // Get the XML representation of the machine info
    //

    Status = TranslateMachineInformationXML(&XMLBuffer, NULL);

    ASSERT_STATUS(NT_SUCCESS(Status), Status);
    ASSERT_STATUS(XMLBuffer, STATUS_UNSUCCESSFUL);

    //
    // Determine the lengths of the strings we'll use
    //
    XMLBufferLength = (ULONG)wcslen(XMLBuffer);
    XML_TAG_LENGTH  = (ULONG)strlen(XML_TAG);

    //
    // Allocate the BS Buffer
    //
    // Need to accomodate:
    //
    // HEADLESS_CMD_SET_BLUE_SCREEN_DATA + XML_TAG\0XMLBuffer\0
    //
    Size = sizeof(HEADLESS_CMD_SET_BLUE_SCREEN_DATA) + 
        (XML_TAG_LENGTH*sizeof(UCHAR)) + sizeof(UCHAR) + 
        (XMLBufferLength*sizeof(UCHAR)) + sizeof(UCHAR);

    BSBuffer = (PHEADLESS_CMD_SET_BLUE_SCREEN_DATA)ALLOCATE_POOL( 
        Size,
        GENERAL_POOL_TAG 
        );

    if (!BSBuffer) {
        FREE_POOL(&XMLBuffer);
    }

    ASSERT_STATUS(BSBuffer, STATUS_NO_MEMORY);

    //
    // Copy the XML Buffer into the BS Buffer as an ANSI string
    //
    
    {
        PUCHAR      pch;
        ULONG       i;

        //
        // Get the BScreen buffer
        //
        pch = &(BSBuffer->Data[0]);

        //
        // Insert the XML Tag (required for HeadlessDispatch)
        //
        strcpy((char *)pch, XML_TAG);

        //
        // Move to the beginning of the XML buffer region
        //
        BSBuffer->ValueIndex = XML_TAG_LENGTH+1;
        pch += XML_TAG_LENGTH+1;

        //
        // Write the WCHAR XMLBuffer as ANSI into the BSBuffer
        // 
        for (i = 0; i < XMLBufferLength; i++) {
            pch[i] = (UCHAR)XMLBuffer[i];
        }
        pch[i] = '\0';
    
    }

    //
    // ========
    // Insert it all into the BLUESCREEN data.
    // ========
    //
    Status = HeadlessDispatch( 
        HeadlessCmdSetBlueScreenData,
        BSBuffer,
        Size,
        NULL,
        0
        );

    //
    // clean up
    //
    FREE_POOL( &BSBuffer );
    FREE_POOL( &XMLBuffer);

    IF_SAC_DEBUG(
        SAC_DEBUG_FUNC_TRACE, 
        KdPrint(("SAC Initialize Machine Information: Exiting.\n"))
        );
    
    return Status;

}

VOID
FreeMachineInformation(
    VOID
    )
/*++

Routine Description:

    This routine releases the machine information collected at driver startup

Arguments:

    None

Return Value:
    
    None

--*/
{
    
    //
    // The information should be present
    //
    ASSERT(MachineInformation);
    if (!MachineInformation) {
        return;
    }

    SAFE_FREE_POOL(&MachineInformation->MachineName);
    SAFE_FREE_POOL(&MachineInformation->GUID);
    SAFE_FREE_POOL(&MachineInformation->ProcessorArchitecture);
    SAFE_FREE_POOL(&MachineInformation->OSVersion);
    SAFE_FREE_POOL(&MachineInformation->OSBuildNumber);
    SAFE_FREE_POOL(&MachineInformation->OSProductType);
    SAFE_FREE_POOL(&MachineInformation->OSServicePack);

}

VOID
InitializeMachineInformation(
    VOID
    )
/*++

Routine Description:

    This function initializes the global variable MachineInformationBuffer.

    We'll gather a whole bunch of information about the machine and fill
    in the buffer.

Arguments:
    
    None.

Return Value:

    None.

--*/
{
    PWSTR   COMPUTERNAME_KEY_NAME  = L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\ComputerName\\ComputerName";
    PWSTR   COMPUTERNAME_VALUE_NAME  = L"ComputerName";
    PWSTR   PROCESSOR_ARCHITECTURE_KEY_NAME  = L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Session Manager\\Environment";
    PWSTR   PROCESSOR_ARCHITECTURE_VALUE_NAME  = L"PROCESSOR_ARCHITECTURE";
    PWSTR   SETUP_KEY_NAME = L"\\Registry\\Machine\\System\\Setup";
    PWSTR   SETUPINPROGRESS_VALUE_NAME = L"SystemSetupInProgress";


    RTL_OSVERSIONINFOEXW            VersionInfo;
    PKEY_VALUE_PARTIAL_INFORMATION  ValueBuffer;
    NTSTATUS                        Status = STATUS_SUCCESS;
    SIZE_T                          i;
    PWSTR                           MyTemporaryBufferW = NULL;
    GUID                            MyGUID;
    PCWSTR                          pwStr;
    BOOLEAN                         InGuiModeSetup = FALSE;

    IF_SAC_DEBUG(
        SAC_DEBUG_FUNC_TRACE, 
        KdPrint(("SAC Initialize Machine Information: Entering.\n"))
        );

    if( MachineInformation != NULL ) {

        //
        // someone called us again!
        //
        IF_SAC_DEBUG( 
            SAC_DEBUG_FUNC_TRACE_LOUD, 
            KdPrint(("SAC Initialize Machine Information:: MachineInformationBuffer already initialzied.\n"))
            );

        return;
    
    } else {

        MachineInformation = (PMACHINE_INFORMATION)ALLOCATE_POOL( sizeof(MACHINE_INFORMATION), GENERAL_POOL_TAG );

        if( MachineInformation == NULL ) {

            goto InitializeMachineInformation_Failure;
        
        }
    
    }

    RtlZeroMemory( MachineInformation, sizeof(MACHINE_INFORMATION) );

    //
    // We're real early in the boot process, so we're going to take for granted that the machine hasn't
    // bugchecked.  This means that we can safely call some kernel functions to go figure out what
    // platform we're running on.
    //
    RtlZeroMemory( &VersionInfo, sizeof(VersionInfo));
    
    Status = RtlGetVersion( (POSVERSIONINFOW)&VersionInfo );

    if( !NT_SUCCESS(Status) ) {

        IF_SAC_DEBUG(
            SAC_DEBUG_FUNC_TRACE, 
            KdPrint(("SAC InitializeMachineInformation: Exiting (2).\n"))
            );
        
        goto InitializeMachineInformation_Failure;
    
    }



    //
    // See if we're in gui-mode setup.  We may need this info later.
    //
    Status = GetRegistryValueBuffer(
        SETUP_KEY_NAME,
        SETUPINPROGRESS_VALUE_NAME,
        &ValueBuffer
        );
    if( NT_SUCCESS(Status) ) {

        //
        // See if it's 0 (we're not in Setup) or non-zero (we're in Setup)
        //
        if( *((PULONG)(ValueBuffer->Data)) != 0 ) {
            InGuiModeSetup = TRUE;
        }

        FREE_POOL(&ValueBuffer);
    }



    //
    // ========
    // Machine name.
    // ========
    //

    if( InGuiModeSetup ) {
        //
        // The machine name hasn't been initialized by the Setup process,
        // so use some predefined string for the manchine name.
        //
        MachineInformation->MachineName = ALLOCATE_POOL(((ULONG)wcslen((PWSTR)GetMessage(SAC_DEFAULT_MACHINENAME))+1) * sizeof(WCHAR), GENERAL_POOL_TAG);
        if( MachineInformation->MachineName ) {
            wcscpy( MachineInformation->MachineName, GetMessage(SAC_DEFAULT_MACHINENAME) );
        }
    } else {
        //
        // We are not in Guimode setup, so go dig the machinename
        // out of the registry.
        //
        Status = GetRegistryValueBuffer(
            COMPUTERNAME_KEY_NAME,
            COMPUTERNAME_VALUE_NAME,
            &ValueBuffer
            );
            
        if( NT_SUCCESS(Status) ) {
    
            //
            // we successfully retrieved the machine name
            //
    
            Status = CopyRegistryValueData(
                &(MachineInformation->MachineName),
                ValueBuffer
                );
    
            FREE_POOL(&ValueBuffer);
    
            if( !NT_SUCCESS(Status) ) {
    
                IF_SAC_DEBUG(
                    SAC_DEBUG_FUNC_TRACE, 
                    KdPrint(("SAC InitializeMachineInformation: Exiting (20).\n"))
                    );
    
                goto InitializeMachineInformation_Failure;
    
            }
        
        } else {
    
            IF_SAC_DEBUG(
                SAC_DEBUG_FUNC_TRACE, 
                KdPrint(("SAC InitializeMachineInformation: Failed to get machine name.\n"))
                );
    
        }
    }


    //
    // ========
    // Machine GUID.
    // ========
    //

    // make sure.
    RtlZeroMemory( &MyGUID, sizeof(GUID) );
    i = sizeof(GUID);
    Status = HeadlessDispatch( HeadlessCmdQueryGUID,
                               NULL,
                               0,
                               &MyGUID,
                               &i );
    
    if( NT_SUCCESS(Status) ) {

        MyTemporaryBufferW = (PWSTR)ALLOCATE_POOL( ((sizeof(GUID)*2) + 8) * sizeof(WCHAR) , GENERAL_POOL_TAG );

        if( MyTemporaryBufferW == NULL ) {

            IF_SAC_DEBUG(
                SAC_DEBUG_FUNC_TRACE, 
                KdPrint(("SAC InitializeMachineInformation: Exiting (31).\n"))
                );

            goto InitializeMachineInformation_Failure;

        }

        swprintf( MyTemporaryBufferW,
                  L"%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
                  MyGUID.Data1,
                  MyGUID.Data2,
                  MyGUID.Data3,
                  MyGUID.Data4[0],
                  MyGUID.Data4[1],
                  MyGUID.Data4[2],
                  MyGUID.Data4[3],
                  MyGUID.Data4[4],
                  MyGUID.Data4[5],
                  MyGUID.Data4[6],
                  MyGUID.Data4[7] );

        MachineInformation->GUID = MyTemporaryBufferW;
    
    } else {
        
        IF_SAC_DEBUG(
            SAC_DEBUG_FUNC_TRACE, 
            KdPrint(("SAC InitializeMachineInformation: Failed to get Machine GUID.\n"))
            );
        
    }

    //
    // ========
    // Processor Architecture.
    // ========
    //
    
    Status = GetRegistryValueBuffer(
        PROCESSOR_ARCHITECTURE_KEY_NAME,
        PROCESSOR_ARCHITECTURE_VALUE_NAME,
        &ValueBuffer
        );
    
    if( NT_SUCCESS(Status) ) {
    
        Status = CopyRegistryValueData(
            &(MachineInformation->ProcessorArchitecture),
            ValueBuffer
            );

        FREE_POOL(&ValueBuffer);

        if( !NT_SUCCESS(Status) ) {

            IF_SAC_DEBUG(
                SAC_DEBUG_FUNC_TRACE, 
                KdPrint(("SAC InitializeMachineInformation: Exiting (30).\n"))
                );

            goto InitializeMachineInformation_Failure;

        }

    } else {
        
        IF_SAC_DEBUG(
            SAC_DEBUG_FUNC_TRACE, 
            KdPrint(("SAC InitializeMachineInformation: Exiting (30).\n"))
            );
    
    }
    
    //
    // ========
    // OS Name.
    // ========
    //

    //
    // Allocate enough memory for the formatting message, plus the size of 2 digits.
    // Currently, our versioning info is of the type "5.1", so we don't need much space
    // here, but let's be conservative and assume both major and minor version numbers
    // are 5 digits in size.  That's 11 characters.
    //
    // allow xxxxx.xxxxx
    //
    MyTemporaryBufferW = (PWSTR)ALLOCATE_POOL( (5 + 1 + 5 + 1) * sizeof(WCHAR), GENERAL_POOL_TAG );
    
    if( MyTemporaryBufferW == NULL ) {

        IF_SAC_DEBUG(
            SAC_DEBUG_FUNC_TRACE, 
            KdPrint(("SAC InitializeMachineInformation: Exiting (50).\n"))
            );
        
        goto InitializeMachineInformation_Failure;
    
    }

    swprintf( MyTemporaryBufferW,
              L"%d.%d",
              VersionInfo.dwMajorVersion,
              VersionInfo.dwMinorVersion );

    MachineInformation->OSVersion = MyTemporaryBufferW;

    //
    // ========
    // Build Number.
    // ========
    //

    //
    // Allocate enough memory for the formatting message, plus the size of our build number.
    // Currently that's well below the 5-digit mark, but let's build some headroom here for
    // build numbers up to 99000 (5-digits).
    //
    MyTemporaryBufferW = (PWSTR)ALLOCATE_POOL( ( 5 + 1 ) * sizeof(WCHAR), GENERAL_POOL_TAG );
    
    if( MyTemporaryBufferW == NULL ) {

        IF_SAC_DEBUG(
            SAC_DEBUG_FUNC_TRACE, 
            KdPrint(("SAC InitializeMachineInformation: Exiting (60).\n"))
            );
        
        goto InitializeMachineInformation_Failure;
    
    }

    swprintf( MyTemporaryBufferW,
              L"%d",
              VersionInfo.dwBuildNumber );

    MachineInformation->OSBuildNumber = MyTemporaryBufferW;

    //
    // ========
    // Product Type (and Suite).
    // ========
    //
    if( ExVerifySuite(DataCenter) ) {

        pwStr = (PWSTR)GetMessage(SAC_MACHINEINFO_DATACENTER);

    } else if( ExVerifySuite(EmbeddedNT) ) {

        pwStr = GetMessage(SAC_MACHINEINFO_EMBEDDED);

    } else if( ExVerifySuite(Enterprise) ) {

        pwStr = (PWSTR)GetMessage(SAC_MACHINEINFO_ADVSERVER);

    } else {

        //
        // We found no product suite that we recognized or cared about.
        // Assume we're running on a generic server.
        //
        pwStr = (PWSTR)GetMessage(SAC_MACHINEINFO_SERVER);

    }

    //
    // If we got a product type string message, then use this as our product type
    //
    if (pwStr) {

        ULONG   Size;

        Size = (ULONG)((wcslen(pwStr) + 1) * sizeof(WCHAR));

        ASSERT(Size > 0);

        MachineInformation->OSProductType = (PWSTR)ALLOCATE_POOL(Size, GENERAL_POOL_TAG);

        if (MachineInformation->OSProductType == NULL) {

            IF_SAC_DEBUG(
                SAC_DEBUG_FAILS, 
                KdPrint(("SAC InitializeMachineInformation: Failed product type memory allocation.\n"))
                );
            
            goto InitializeMachineInformation_Failure;

        }

        RtlCopyMemory(MachineInformation->OSProductType, pwStr, Size);

    } else {
        
        IF_SAC_DEBUG(
            SAC_DEBUG_FAILS, 
            KdPrint(("SAC InitializeMachineInformation: Failed to get product type.\n"))
            );
    
    }

    //
    // ========
    // Service Pack Information.
    // ========
    //
    if( VersionInfo.wServicePackMajor != 0 ) {

        //
        // There's been a service pack applied.  Better tell the user.
        //

        //
        // Allocate enough memory for the formatting message, plus the size of our servicepack number.
        // Currently that's well below the 5-digit mark, but let's build some headroom here for
        // service pack numbers up to 99000 (5-digits).
        //
        //  allow for xxxxx.xxxxx
        //
        MyTemporaryBufferW = (PWSTR)ALLOCATE_POOL( (5 + 1 + 5 + 1) * sizeof(WCHAR), GENERAL_POOL_TAG );
        
        if( MyTemporaryBufferW == NULL ) {

            IF_SAC_DEBUG(
                SAC_DEBUG_FAILS, 
                KdPrint(("SAC InitializeMachineInformation: Failed service pack memory allocation.\n"))
                );
            
            goto InitializeMachineInformation_Failure;
        
        }

        swprintf( MyTemporaryBufferW,
                  L"%d.%d",
                  VersionInfo.wServicePackMajor,
                  VersionInfo.wServicePackMinor );
        
        MachineInformation->OSServicePack = MyTemporaryBufferW;
    
    } else {

        ULONG   Size;

        pwStr = (PWSTR)GetMessage(SAC_MACHINEINFO_NO_SERVICE_PACK);

        Size = (ULONG)((wcslen(pwStr) + 1) * sizeof(WCHAR));

        ASSERT(Size > 0);

        MachineInformation->OSServicePack = (PWSTR)ALLOCATE_POOL(Size, GENERAL_POOL_TAG);

        if (MachineInformation->OSServicePack == NULL) {

            IF_SAC_DEBUG(
                SAC_DEBUG_FAILS, 
                KdPrint(("SAC InitializeMachineInformation: Failed service pack memory allocation.\n"))
                );
            
            goto InitializeMachineInformation_Failure;

        }

        RtlCopyMemory(MachineInformation->OSServicePack, pwStr, Size);
    
    }

    return;

InitializeMachineInformation_Failure:
    
    if( MachineInformation != NULL ) {
        FREE_POOL(&MachineInformation);
        MachineInformation = NULL;
    }

    IF_SAC_DEBUG(
        SAC_DEBUG_FUNC_TRACE, 
        KdPrint(("SAC Initialize Machine Information: Exiting with error.\n"))
        );
    
    return;

}

NTSTATUS
SerialBufferGetChar(
    IN PUCHAR   ch
    )
/*++

Routine Description:

    This routine reads a character from the serial port buffer
    which is populated by the TimerDPC function.  The character
    is read from the Consumer index position in the buffer.  After
    the character is read, the buffer position is nulled.

Arguments:

    ch  - on success, contains the character at the consumer index
    
Return Value:

    Status                                                                  
                                                                  
--*/
{
    NTSTATUS    Status;

    Status = STATUS_SUCCESS;

    do {
        
        //
        // Bail if there are no new characters to read
        //
        if (SerialPortConsumerIndex == SerialPortProducerIndex) {

            Status = STATUS_NO_DATA_DETECTED;

            break;

        }

        //
        // Note: the following block is not done with an interlocked
        //       exchange because we don't need to.  The design
        //       of the serialport ring buffer is such that the 
        //       producer index is allowed to pass the consumer.
        //       This should not happen, however, because the
        //       consumer is notified whenever we get new data
        //       and the buffer should be large enough to allow 
        //       for reasonable consumer delays.
        //
        {
            //
            // get the current character at the current consumer index.  
            //
            *ch = SerialPortBuffer[SerialPortConsumerIndex];

            //
            // Null the value at the index we just read.  This prevents 
            // information being present in the buffer after we've already 
            // read it.
            //
            SerialPortBuffer[SerialPortConsumerIndex] = 0;        
        }

        //
        // Compute the new producer index and store it atomically
        //
        InterlockedExchange(
            (volatile long *)&SerialPortConsumerIndex, 
            (SerialPortConsumerIndex + 1) % SERIAL_PORT_BUFFER_LENGTH
            );

    } while ( FALSE );

    return Status;
}

#if ENABLE_CMD_SESSION_PERMISSION_CHECKING

NTSTATUS
GetCommandConsoleLaunchingPermission(
    OUT PBOOLEAN    Permission
    )
/*++

Routine Description:

    This routine determines if command console sessions are allowed
    to be launched.

Arguments:

    Permission  - on success, contains TRUE if sessions are allowed
                  to be launched

Return Value:

    Status

--*/
{
    NTSTATUS    Status;
    
    PWSTR   KEY_NAME    = L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\sacdrv";
    PWSTR   VALUE_NAME  = L"DisableCmdSessions";
    
    PKEY_VALUE_PARTIAL_INFORMATION  ValueBuffer;

    //
    // default: permission is granted unless we specifically find
    //          the key/value stating that it is not
    //
    *Permission = TRUE;
    
    do {

        //
        // Attempt to find the registry key/value 
        //
        Status = GetRegistryValueBuffer(
            KEY_NAME,
            VALUE_NAME,
            &ValueBuffer
            );

        if( Status == STATUS_OBJECT_NAME_NOT_FOUND ) {
            
            //
            // The reg key was not found, so the feature is enabled.
            //
            Status = STATUS_SUCCESS;
            
            break;
        
        }
        
        if(! NT_SUCCESS(Status) ) {
            break;
        }
        
        //
        // We found the key/value, so notify the caller
        // that permission has been denied.
        //
        *Permission = FALSE;

    } while ( FALSE );

    return Status;

}

#if ENABLE_SACSVR_START_TYPE_OVERRIDE

NTSTATUS
ImposeSacCmdServiceStartTypePolicy(
    VOID
    )
/*++

Routine Description:
    
    This routine implement the service start type policy
    that is imposed when the cmd console session feature
    is ENABLED.
            
    Here is the state table:
            
    Command Console Feature Enabled:
            
    service start type:
            
        automatic   --> NOP
        manual      --> automatic
        disabled    --> NOP

Arguments:

    None

Return Value:

    Status    
        
--*/
{
    NTSTATUS    Status;
    
    PWSTR       KEY_NAME    = L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\sacsvr";
    PWSTR       VALUE_NAME  = L"Start";
    
    PULONG                          ValueData;
    PKEY_VALUE_PARTIAL_INFORMATION  ValueBuffer;
    
    do {

        //
        // init
        //
        ValueBuffer = NULL;
        
        //
        // Attempt to find the registry key/value 
        //
        Status = GetRegistryValueBuffer(
            KEY_NAME,
            VALUE_NAME,
            &ValueBuffer
            );

        if(! NT_SUCCESS(Status)) {
            break;
        }
        if(ValueBuffer == NULL) {
            Status = STATUS_UNSUCCESSFUL;
            break;
        }
        
        //
        // Get the current start type value
        //
        Status = CopyRegistryValueData(
            &ValueData,
            ValueBuffer
            );

        FREE_POOL(&ValueBuffer);

        if( !NT_SUCCESS(Status) ) {
            break;
        }

        //
        // Examine the current start type and assign
        // a new type if appropriate.
        //
        switch (*ValueData) {
        case 2: // automatic
        case 4: // disabled
            break;

        case 3: // manual
            
            //
            // Set the start type --> Automatic
            //
            *ValueData = 2;

            //
            // Set the start type value in the service key.
            //
            Status = SetRegistryValue(
                KEY_NAME,
                VALUE_NAME,
                REG_DWORD,
                ValueData,
                sizeof(ULONG)
                );

            if(!NT_SUCCESS(Status)) {
                
                IF_SAC_DEBUG(
                    SAC_DEBUG_FAILS, 
                    KdPrint(("SAC ImposeSacCmdServiceStartTypePolicy: Failed SetRegistryValue: %X\n", Status))
                    );
            
            }
            
            break;

        default:
            ASSERT(0);
            break;
        }

    } while ( FALSE );

    return Status;

}
#endif

#endif

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

Routine Description:

    This routine takes a source string and inserts an 
    "interval string" at interval characters in the new
    destination string.
    
    Note: caller is responsible for releasing DestStr if successful      
          
    ex:
    
    src "aaabbbccc"
    interval string = "XYZ"
    interval = 3
                       
    ==> dest string == "aaaXYZbbbXYZccc"

Arguments:
    
    SourceStr   - the source string
    Interval    - spanning interval
    InsertStr   - the insert string
    DestStr     - the destination string    

Return Value:

    Status

--*/
{
    ULONG   SrcLength;
    ULONG   DestLength;
    ULONG   DestSize;
    ULONG   InsertLength;
    ULONG   k;
    ULONG   l;
    ULONG   i;
    PWCHAR  DestStr;
    ULONG   IntervalCnt;

    ASSERT_STATUS(SourceStr, STATUS_INVALID_PARAMETER_1); 
    ASSERT_STATUS(Interval > 0, STATUS_INVALID_PARAMETER_2); 
    ASSERT_STATUS(InsertStr, STATUS_INVALID_PARAMETER_3); 
    ASSERT_STATUS(pDestStr > 0, STATUS_INVALID_PARAMETER_4); 

    //
    // the length of the insert string
    //
    InsertLength = (ULONG)wcslen(InsertStr);
    
    //
    // Compute how large the destination string needs to be,
    // including the source string and the interval strings.
    //
    SrcLength = (ULONG)wcslen(SourceStr);
    IntervalCnt = SrcLength / Interval;
    if (SrcLength % Interval == 0) {
        IntervalCnt = IntervalCnt > 0 ? IntervalCnt - 1 : IntervalCnt;
    }
    DestLength = SrcLength + (IntervalCnt * (ULONG)wcslen(InsertStr));
    DestSize = (ULONG)((DestLength + 1) * sizeof(WCHAR));

    //
    // Allocate the new destination string
    //
    DestStr = ALLOCATE_POOL(DestSize, GENERAL_POOL_TAG);
    ASSERT_STATUS(DestStr, STATUS_NO_MEMORY);
    RtlZeroMemory(DestStr, DestSize);

    //
    // Initialize the pointers into the source and destination strings
    //
    l = 0;
    i = 0;

    do {

        //
        // k = # of characters to copy
        //
        // if Interval > # of characters left to copy,
        // then k = # of characters left to copy
        // else k = interval
        // 
        k = Interval > (SrcLength - i) ? (SrcLength - i) : Interval;
        
        //
        // Copy k charactars to the destination buffer
        //
        wcsncpy(
            &DestStr[l],
            &SourceStr[i],
            k
            );

        //
        // Account for how many characters we just copied
        //
        l += k;
        i += k;

        //
        // If there are any characters left to copy, 
        // then we need to insert the InsertString 
        // That is, we are at an interval.
        //
        if (i < SrcLength) {
            
            //
            // Insert the specified string at the interval
            //
            wcscpy(
                &DestStr[l],
                InsertStr
                );

            //
            // Account for how many characters we just copied
            //
            l += InsertLength;
        
        }

    } while ( i < SrcLength);

    //
    //
    //
    ASSERT(i == SrcLength);
    ASSERT(l == DestLength);
    ASSERT((l + 1) * sizeof(WCHAR) == DestSize);

    //
    // Send back the destination string
    //
    *pDestStr = DestStr;

    return STATUS_SUCCESS;
}

ULONG
GetMessageLineCount(
    ULONG MessageId
    )
/*++

Routine Description:

    This routine retrieves a message resource and counts the # of lines in it
    
Arguments:

    MessageId   - The message id of the resource to send

Return Value:

    LineCount

--*/
{
    PCWSTR  p;
    ULONG   c;

    //
    // we start at 0 
    // 1. if the message is found, 
    //    then we know resource messages always have at least 1 CRLF
    // 2. if the message is not found,
    //    then the line count is 0
    //
    c = 0;

    p = GetMessage(MessageId);
       
    if (p) {
        
        while(*p) {
            if (*p == L'\n') {
                c++;
            }
            p++;
        }

    }
    
    return(c);
}