reactos/drivers/sac/driver/sacdrv.h

/*
 * PROJECT:     ReactOS Drivers
 * LICENSE:     BSD - See COPYING.ARM in the top level directory
 * FILE:        drivers/sac/driver/sacdrv.h
 * PURPOSE:     Driver for the Server Administration Console (SAC) for EMS
 * PROGRAMMERS: ReactOS Portable Systems Group
 */

#ifndef _SACDRV_H_
#define _SACDRV_H_

/* INCLUDES *******************************************************************/

#include <ntifs.h>
#include <stdio.h>
#include <ntoskrnl/include/internal/hdl.h>
#include <sacmsg.h>

/* DEFINES ********************************************************************/

//
// SAC Heap Allocator Macros
//
#define SacAllocatePool(Length, Tag)    \
    MyAllocatePool(Length, Tag, __FILE__, __LINE__)
#define SacFreePool(Pointer)            \
    MyFreePool((PVOID*)(&Pointer))

//
// SAC Debugging Macro and Constants
//
#define SAC_DBG_ENTRY_EXIT                  0x01
#define SAC_DBG_UTIL                        0x02
#define SAC_DBG_INIT                        0x04
#define SAC_DBG_MM                          0x1000
#define SAC_DBG_MACHINE                     0x2000
#define SAC_DBG(x, ...)                     \
    if (SACDebug & x)                       \
    {                                       \
        DbgPrint("SAC %s: ", __FUNCTION__); \
        DbgPrint(__VA_ARGS__);              \
    }

//
// SAC Parameter Checking Macros
//
#define CHECK_PARAMETER_WITH_STATUS(Parameter, Status)  \
{                                                       \
    ASSERT(((PVOID)(Parameter)) != NULL);               \
    if (((PVOID)(Parameter)) == NULL)                   \
    {                                                   \
        return Status;                                  \
    }                                                   \
}
#define CHECK_PARAMETER(x)      \
    CHECK_PARAMETER_WITH_STATUS(x, STATUS_INVALID_PARAMETER)
#define CHECK_PARAMETER1(x)     \
    CHECK_PARAMETER_WITH_STATUS(x, STATUS_INVALID_PARAMETER_1)
#define CHECK_PARAMETER2(x)     \
    CHECK_PARAMETER_WITH_STATUS(x, STATUS_INVALID_PARAMETER_2)
#define CHECK_PARAMETER3(x)     \
    CHECK_PARAMETER_WITH_STATUS(x, STATUS_INVALID_PARAMETER_3)
#define CHECK_PARAMETER4(x)     \
    CHECK_PARAMETER_WITH_STATUS(x, STATUS_INVALID_PARAMETER_4)
#define CHECK_ALLOCATION(x)     \
    CHECK_PARAMETER_WITH_STATUS(x, STATUS_NO_MEMORY)

//
// SAC Channel Event Macros
//
#define ChannelInitializeEvent(Channel, Attributes, x)                  \
{                                                                       \
    PVOID Object, WaitObject;                                           \
    if (Attributes->x)                                                  \
    {                                                                   \
        if (!VerifyEventWaitable(Attributes->x, &Object, &WaitObject))  \
        {                                                               \
            goto FailChannel;                                           \
        }                                                               \
        Channel->x = Attributes->x;                                     \
        Channel->x##ObjectBody = Object;                                \
        Channel->x##WaitObjectBody = WaitObject;                        \
    }                                                                   \
}
#define ChannelUninitializeEvent(Channel, x, f)         \
{                                                       \
    ASSERT(ChannelGetFlags(Channel) & (f));             \
    ASSERT(Channel->x##ObjectBody);                     \
    ASSERT(Channel->x##WaitObjectBody);                 \
    if (Channel->x##ObjectBody)                         \
    {                                                   \
        ObDereferenceObject(Channel->x##ObjectBody);    \
        Channel->Flags &= ~(f);                         \
        Channel->x = NULL;                              \
        Channel->x##ObjectBody = NULL;                  \
        Channel->x##WaitObjectBody = NULL;              \
    }                                                   \
}
#define ChannelSetEvent(Channel, x)                                     \
{                                                                       \
    ASSERT(Channel->x);                                                 \
    ASSERT(Channel->x##ObjectBody);                                     \
    ASSERT(Channel->x##WaitObjectBody);                                 \
    if (Channel->x##WaitObjectBody)                                     \
    {                                                                   \
        KeSetEvent(Channel->x##WaitObjectBody, EVENT_INCREMENT, FALSE); \
        Status = STATUS_SUCCESS;                                        \
    }                                                                   \
    else                                                                \
    {                                                                   \
        Status = STATUS_UNSUCCESSFUL;                                   \
    }                                                                   \
}
#define ChannelClearEvent(Channel, x)               \
{                                                   \
    ASSERT(Channel->x);                             \
    ASSERT(Channel->x##ObjectBody);                 \
    ASSERT(Channel->x##WaitObjectBody);             \
    if (Channel->x##WaitObjectBody)                 \
    {                                               \
        KeClearEvent(Channel->x##WaitObjectBody);   \
        Status = STATUS_SUCCESS;                    \
    }                                               \
    else                                            \
    {                                               \
        Status = STATUS_UNSUCCESSFUL;               \
    }                                               \
}

//
// SAC Pool Tags, taken from pooltag.txt:
//
//  Rcp? - sacdrv.sys - SAC Driver (Headless)
//  RcpA - sacdrv.sys -     Internal memory mgr alloc block
//  RcpI - sacdrv.sys -     Internal memory mgr initial heap block
//  RcpS - sacdrv.sys -     Security related block
#define GENERIC_TAG                         '?pcR'
#define ALLOC_BLOCK_TAG                     'ApcR'
#define INITIAL_BLOCK_TAG                   'IpcR'
#define SECURITY_BLOCK_TAG                  'SpcR'
#define FREE_POOL_TAG                       'FpcR'
#define GLOBAL_BLOCK_TAG                    'GpcR'
#define CHANNEL_BLOCK_TAG                   'CpcR'
#define LOCAL_MEMORY_SIGNATURE              'SSEL'
#define GLOBAL_MEMORY_SIGNATURE             'DAEH'

//
// Size Definitions
//
#define SAC_MEMORY_LIST_SIZE                (1 * 1024 * 1024)   // 1MB
#define SAC_OBUFFER_SIZE                    (2 * 1024)          // 2KB
#define SAC_CHANNEL_NAME_SIZE               64
#define SAC_CHANNEL_DESCRIPTION_SIZE        256
#define SAC_MAX_CHANNELS                    10
#define SAC_SERIAL_PORT_BUFFER_SIZE         1024                // 1KB
#define SAC_MAX_MESSAGES                    200
#define SAC_VTUTF8_COL_WIDTH                80
#define SAC_VTUTF8_COL_HEIGHT               25
#define SAC_VTUTF8_ROW_HEIGHT               24
#define MAX_UTF8_ENCODE_BLOCK_LENGTH        (Utf8ConversionBufferSize / 3 - 1)
#define SAC_VTUTF8_OBUFFER_SIZE             0x2D00
#define SAC_VTUTF8_IBUFFER_SIZE             0x2000
#define SAC_RAW_OBUFFER_SIZE                0x2000
#define SAC_RAW_IBUFFER_SIZE                0x2000

//
// Channel flags
//
#define SAC_CHANNEL_FLAG_INTERNAL           0x1
#define SAC_CHANNEL_FLAG_CLOSE_EVENT        0x2
#define SAC_CHANNEL_FLAG_HAS_NEW_DATA_EVENT 0x4
#define SAC_CHANNEL_FLAG_LOCK_EVENT         0x8
#define SAC_CHANNEL_FLAG_REDRAW_EVENT       0x10
#define SAC_CHANNEL_FLAG_APPLICATION        0x20

//
// Cell Flags
//
#define SAC_CELL_FLAG_BLINK                 1
#define SAC_CELL_FLAG_BOLD                  2
#define SAC_CELL_FLAG_INVERTED              4

//
// Forward definitions
//
struct _SAC_CHANNEL;

//
// Structures used by the SAC Heap Allocator
//
typedef struct _SAC_MEMORY_ENTRY
{
    ULONG Signature;
    ULONG Tag;
    ULONG Size;
} SAC_MEMORY_ENTRY, *PSAC_MEMORY_ENTRY;
typedef struct _SAC_MEMORY_LIST
{
    ULONG Signature;
    PSAC_MEMORY_ENTRY LocalDescriptor;
    ULONG Size;
    struct _SAC_MEMORY_LIST* Next;
} SAC_MEMORY_LIST, *PSAC_MEMORY_LIST;

typedef struct _SAC_MESSAGE_ENTRY
{
    ULONG Index;
    PWCHAR Buffer;
} SAC_MESSAGE_ENTRY, *PSAC_MESSAGE_ENTRY;

//
// These are the VT-100/220/ANSI Escape Codes supported by SAC as input
//
typedef enum _SAC_ANSI_COMMANDS
{
    SacCursorUp,
    SacCursorDown,
    SacCursorRight,
    SacCursorLeft,
    SacFontNormal,
    SacFontBlink,
    SacFontBlinkOff,
    SacFontBold,
    SacFontBoldOff,
    SacFontInverse,
    SacFontInverseOff,
    SacBackTab,
    SacEraseEndOfLine,
    SacEraseStartOfLine,
    SacEraseLine,
    SacEraseEndOfScreen,
    SacEraseStartOfScreen,
    SacEraseScreen,
    SacSetCursorPosition,
    SacSetScrollRegion,
    SacSetColors,
    SacSetBackgroundColor,
    SacSetFontColor,
    SacSetColorsAndAttributes
} SAC_ANSI_COMMANDS;

//
// These are the VT-100/220/ANSI Escape Codes send by SAC as output
//
typedef enum _SAC_ANSI_DISPATCH
{
    SacAnsiClearScreen,
    SacAnsiClearEndOfScreen,
    SacAnsiClearEndOfLine,
    SacAnsiSetColors,
    SacAnsiSetPosition,
    SacAnsiClearAttributes,
    SacAnsiSetInverseAttribute,
    SacAnsiClearInverseAttribute,
    SacAnsiSetBlinkAttribute,
    SacAnsiClearBlinkAttribute,
    SacAnsiSetBoldAttribute,
    SacAnsiClearBoldAttribute
} SAC_ANSI_DISPATCH;

//
// Commands that the consumer and producer share
//
typedef enum _SAC_POST_COMMANDS
{
    Nothing,
    Shutdown,
    Close,
    Restart
} SAC_POST_COMMANDS;

//
// SAC supports 3 different channel output types
//
typedef enum _SAC_CHANNEL_TYPE
{
    VtUtf8,
    Cmd,
    Raw
} SAC_CHANNEL_TYPE;

//
// A SAC channel can be active or inactive
//
typedef enum _SAC_CHANNEL_STATUS
{
    Inactive,
    Active
} SAC_CHANNEL_STATUS, *PSAC_CHANNEL_STATUS;

//
// A SAC channel identifier
//
typedef struct _SAC_CHANNEL_ID
{
    GUID ChannelGuid;
    ULONG ChannelId;
} SAC_CHANNEL_ID, *PSAC_CHANNEL_ID;

//
// Reference-counted SAC channel semaphore lock
//
typedef struct _SAC_CHANNEL_LOCK
{
    LONG RefCount;
    KSEMAPHORE Lock;
} SAC_CHANNEL_LOCK, *PSAC_CHANNEL_LOCK;

//
// Structure of the cell-buffer when in VT-UTF8 Mode
//
typedef struct _SAC_CELL_DATA
{
    UCHAR CellBackColor;
    UCHAR CellForeColor;
    UCHAR CellFlags;
    WCHAR Char;
} SAC_CELL_DATA, *PSAC_CELL_DATA;
C_ASSERT(sizeof(SAC_CELL_DATA) == 6);

//
// Screen buffer when in VT-UTF8 Mode
//
typedef struct _SAC_VTUTF8_SCREEN
{
    SAC_CELL_DATA Cell[SAC_VTUTF8_ROW_HEIGHT][SAC_VTUTF8_COL_WIDTH];
} SAC_VTUTF8_SCREEN, *PSAC_VTUTF8_SCREEN;

//
// Small optimization to easily recognize the most common VT-100/ANSI codes
//
typedef struct _SAC_STATIC_ESCAPE_STRING
{
    WCHAR Sequence[10];
    ULONG Size;
    ULONG Action;
} SAC_STATIC_ESCAPE_STRING, *PSAC_STATIC_ESCAPE_STRING;

//
// Channel callbacks
//
typedef
NTSTATUS
(NTAPI *PSAC_CHANNEL_CREATE)(
    IN struct _SAC_CHANNEL* Channel
);

typedef
NTSTATUS
(NTAPI *PSAC_CHANNEL_DESTROY)(
    IN struct _SAC_CHANNEL* Channel
);

typedef
NTSTATUS
(NTAPI *PSAC_CHANNEL_OREAD)(
    IN struct _SAC_CHANNEL* Channel,
    IN PCHAR Buffer,
    IN ULONG BufferSize,
    OUT PULONG ByteCount
);

typedef
NTSTATUS
(NTAPI *PSAC_CHANNEL_OECHO)(
    IN struct _SAC_CHANNEL* Channel,
    IN PCHAR String,
    IN ULONG Length
);

typedef
NTSTATUS
(NTAPI *PSAC_CHANNEL_OFLUSH)(
    IN struct _SAC_CHANNEL* Channel
);

typedef
NTSTATUS
(NTAPI *PSAC_CHANNEL_OWRITE)(
    IN struct _SAC_CHANNEL* Channel,
    IN PCHAR String,
    IN ULONG Length
);

typedef
NTSTATUS
(NTAPI *PSAC_CHANNEL_IREAD)(
    IN struct _SAC_CHANNEL* Channel,
    IN PCHAR Buffer,
    IN ULONG BufferSize,
    IN PULONG ReturnBufferSize
);

typedef
NTSTATUS
(NTAPI *PSAC_CHANNEL_IBUFFER_FULL)(
    IN struct _SAC_CHANNEL* Channel,
    OUT PBOOLEAN BufferStatus
);

typedef
ULONG
(NTAPI *PSAC_CHANNEL_IBUFFER_LENGTH)(
    IN struct _SAC_CHANNEL* Channel
);

typedef
WCHAR
(NTAPI *PSAC_CHANNEL_IREAD_LAST)(
    IN struct _SAC_CHANNEL* Channel
);

typedef
NTSTATUS
(NTAPI *PSAC_CHANNEL_IWRITE)(
    IN struct _SAC_CHANNEL* Channel,
    IN PCHAR Buffer,
    IN ULONG BufferSize
);

//
// A channel and its attributes
//
typedef struct _SAC_CHANNEL
{
    LONG Index;
    SAC_CHANNEL_ID ChannelId;
    HANDLE CloseEvent;
    PVOID CloseEventObjectBody;
    PKEVENT CloseEventWaitObjectBody;
    HANDLE HasNewDataEvent;
    PVOID HasNewDataEventObjectBody;
    PKEVENT HasNewDataEventWaitObjectBody;
    HANDLE LockEvent;
    PVOID LockEventObjectBody;
    PKEVENT LockEventWaitObjectBody;
    HANDLE RedrawEvent;
    PVOID RedrawEventObjectBody;
    PKEVENT RedrawEventWaitObjectBody;
    PFILE_OBJECT FileObject;
    SAC_CHANNEL_TYPE ChannelType;
    SAC_CHANNEL_STATUS ChannelStatus;
    WCHAR NameBuffer[SAC_CHANNEL_NAME_SIZE + 1];
    WCHAR DescriptionBuffer[SAC_CHANNEL_DESCRIPTION_SIZE + 1];
    ULONG Flags;
    GUID ApplicationType;
    LONG WriteEnabled;
    ULONG IBufferIndex;
    PCHAR IBuffer;
    LONG ChannelHasNewIBufferData;
    UCHAR CursorRow;
    UCHAR CursorCol;
    UCHAR CellForeColor;
    UCHAR CellBackColor;
    UCHAR CellFlags;
    PCHAR OBuffer;
    ULONG OBufferIndex;
    ULONG OBufferFirstGoodIndex;
    LONG ChannelHasNewOBufferData;
    PSAC_CHANNEL_CREATE ChannelCreate;
    PSAC_CHANNEL_DESTROY ChannelDestroy;
    PSAC_CHANNEL_OFLUSH ChannelOutputFlush;
    PSAC_CHANNEL_OECHO ChannelOutputEcho;
    PSAC_CHANNEL_OWRITE ChannelOutputWrite;
    PSAC_CHANNEL_OREAD ChannelOutputRead;
    PSAC_CHANNEL_IWRITE ChannelInputWrite;
    PSAC_CHANNEL_IREAD ChannelInputRead;
    PSAC_CHANNEL_IREAD_LAST ChannelInputReadLast;
    PSAC_CHANNEL_IBUFFER_FULL ChannelInputBufferIsFull;
    PSAC_CHANNEL_IBUFFER_LENGTH ChannelInputBufferLength;
    SAC_CHANNEL_LOCK ChannelAttributeLock;
    SAC_CHANNEL_LOCK ChannelOBufferLock;
    SAC_CHANNEL_LOCK ChannelIBufferLock;
} SAC_CHANNEL, *PSAC_CHANNEL;

typedef struct _SAC_CHANNEL_ATTRIBUTES
{
    SAC_CHANNEL_TYPE ChannelType;
    WCHAR NameBuffer[SAC_CHANNEL_NAME_SIZE + 1];
    WCHAR DescriptionBuffer[SAC_CHANNEL_DESCRIPTION_SIZE + 1];
    ULONG Flag;
    HANDLE CloseEvent;
    HANDLE HasNewDataEvent;
    HANDLE LockEvent;
    HANDLE RedrawEvent;
    GUID ChannelId;
} SAC_CHANNEL_ATTRIBUTES, *PSAC_CHANNEL_ATTRIBUTES;

//
// Cached Machine Information
//
typedef struct _SAC_MACHINE_INFO
{
    PWCHAR MachineName;
    PWCHAR MachineGuid;
    PWCHAR ProcessorArchitecture;
    PWCHAR MajorVersion;
    PWCHAR BuildNumber;
    PWCHAR ProductType;
    PWCHAR ServicePack;
} SAC_MACHINE_INFO, *PSAC_MACHINE_INFO;

//
// The device extension for the SAC
//
typedef struct _SAC_DEVICE_EXTENSION
{
    PDEVICE_OBJECT DeviceObject;
    BOOLEAN Initialized;
    BOOLEAN Rundown;
    BOOLEAN PriorityFail;
    BOOLEAN RundownInProgress;
    KPRIORITY PriorityBoost;
    PEPROCESS Process;
    KSPIN_LOCK Lock;
    KEVENT RundownEvent;
    KEVENT Event;
    HANDLE WorkerThreadHandle;
    KEVENT WorkerThreadEvent;
    KTIMER Timer;
    KDPC Dpc;
    LIST_ENTRY List;
} SAC_DEVICE_EXTENSION, *PSAC_DEVICE_EXTENSION;

//
// Dispatch Routines
//
NTSTATUS
NTAPI
Dispatch(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
);

NTSTATUS
NTAPI
DispatchDeviceControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
);

NTSTATUS
NTAPI
DispatchShutdownControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
);

VOID
NTAPI
UnloadHandler(
    IN PDRIVER_OBJECT DriverObject
);

//
// Initialization and shutdown routines
//
VOID
NTAPI
FreeGlobalData(
    VOID
);

VOID
NTAPI
FreeDeviceData(
    IN PDEVICE_OBJECT DeviceObject
);

BOOLEAN
NTAPI
InitializeDeviceData(
    IN PDEVICE_OBJECT DeviceObject
);

BOOLEAN
NTAPI
InitializeGlobalData(
    IN PUNICODE_STRING RegistryPath,
    IN PDRIVER_OBJECT DriverObject
);

BOOLEAN
NTAPI
InitializeMemoryManagement(
    VOID
);

VOID
NTAPI
FreeMemoryManagement(
    VOID
);

VOID
NTAPI
InitializeCmdEventInfo(
    VOID
);

VOID
NTAPI
InitializeMachineInformation(
    VOID
);

NTSTATUS
NTAPI
PreloadGlobalMessageTable(
    IN PVOID ImageBase
);

NTSTATUS
NTAPI
TearDownGlobalMessageTable(
    VOID
);

NTSTATUS
NTAPI
GetCommandConsoleLaunchingPermission(
    OUT PBOOLEAN Permission
);

NTSTATUS
NTAPI
ImposeSacCmdServiceStartTypePolicy(
    VOID
);

NTSTATUS
NTAPI
RegisterBlueScreenMachineInformation(
    VOID
);

VOID
NTAPI
FreeMachineInformation(
    VOID
);

//
// DPC, Timer, Thread Callbacks
//
VOID
NTAPI
TimerDpcRoutine(
    IN PKDPC Dpc,
    IN PVOID DeferredContext,
    IN PVOID SystemArgument1,
    IN PVOID SystemArgument2
);

//
// Custom SAC Heap Allocator Routines
//
PVOID
NTAPI
MyAllocatePool(
    IN SIZE_T PoolSize,
    IN ULONG Tag,
    IN PCHAR File,
    IN ULONG Line
);

VOID
NTAPI
MyFreePool(
    IN PVOID *Block
);

//
// Connection Manager Routines
//
NTSTATUS
NTAPI
ConMgrInitialize(
    VOID
);

VOID
NTAPI
ConMgrWorkerProcessEvents(
    IN PSAC_DEVICE_EXTENSION DeviceExtension
);

NTSTATUS
NTAPI
ConMgrShutdown(
    VOID
);

BOOLEAN
NTAPI
ConMgrSimpleEventMessage(
    IN ULONG MessageIndex,
    IN BOOLEAN LockHeld
);

BOOLEAN
NTAPI
SacPutSimpleMessage(
    IN ULONG MessageIndex
);

VOID
NTAPI
SacPutString(
    IN PWCHAR String
);

NTSTATUS
NTAPI
ConMgrWriteData(
    IN PSAC_CHANNEL Channel,
    IN PVOID Buffer,
    IN ULONG BufferLength
);

NTSTATUS
NTAPI
ConMgrFlushData(
    IN PSAC_CHANNEL Channel
);

BOOLEAN
NTAPI
ConMgrIsWriteEnabled(
    IN PSAC_CHANNEL Channel
);

NTSTATUS
NTAPI
ConMgrHandleEvent(
    IN ULONG EventCode,
    IN PSAC_CHANNEL Channel,
    OUT PVOID Data
);

//
// Channel Manager Routines
//
NTSTATUS
NTAPI
ChanMgrInitialize(
    VOID
);

NTSTATUS
NTAPI
ChanMgrShutdown(
    VOID
);

NTSTATUS
NTAPI
ChanMgrCreateChannel(
    OUT PSAC_CHANNEL *Channel,
    IN PSAC_CHANNEL_ATTRIBUTES Attributes
);

NTSTATUS
NTAPI
ChanMgrGetByHandle(
    IN SAC_CHANNEL_ID ChannelId,
    OUT PSAC_CHANNEL* TargetChannel
);

NTSTATUS
NTAPI
ChanMgrReleaseChannel(
    IN PSAC_CHANNEL Channel
);

NTSTATUS
NTAPI
ChanMgrGetNextActiveChannel(
    IN PSAC_CHANNEL CurrentChannel,
    IN PULONG TargetIndex,
    OUT PSAC_CHANNEL *TargetChannel
);

NTSTATUS
NTAPI
ChanMgrCloseChannel(
    IN PSAC_CHANNEL Channel
);

//
// Channel Routines
//
NTSTATUS
NTAPI
ChannelClose(
    IN PSAC_CHANNEL Channel
);

BOOLEAN
NTAPI
ChannelIsEqual(
    IN PSAC_CHANNEL Channel,
    IN PSAC_CHANNEL_ID ChannelId
);

NTSTATUS
NTAPI
ChannelOWrite(
    IN PSAC_CHANNEL Channel,
    IN PCHAR Buffer,
    IN ULONG BufferSize
);

NTSTATUS
NTAPI
ChannelOFlush(
    IN PSAC_CHANNEL Channel
);

NTSTATUS
NTAPI
ChannelSetRedrawEvent(
    IN PSAC_CHANNEL Channel
);

NTSTATUS
NTAPI
ChannelClearRedrawEvent(
    IN PSAC_CHANNEL Channel
);

NTSTATUS
NTAPI
ChannelHasRedrawEvent(
    IN PSAC_CHANNEL Channel,
    OUT PBOOLEAN Present
);

BOOLEAN
NTAPI
ChannelIsActive(
    IN PSAC_CHANNEL Channel
);

NTSTATUS
NTAPI
ChannelGetName(
    IN PSAC_CHANNEL Channel,
    OUT PWCHAR *Name
);

BOOLEAN
NTAPI
ChannelIsEqual(
    IN PSAC_CHANNEL Channel,
    IN PSAC_CHANNEL_ID ChannelId
);

NTSTATUS
NTAPI
ChannelCreate(
    IN PSAC_CHANNEL Channel,
    IN PSAC_CHANNEL_ATTRIBUTES Attributes,
    IN SAC_CHANNEL_ID ChannelId
);

NTSTATUS
NTAPI
ChannelDestroy(
    IN PSAC_CHANNEL Channel
);

NTSTATUS
NTAPI
ChannelIWrite(
    IN PSAC_CHANNEL Channel,
    IN PCHAR Buffer,
    IN ULONG BufferSize
);

WCHAR
NTAPI
ChannelIReadLast(
    IN PSAC_CHANNEL Channel
);

ULONG
NTAPI
ChannelIBufferLength(
    IN PSAC_CHANNEL Channel
);

NTSTATUS
NTAPI
ChannelIRead(
    IN PSAC_CHANNEL Channel,
    IN PCHAR Buffer,
    IN ULONG BufferSize,
    IN OUT PULONG ResultBufferSize
);

//
// RAW Channel Table
//
NTSTATUS
NTAPI
RawChannelCreate(
    IN PSAC_CHANNEL Channel
);

NTSTATUS
NTAPI
RawChannelDestroy(
    IN PSAC_CHANNEL Channel
);

NTSTATUS
NTAPI
RawChannelORead(
    IN PSAC_CHANNEL Channel,
    IN PCHAR Buffer,
    IN ULONG BufferSize,
    OUT PULONG ByteCount
);

NTSTATUS
NTAPI
RawChannelOEcho(
    IN PSAC_CHANNEL Channel,
    IN PCHAR String,
    IN ULONG Length
);

NTSTATUS
NTAPI
RawChannelOFlush(
    IN PSAC_CHANNEL Channel
);

NTSTATUS
NTAPI
RawChannelOWrite(
    IN PSAC_CHANNEL Channel,
    IN PCHAR String,
    IN ULONG Length
);

NTSTATUS
NTAPI
RawChannelIRead(
    IN PSAC_CHANNEL Channel,
    IN PCHAR Buffer,
    IN ULONG BufferSize,
    IN PULONG ReturnBufferSize
);

NTSTATUS
NTAPI
RawChannelIBufferIsFull(
    IN PSAC_CHANNEL Channel,
    OUT PBOOLEAN BufferStatus
);

ULONG
NTAPI
RawChannelIBufferLength(
    IN PSAC_CHANNEL Channel
);

WCHAR
NTAPI
RawChannelIReadLast(
    IN PSAC_CHANNEL Channel
);

NTSTATUS
NTAPI
RawChannelIWrite(
    IN PSAC_CHANNEL Channel,
    IN PCHAR Buffer,
    IN ULONG BufferSize
);

//
// VT-UTF8 Channel Table
//
NTSTATUS
NTAPI
VTUTF8ChannelCreate(
    IN PSAC_CHANNEL Channel
);

NTSTATUS
NTAPI
VTUTF8ChannelDestroy(
    IN PSAC_CHANNEL Channel
);

NTSTATUS
NTAPI
VTUTF8ChannelORead(
    IN PSAC_CHANNEL Channel,
    IN PCHAR Buffer,
    IN ULONG BufferSize,
    OUT PULONG ByteCount
);

NTSTATUS
NTAPI
VTUTF8ChannelOEcho(
    IN PSAC_CHANNEL Channel,
    IN PCHAR String,
    IN ULONG Length
);

NTSTATUS
NTAPI
VTUTF8ChannelOFlush(
    IN PSAC_CHANNEL Channel
);

NTSTATUS
NTAPI
VTUTF8ChannelOWrite(
    IN PSAC_CHANNEL Channel,
    IN PCHAR String,
    IN ULONG Length
);

NTSTATUS
NTAPI
VTUTF8ChannelIRead(
    IN PSAC_CHANNEL Channel,
    IN PCHAR Buffer,
    IN ULONG BufferSize,
    IN PULONG ReturnBufferSize
);

NTSTATUS
NTAPI
VTUTF8ChannelIBufferIsFull(
    IN PSAC_CHANNEL Channel,
    OUT PBOOLEAN BufferStatus
);

ULONG
NTAPI
VTUTF8ChannelIBufferLength(
    IN PSAC_CHANNEL Channel
);

WCHAR
NTAPI
VTUTF8ChannelIReadLast(
    IN PSAC_CHANNEL Channel
);

NTSTATUS
NTAPI
VTUTF8ChannelIWrite(
    IN PSAC_CHANNEL Channel,
    IN PCHAR Buffer,
    IN ULONG BufferSize
);


//
// Helper Routines
//
BOOLEAN
NTAPI
SacTranslateUtf8ToUnicode(
    IN CHAR Utf8Char,
    IN PCHAR Utf8Buffer,
    OUT PWCHAR Utf8Value
);

ULONG
NTAPI
GetMessageLineCount(
    IN ULONG MessageIndex
);

NTSTATUS
NTAPI
SerialBufferGetChar(
    OUT PCHAR Char
);

NTSTATUS
NTAPI
UTF8EncodeAndSend(
    IN PWCHAR String
);

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

PWCHAR
NTAPI
GetMessage(
    IN ULONG MessageIndex
);

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

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

//
// SAC Command Functions
//
VOID
NTAPI
DoRebootCommand(
    IN BOOLEAN Reboot
);

VOID
NTAPI
DoFullInfoCommand(
    VOID
);

VOID
NTAPI
DoPagingCommand(
    VOID
);

VOID
NTAPI
DoSetTimeCommand(
    IN PCHAR InputTime
);

VOID
NTAPI
DoKillCommand(
    IN PCHAR KillString
);

VOID
NTAPI
DoLowerPriorityCommand(
    IN PCHAR PrioString
);

VOID
NTAPI
DoRaisePriorityCommand(
    IN PCHAR PrioString
);

VOID
NTAPI
DoLimitMemoryCommand(
    IN PCHAR LimitString
);

VOID
NTAPI
DoCrashCommand(
    VOID
);

VOID
NTAPI
DoMachineInformationCommand(
    VOID
);

VOID
NTAPI
DoChannelCommand(
    IN PCHAR ChannelString
);

VOID
NTAPI
DoCmdCommand(
    IN PCHAR InputString
);

VOID
NTAPI
DoLockCommand(
    VOID
);

VOID
NTAPI
DoHelpCommand(
    VOID
);

VOID
NTAPI
DoGetNetInfo(
    IN BOOLEAN DoPrint
);

VOID
NTAPI
DoSetIpAddressCommand(
    IN PCHAR IpString
);

VOID
NTAPI
DoTlistCommand(
    VOID
);

//
// External data
//
extern ULONG SACDebug;
extern PSAC_MESSAGE_ENTRY GlobalMessageTable;
extern KMUTEX CurrentChannelLock;
extern LONG CurrentChannelRefCount;
extern PCHAR SerialPortBuffer;
extern LONG SerialPortConsumerIndex, SerialPortProducerIndex;
extern PCHAR Utf8ConversionBuffer;
extern BOOLEAN GlobalPagingNeeded, GlobalDoThreads;
extern ULONG Utf8ConversionBufferSize;
extern BOOLEAN CommandConsoleLaunchingEnabled;

//
// Function to initialize a SAC Semaphore Lock
//
FORCEINLINE
VOID
SacInitializeLock(IN PSAC_CHANNEL_LOCK Lock)
{
    KeInitializeSemaphore(&Lock->Lock, 1, 1);
}

//
// Function to acquire a SAC Semaphore Lock
//
FORCEINLINE
VOID
SacAcquireLock(IN PSAC_CHANNEL_LOCK Lock)
{
    KeWaitForSingleObject(&Lock->Lock, Executive, KernelMode, FALSE, NULL);
    ASSERT(Lock->RefCount == 0);
    _InterlockedIncrement(&Lock->RefCount);
}

//
// Function to release a SAC Semaphore Lock
//
FORCEINLINE
VOID
SacReleaseLock(IN PSAC_CHANNEL_LOCK Lock)
{
    ASSERT(Lock->RefCount == 1);
    _InterlockedDecrement(&Lock->RefCount);
    KeReleaseSemaphore(&Lock->Lock, SEMAPHORE_INCREMENT, 1, FALSE);
}

//
// Function to check if the SAC Mutex Lock is held
//
FORCEINLINE
VOID
SacAssertMutexLockHeld(VOID)
{
    ASSERT(CurrentChannelRefCount == 1);
    ASSERT(KeReadStateMutex(&CurrentChannelLock) == 0);
}

//
// Function to check if the SAC Mutex Lock is held
//
FORCEINLINE
VOID
SacInitializeMutexLock(VOID)
{
    KeInitializeMutex(&CurrentChannelLock, 0);
    CurrentChannelRefCount = 0;
}

//
// Function to acquire the SAC Mutex Lock
//
FORCEINLINE
VOID
SacAcquireMutexLock(VOID)
{
    KeWaitForSingleObject(&CurrentChannelLock, Executive, KernelMode, FALSE, NULL);
    ASSERT(CurrentChannelRefCount == 0);
    _InterlockedIncrement(&CurrentChannelRefCount);
}

//
// Function to release the SAC Mutex Lock
//
FORCEINLINE
VOID
SacReleaseMutexLock(VOID)
{
    ASSERT(CurrentChannelRefCount == 1);
    _InterlockedDecrement(&CurrentChannelRefCount);
    KeReleaseMutex(&CurrentChannelLock, FALSE);
}

//
// Locking Macros
//
#define ChannelLockCreates()            SacAcquireLock(&ChannelCreateLock);
#define ChannelUnlockCreates()          SacReleaseLock(&ChannelCreateLock);
#define ChannelLockOBuffer(x)           SacAcquireLock(&x->ChannelOBufferLock);
#define ChannelUnlockOBuffer(x)         SacReleaseLock(&x->ChannelOBufferLock);
#define ChannelLockIBuffer(x)           SacAcquireLock(&x->ChannelIBufferLock);
#define ChannelUnlockIBuffer(x)         SacReleaseLock(&x->ChannelIBufferLock);
#define ChannelLockAttributes(x)        SacAcquireLock(&x->ChannelAttributeLock);
#define ChannelUnlockAttributes(x)      SacReleaseLock(&x->ChannelAttributeLock);
#define ChannelSlotLock(x)              SacAcquireLock(&ChannelSlotLock[x]);
#define ChannelSlotUnlock(x)            SacReleaseLock(&ChannelSlotLock[x]);

//
// Channel Accessors
//
FORCEINLINE
ULONG
ChannelGetFlags(IN PSAC_CHANNEL Channel)
{
    return Channel->Flags;
}

FORCEINLINE
LONG
ChannelGetIndex(IN PSAC_CHANNEL Channel)
{
    /* Return the index of the channel */
    return Channel->Index;
}

FORCEINLINE
BOOLEAN
ChannelHasNewIBufferData(IN PSAC_CHANNEL Channel)
{
    /* Return if there's any new data in the input buffer */
    return Channel->ChannelHasNewIBufferData;
}

//
// FIXME: ANSI.H
//
//
// Source: http://en.wikipedia.org/wiki/ANSI_escape_code
//
typedef enum _VT_ANSI_ATTRIBUTES
{
    //
    // Attribute modifiers (mostly supported)
    //
    Normal,
    Bold,
    Faint,
    Italic,
    Underline,
    SlowBlink,
    FastBlink,
    Inverse,
    Conceal,
    Strikethrough,

    //
    // Font selectors (not supported)
    //
    PrimaryFont,
    AlternateFont1,
    AlternateFont2,
    AlternateFont3,
    Alternatefont4,
    AlternateFont5,
    AlternateFont6,
    AlternateFont7,
    AlternateFont8,
    AlternateFont9,

    //
    // Additional attributes (not supported)
    //
    Fraktur,
    DoubleUnderline,

    //
    // Attribute Un-modifiers (mostly supported)
    //
    BoldOff,
    ItalicOff,
    UnderlineOff,
    BlinkOff,
    Reserved,
    InverseOff,
    ConcealOff,
    StrikethroughOff,

    //
    // Standard Text Color
    //
    SetColorStart,
    SetColorBlack = SetColorStart,
    SetColorRed,
    SetColorGreen,
    SetColorYellow,
    SetColorBlue,
    SetcolorMAgent,
    SetColorCyan,
    SetColorWhite,
    SetColorMax = SetColorWhite,

    //
    // Extended Text Color (not supported)
    //
    SetColor256,
    SeTextColorDefault,

    //
    // Standard Background Color
    //
    SetBackColorStart,
    SetBackColorBlack = SetBackColorStart,
    SetBackColorRed,
    SetBackColorGreen,
    SetBackColorYellow,
    SetBackColorBlue,
    SetBackcolorMAgent,
    SetBackColorCyan,
    SetBackColorWhite,
    SetBackColorMax = SetBackColorWhite,

    //
    // Extended Background Color (not supported)
    //
    SetBackColor256,
    SetBackColorDefault,

    //
    // Extra Attributes (not supported)
    //
    Reserved1,
    Framed,
    Encircled,
    Overlined,
    FramedOff,
    OverlinedOff,
    Reserved2,
    Reserved3,
    Reserved4,
    Reserved5

    //
    // Ideograms (not supported)
    //
} VT_ANSI_ATTRIBUTES;

//
// The following site is a good reference on VT100/ANSI escape codes
// http://www.termsys.demon.co.uk/vtansi.htm
//
#define VT_ANSI_ESCAPE              L'\x1B'
#define VT_ANSI_COMMAND             L'['

#define VT_ANSI_CURSOR_UP_CHAR      L'A'
#define VT_ANSI_CURSOR_UP           L"[A"

#define VT_ANSI_CURSOR_DOWN_CHAR    L'B'
#define VT_ANSI_CURSOR_DOWN         L"[B"

#define VT_ANSI_CURSOR_RIGHT_CHAR   L'C'
#define VT_ANSI_CURSOR_RIGHT        L"[C"

#define VT_ANSI_CURSOR_LEFT_CHAR    L'D'
#define VT_ANSI_CURSOR_LEFT         L"[D"

#define VT_ANSI_ERASE_LINE_CHAR     L'K'
#define VT_ANSI_ERASE_END_LINE      L"[K"
#define VT_ANSI_ERASE_START_LINE    L"[1K"
#define VT_ANSI_ERASE_ENTIRE_LINE   L"[2K"

#define VT_ANSI_ERASE_SCREEN_CHAR   L'J'
#define VT_ANSI_ERASE_DOWN_SCREEN   L"[J"
#define VT_ANSI_ERASE_UP_SCREEN     L"[1J"
#define VT_ANSI_ERASE_ENTIRE_SCREEN L"[2J"

#define VT_ANSI_BACKTAB_CHAR        L'Z'
#define VT_220_BACKTAB              L"[0Z"

#define VT_ANSI_SET_ATTRIBUTE_CHAR  L'm'
#define VT_ANSI_SEPARATOR_CHAR      L';'
#define VT_ANSI_HVP_CURSOR_CHAR     L'f'
#define VT_ANSI_CUP_CURSOR_CHAR     L'H'
#define VT_ANSI_SCROLL_CHAR         L'r'

#endif /* _SACDRV_H_ */