reactos/drivers/sac/driver/sacdrv.h

   1 /*
   2  * PROJECT:     ReactOS Drivers
   3  * LICENSE:     BSD - See COPYING.ARM in the top level directory
   4  * FILE:        drivers/sac/driver/sacdrv.h
   5  * PURPOSE:     Driver for the Server Administration Console (SAC) for EMS
   6  * PROGRAMMERS: ReactOS Portable Systems Group
   7  */
   8
   9 #ifndef _SACDRV_H_
  10 #define _SACDRV_H_
  11
  12 /* INCLUDES *******************************************************************/
  13
  14 #include <ntifs.h>
  15 #include <stdio.h>
  16 #include <ntoskrnl/include/internal/hdl.h>
  17 #include <sacmsg.h>
  18
  19 /* DEFINES ********************************************************************/
  20
  21 //
  22 // SAC Heap Allocator Macros
  23 //
  24 #define SacAllocatePool(Length, Tag)    \
  25     MyAllocatePool(Length, Tag, __FILE__, __LINE__)
  26 #define SacFreePool(Pointer)            \
  27     MyFreePool((PVOID*)(&Pointer))
  28
  29 //
  30 // SAC Debugging Macro and Constants
  31 //
  32 #define SAC_DBG_ENTRY_EXIT                  0x01
  33 #define SAC_DBG_UTIL                        0x02
  34 #define SAC_DBG_INIT                        0x04
  35 #define SAC_DBG_MM                          0x1000
  36 #define SAC_DBG_MACHINE                     0x2000
  37 #define SAC_DBG(x, ...)                     \
  38     if (SACDebug & x)                       \
  39     {                                       \
  40         DbgPrint("SAC %s: ", __FUNCTION__); \
  41         DbgPrint(__VA_ARGS__);              \
  42     }
  43
  44 //
  45 // SAC Parameter Checking Macros
  46 //
  47 #define CHECK_PARAMETER_WITH_STATUS(Parameter, Status)  \
  48 {                                                       \
  49     ASSERT(((PVOID)(Parameter)) != NULL);               \
  50     if (((PVOID)(Parameter)) == NULL)                   \
  51     {                                                   \
  52         return Status;                                  \
  53     }                                                   \
  54 }
  55 #define CHECK_PARAMETER(x)      \
  56     CHECK_PARAMETER_WITH_STATUS(x, STATUS_INVALID_PARAMETER)
  57 #define CHECK_PARAMETER1(x)     \
  58     CHECK_PARAMETER_WITH_STATUS(x, STATUS_INVALID_PARAMETER_1)
  59 #define CHECK_PARAMETER2(x)     \
  60     CHECK_PARAMETER_WITH_STATUS(x, STATUS_INVALID_PARAMETER_2)
  61 #define CHECK_PARAMETER3(x)     \
  62     CHECK_PARAMETER_WITH_STATUS(x, STATUS_INVALID_PARAMETER_3)
  63 #define CHECK_PARAMETER4(x)     \
  64     CHECK_PARAMETER_WITH_STATUS(x, STATUS_INVALID_PARAMETER_4)
  65 #define CHECK_ALLOCATION(x)     \
  66     CHECK_PARAMETER_WITH_STATUS(x, STATUS_NO_MEMORY)
  67
  68 //
  69 // SAC Channel Event Macros
  70 //
  71 #define ChannelInitializeEvent(Channel, Attributes, x)                  \
  72 {                                                                       \
  73     PVOID Object, WaitObject;                                           \
  74     if (Attributes->x)                                                  \
  75     {                                                                   \
  76         if (!VerifyEventWaitable(Attributes->x, &Object, &WaitObject))  \
  77         {                                                               \
  78             goto FailChannel;                                           \
  79         }                                                               \
  80         Channel->x = Attributes->x;                                     \
  81         Channel->x##ObjectBody = Object;                                \
  82         Channel->x##WaitObjectBody = WaitObject;                        \
  83     }                                                                   \
  84 }
  85 #define ChannelUninitializeEvent(Channel, x, f)         \
  86 {                                                       \
  87     ASSERT(ChannelGetFlags(Channel) & (f));             \
  88     ASSERT(Channel->x##ObjectBody);                     \
  89     ASSERT(Channel->x##WaitObjectBody);                 \
  90     if (Channel->x##ObjectBody)                         \
  91     {                                                   \
  92         ObDereferenceObject(Channel->x##ObjectBody);    \
  93         Channel->Flags &= ~(f);                         \
  94         Channel->x = NULL;                              \
  95         Channel->x##ObjectBody = NULL;                  \
  96         Channel->x##WaitObjectBody = NULL;              \
  97     }                                                   \
  98 }
  99 #define ChannelSetEvent(Channel, x)                                     \
 100 {                                                                       \
 101     ASSERT(Channel->x);                                                 \
 102     ASSERT(Channel->x##ObjectBody);                                     \
 103     ASSERT(Channel->x##WaitObjectBody);                                 \
 104     if (Channel->x##WaitObjectBody)                                     \
 105     {                                                                   \
 106         KeSetEvent(Channel->x##WaitObjectBody, EVENT_INCREMENT, FALSE); \
 107         Status = STATUS_SUCCESS;                                        \
 108     }                                                                   \
 109     else                                                                \
 110     {                                                                   \
 111         Status = STATUS_UNSUCCESSFUL;                                   \
 112     }                                                                   \
 113 }
 114 #define ChannelClearEvent(Channel, x)               \
 115 {                                                   \
 116     ASSERT(Channel->x);                             \
 117     ASSERT(Channel->x##ObjectBody);                 \
 118     ASSERT(Channel->x##WaitObjectBody);             \
 119     if (Channel->x##WaitObjectBody)                 \
 120     {                                               \
 121         KeClearEvent(Channel->x##WaitObjectBody);   \
 122         Status = STATUS_SUCCESS;                    \
 123     }                                               \
 124     else                                            \
 125     {                                               \
 126         Status = STATUS_UNSUCCESSFUL;               \
 127     }                                               \
 128 }
 129
 130 //
 131 // SAC Pool Tags, taken from pooltag.txt:
 132 //
 133 //  Rcp? - sacdrv.sys - SAC Driver (Headless)
 134 //  RcpA - sacdrv.sys -     Internal memory mgr alloc block
 135 //  RcpI - sacdrv.sys -     Internal memory mgr initial heap block
 136 //  RcpS - sacdrv.sys -     Security related block
 137 #define GENERIC_TAG                         '?pcR'
 138 #define ALLOC_BLOCK_TAG                     'ApcR'
 139 #define INITIAL_BLOCK_TAG                   'IpcR'
 140 #define SECURITY_BLOCK_TAG                  'SpcR'
 141 #define FREE_POOL_TAG                       'FpcR'
 142 #define GLOBAL_BLOCK_TAG                    'GpcR'
 143 #define CHANNEL_BLOCK_TAG                   'CpcR'
 144 #define LOCAL_MEMORY_SIGNATURE              'SSEL'
 145 #define GLOBAL_MEMORY_SIGNATURE             'DAEH'
 146
 147 //
 148 // Size Definitions
 149 //
 150 #define SAC_MEMORY_LIST_SIZE                (1 * 1024 * 1024)   // 1MB
 151 #define SAC_OBUFFER_SIZE                    (2 * 1024)          // 2KB
 152 #define SAC_CHANNEL_NAME_SIZE               64
 153 #define SAC_CHANNEL_DESCRIPTION_SIZE        256
 154 #define SAC_MAX_CHANNELS                    10
 155 #define SAC_SERIAL_PORT_BUFFER_SIZE         1024                // 1KB
 156 #define SAC_MAX_MESSAGES                    200
 157 #define SAC_VTUTF8_COL_WIDTH                80
 158 #define SAC_VTUTF8_COL_HEIGHT               25
 159 #define SAC_VTUTF8_ROW_HEIGHT               24
 160 #define MAX_UTF8_ENCODE_BLOCK_LENGTH        (Utf8ConversionBufferSize / 3 - 1)
 161 #define SAC_VTUTF8_OBUFFER_SIZE             0x2D00
 162 #define SAC_VTUTF8_IBUFFER_SIZE             0x2000
 163 #define SAC_RAW_OBUFFER_SIZE                0x2000
 164 #define SAC_RAW_IBUFFER_SIZE                0x2000
 165
 166 //
 167 // Channel flags
 168 //
 169 #define SAC_CHANNEL_FLAG_INTERNAL           0x1
 170 #define SAC_CHANNEL_FLAG_CLOSE_EVENT        0x2
 171 #define SAC_CHANNEL_FLAG_HAS_NEW_DATA_EVENT 0x4
 172 #define SAC_CHANNEL_FLAG_LOCK_EVENT         0x8
 173 #define SAC_CHANNEL_FLAG_REDRAW_EVENT       0x10
 174 #define SAC_CHANNEL_FLAG_APPLICATION        0x20
 175
 176 //
 177 // Cell Flags
 178 //
 179 #define SAC_CELL_FLAG_BLINK                 1
 180 #define SAC_CELL_FLAG_BOLD                  2
 181 #define SAC_CELL_FLAG_INVERTED              4
 182
 183 //
 184 // Forward definitions
 185 //
 186 struct _SAC_CHANNEL;
 187
 188 //
 189 // Structures used by the SAC Heap Allocator
 190 //
 191 typedef struct _SAC_MEMORY_ENTRY
 192 {
 193     ULONG Signature;
 194     ULONG Tag;
 195     ULONG Size;
 196 } SAC_MEMORY_ENTRY, *PSAC_MEMORY_ENTRY;
 197 typedef struct _SAC_MEMORY_LIST
 198 {
 199     ULONG Signature;
 200     PSAC_MEMORY_ENTRY LocalDescriptor;
 201     ULONG Size;
 202     struct _SAC_MEMORY_LIST* Next;
 203 } SAC_MEMORY_LIST, *PSAC_MEMORY_LIST;
 204
 205 typedef struct _SAC_MESSAGE_ENTRY
 206 {
 207     ULONG Index;
 208     PWCHAR Buffer;
 209 } SAC_MESSAGE_ENTRY, *PSAC_MESSAGE_ENTRY;
 210
 211 //
 212 // These are the VT-100/220/ANSI Escape Codes supported by SAC as input
 213 //
 214 typedef enum _SAC_ANSI_COMMANDS
 215 {
 216     SacCursorUp,
 217     SacCursorDown,
 218     SacCursorRight,
 219     SacCursorLeft,
 220     SacFontNormal,
 221     SacFontBlink,
 222     SacFontBlinkOff,
 223     SacFontBold,
 224     SacFontBoldOff,
 225     SacFontInverse,
 226     SacFontInverseOff,
 227     SacBackTab,
 228     SacEraseEndOfLine,
 229     SacEraseStartOfLine,
 230     SacEraseLine,
 231     SacEraseEndOfScreen,
 232     SacEraseStartOfScreen,
 233     SacEraseScreen,
 234     SacSetCursorPosition,
 235     SacSetScrollRegion,
 236     SacSetColors,
 237     SacSetBackgroundColor,
 238     SacSetFontColor,
 239     SacSetColorsAndAttributes
 240 } SAC_ANSI_COMMANDS;
 241
 242 //
 243 // These are the VT-100/220/ANSI Escape Codes send by SAC as output
 244 //
 245 typedef enum _SAC_ANSI_DISPATCH
 246 {
 247     SacAnsiClearScreen,
 248     SacAnsiClearEndOfScreen,
 249     SacAnsiClearEndOfLine,
 250     SacAnsiSetColors,
 251     SacAnsiSetPosition,
 252     SacAnsiClearAttributes,
 253     SacAnsiSetInverseAttribute,
 254     SacAnsiClearInverseAttribute,
 255     SacAnsiSetBlinkAttribute,
 256     SacAnsiClearBlinkAttribute,
 257     SacAnsiSetBoldAttribute,
 258     SacAnsiClearBoldAttribute
 259 } SAC_ANSI_DISPATCH;
 260
 261 //
 262 // Commands that the consumer and producer share
 263 //
 264 typedef enum _SAC_POST_COMMANDS
 265 {
 266     Nothing,
 267     Shutdown,
 268     Close,
 269     Restart
 270 } SAC_POST_COMMANDS;
 271
 272 //
 273 // SAC supports 3 different channel output types
 274 //
 275 typedef enum _SAC_CHANNEL_TYPE
 276 {
 277     VtUtf8,
 278     Cmd,
 279     Raw
 280 } SAC_CHANNEL_TYPE;
 281
 282 //
 283 // A SAC channel can be active or inactive
 284 //
 285 typedef enum _SAC_CHANNEL_STATUS
 286 {
 287     Inactive,
 288     Active
 289 } SAC_CHANNEL_STATUS, *PSAC_CHANNEL_STATUS;
 290
 291 //
 292 // A SAC channel identifier
 293 //
 294 typedef struct _SAC_CHANNEL_ID
 295 {
 296     GUID ChannelGuid;
 297     ULONG ChannelId;
 298 } SAC_CHANNEL_ID, *PSAC_CHANNEL_ID;
 299
 300 //
 301 // Reference-counted SAC channel semaphore lock
 302 //
 303 typedef struct _SAC_CHANNEL_LOCK
 304 {
 305     LONG RefCount;
 306     KSEMAPHORE Lock;
 307 } SAC_CHANNEL_LOCK, *PSAC_CHANNEL_LOCK;
 308
 309 //
 310 // Structure of the cell-buffer when in VT-UTF8 Mode
 311 //
 312 typedef struct _SAC_CELL_DATA
 313 {
 314     UCHAR CellBackColor;
 315     UCHAR CellForeColor;
 316     UCHAR CellFlags;
 317     WCHAR Char;
 318 } SAC_CELL_DATA, *PSAC_CELL_DATA;
 319 C_ASSERT(sizeof(SAC_CELL_DATA) == 6);
 320
 321 //
 322 // Screen buffer when in VT-UTF8 Mode
 323 //
 324 typedef struct _SAC_VTUTF8_SCREEN
 325 {
 326     SAC_CELL_DATA Cell[SAC_VTUTF8_ROW_HEIGHT][SAC_VTUTF8_COL_WIDTH];
 327 } SAC_VTUTF8_SCREEN, *PSAC_VTUTF8_SCREEN;
 328
 329 //
 330 // Small optimization to easily recognize the most common VT-100/ANSI codes
 331 //
 332 typedef struct _SAC_STATIC_ESCAPE_STRING
 333 {
 334     WCHAR Sequence[10];
 335     ULONG Size;
 336     ULONG Action;
 337 } SAC_STATIC_ESCAPE_STRING, *PSAC_STATIC_ESCAPE_STRING;
 338
 339 //
 340 // Channel callbacks
 341 //
 342 typedef
 343 NTSTATUS
 344 (NTAPI *PSAC_CHANNEL_CREATE)(
 345     IN struct _SAC_CHANNEL* Channel
 346 );
 347
 348 typedef
 349 NTSTATUS
 350 (NTAPI *PSAC_CHANNEL_DESTROY)(
 351     IN struct _SAC_CHANNEL* Channel
 352 );
 353
 354 typedef
 355 NTSTATUS
 356 (NTAPI *PSAC_CHANNEL_OREAD)(
 357     IN struct _SAC_CHANNEL* Channel,
 358     IN PCHAR Buffer,
 359     IN ULONG BufferSize,
 360     OUT PULONG ByteCount
 361 );
 362
 363 typedef
 364 NTSTATUS
 365 (NTAPI *PSAC_CHANNEL_OECHO)(
 366     IN struct _SAC_CHANNEL* Channel,
 367     IN PCHAR String,
 368     IN ULONG Length
 369 );
 370
 371 typedef
 372 NTSTATUS
 373 (NTAPI *PSAC_CHANNEL_OFLUSH)(
 374     IN struct _SAC_CHANNEL* Channel
 375 );
 376
 377 typedef
 378 NTSTATUS
 379 (NTAPI *PSAC_CHANNEL_OWRITE)(
 380     IN struct _SAC_CHANNEL* Channel,
 381     IN PCHAR String,
 382     IN ULONG Length
 383 );
 384
 385 typedef
 386 NTSTATUS
 387 (NTAPI *PSAC_CHANNEL_IREAD)(
 388     IN struct _SAC_CHANNEL* Channel,
 389     IN PCHAR Buffer,
 390     IN ULONG BufferSize,
 391     IN PULONG ReturnBufferSize
 392 );
 393
 394 typedef
 395 NTSTATUS
 396 (NTAPI *PSAC_CHANNEL_IBUFFER_FULL)(
 397     IN struct _SAC_CHANNEL* Channel,
 398     OUT PBOOLEAN BufferStatus
 399 );
 400
 401 typedef
 402 ULONG
 403 (NTAPI *PSAC_CHANNEL_IBUFFER_LENGTH)(
 404     IN struct _SAC_CHANNEL* Channel
 405 );
 406
 407 typedef
 408 WCHAR
 409 (NTAPI *PSAC_CHANNEL_IREAD_LAST)(
 410     IN struct _SAC_CHANNEL* Channel
 411 );
 412
 413 typedef
 414 NTSTATUS
 415 (NTAPI *PSAC_CHANNEL_IWRITE)(
 416     IN struct _SAC_CHANNEL* Channel,
 417     IN PCHAR Buffer,
 418     IN ULONG BufferSize
 419 );
 420
 421 //
 422 // A channel and its attributes
 423 //
 424 typedef struct _SAC_CHANNEL
 425 {
 426     LONG Index;
 427     SAC_CHANNEL_ID ChannelId;
 428     HANDLE CloseEvent;
 429     PVOID CloseEventObjectBody;
 430     PKEVENT CloseEventWaitObjectBody;
 431     HANDLE HasNewDataEvent;
 432     PVOID HasNewDataEventObjectBody;
 433     PKEVENT HasNewDataEventWaitObjectBody;
 434     HANDLE LockEvent;
 435     PVOID LockEventObjectBody;
 436     PKEVENT LockEventWaitObjectBody;
 437     HANDLE RedrawEvent;
 438     PVOID RedrawEventObjectBody;
 439     PKEVENT RedrawEventWaitObjectBody;
 440     PFILE_OBJECT FileObject;
 441     SAC_CHANNEL_TYPE ChannelType;
 442     SAC_CHANNEL_STATUS ChannelStatus;
 443     WCHAR NameBuffer[SAC_CHANNEL_NAME_SIZE + 1];
 444     WCHAR DescriptionBuffer[SAC_CHANNEL_DESCRIPTION_SIZE + 1];
 445     ULONG Flags;
 446     GUID ApplicationType;
 447     LONG WriteEnabled;
 448     ULONG IBufferIndex;
 449     PCHAR IBuffer;
 450     LONG ChannelHasNewIBufferData;
 451     UCHAR CursorRow;
 452     UCHAR CursorCol;
 453     UCHAR CellForeColor;
 454     UCHAR CellBackColor;
 455     UCHAR CellFlags;
 456     PCHAR OBuffer;
 457     ULONG OBufferIndex;
 458     ULONG OBufferFirstGoodIndex;
 459     LONG ChannelHasNewOBufferData;
 460     PSAC_CHANNEL_CREATE ChannelCreate;
 461     PSAC_CHANNEL_DESTROY ChannelDestroy;
 462     PSAC_CHANNEL_OFLUSH ChannelOutputFlush;
 463     PSAC_CHANNEL_OECHO ChannelOutputEcho;
 464     PSAC_CHANNEL_OWRITE ChannelOutputWrite;
 465     PSAC_CHANNEL_OREAD ChannelOutputRead;
 466     PSAC_CHANNEL_IWRITE ChannelInputWrite;
 467     PSAC_CHANNEL_IREAD ChannelInputRead;
 468     PSAC_CHANNEL_IREAD_LAST ChannelInputReadLast;
 469     PSAC_CHANNEL_IBUFFER_FULL ChannelInputBufferIsFull;
 470     PSAC_CHANNEL_IBUFFER_LENGTH ChannelInputBufferLength;
 471     SAC_CHANNEL_LOCK ChannelAttributeLock;
 472     SAC_CHANNEL_LOCK ChannelOBufferLock;
 473     SAC_CHANNEL_LOCK ChannelIBufferLock;
 474 } SAC_CHANNEL, *PSAC_CHANNEL;
 475
 476 typedef struct _SAC_CHANNEL_ATTRIBUTES
 477 {
 478     SAC_CHANNEL_TYPE ChannelType;
 479     WCHAR NameBuffer[SAC_CHANNEL_NAME_SIZE + 1];
 480     WCHAR DescriptionBuffer[SAC_CHANNEL_DESCRIPTION_SIZE + 1];
 481     ULONG Flag;
 482     HANDLE CloseEvent;
 483     HANDLE HasNewDataEvent;
 484     HANDLE LockEvent;
 485     HANDLE RedrawEvent;
 486     GUID ChannelId;
 487 } SAC_CHANNEL_ATTRIBUTES, *PSAC_CHANNEL_ATTRIBUTES;
 488
 489 //
 490 // Cached Machine Information
 491 //
 492 typedef struct _SAC_MACHINE_INFO
 493 {
 494     PWCHAR MachineName;
 495     PWCHAR MachineGuid;
 496     PWCHAR ProcessorArchitecture;
 497     PWCHAR MajorVersion;
 498     PWCHAR BuildNumber;
 499     PWCHAR ProductType;
 500     PWCHAR ServicePack;
 501 } SAC_MACHINE_INFO, *PSAC_MACHINE_INFO;
 502
 503 //
 504 // The device extension for the SAC
 505 //
 506 typedef struct _SAC_DEVICE_EXTENSION
 507 {
 508     PDEVICE_OBJECT DeviceObject;
 509     BOOLEAN Initialized;
 510     BOOLEAN Rundown;
 511     BOOLEAN PriorityFail;
 512     BOOLEAN RundownInProgress;
 513     KPRIORITY PriorityBoost;
 514     PEPROCESS Process;
 515     KSPIN_LOCK Lock;
 516     KEVENT RundownEvent;
 517     KEVENT Event;
 518     HANDLE WorkerThreadHandle;
 519     KEVENT WorkerThreadEvent;
 520     KTIMER Timer;
 521     KDPC Dpc;
 522     LIST_ENTRY List;
 523 } SAC_DEVICE_EXTENSION, *PSAC_DEVICE_EXTENSION;
 524
 525 //
 526 // Dispatch Routines
 527 //
 528 NTSTATUS
 529 NTAPI
 530 Dispatch(
 531     IN PDEVICE_OBJECT DeviceObject,
 532     IN PIRP Irp
 533 );
 534
 535 NTSTATUS
 536 NTAPI
 537 DispatchDeviceControl(
 538     IN PDEVICE_OBJECT DeviceObject,
 539     IN PIRP Irp
 540 );
 541
 542 NTSTATUS
 543 NTAPI
 544 DispatchShutdownControl(
 545     IN PDEVICE_OBJECT DeviceObject,
 546     IN PIRP Irp
 547 );
 548
 549 VOID
 550 NTAPI
 551 UnloadHandler(
 552     IN PDRIVER_OBJECT DriverObject
 553 );
 554
 555 //
 556 // Initialization and shutdown routines
 557 //
 558 VOID
 559 NTAPI
 560 FreeGlobalData(
 561     VOID
 562 );
 563
 564 VOID
 565 NTAPI
 566 FreeDeviceData(
 567     IN PDEVICE_OBJECT DeviceObject
 568 );
 569
 570 BOOLEAN
 571 NTAPI
 572 InitializeDeviceData(
 573     IN PDEVICE_OBJECT DeviceObject
 574 );
 575
 576 BOOLEAN
 577 NTAPI
 578 InitializeGlobalData(
 579     IN PUNICODE_STRING RegistryPath,
 580     IN PDRIVER_OBJECT DriverObject
 581 );
 582
 583 BOOLEAN
 584 NTAPI
 585 InitializeMemoryManagement(
 586     VOID
 587 );
 588
 589 VOID
 590 NTAPI
 591 FreeMemoryManagement(
 592     VOID
 593 );
 594
 595 VOID
 596 NTAPI
 597 InitializeCmdEventInfo(
 598     VOID
 599 );
 600
 601 VOID
 602 NTAPI
 603 InitializeMachineInformation(
 604     VOID
 605 );
 606
 607 NTSTATUS
 608 NTAPI
 609 PreloadGlobalMessageTable(
 610     IN PVOID ImageBase
 611 );
 612
 613 NTSTATUS
 614 NTAPI
 615 TearDownGlobalMessageTable(
 616     VOID
 617 );
 618
 619 NTSTATUS
 620 NTAPI
 621 GetCommandConsoleLaunchingPermission(
 622     OUT PBOOLEAN Permission
 623 );
 624
 625 NTSTATUS
 626 NTAPI
 627 ImposeSacCmdServiceStartTypePolicy(
 628     VOID
 629 );
 630
 631 NTSTATUS
 632 NTAPI
 633 RegisterBlueScreenMachineInformation(
 634     VOID
 635 );
 636
 637 VOID
 638 NTAPI
 639 FreeMachineInformation(
 640     VOID
 641 );
 642
 643 //
 644 // DPC, Timer, Thread Callbacks
 645 //
 646 VOID
 647 NTAPI
 648 TimerDpcRoutine(
 649     IN PKDPC Dpc,
 650     IN PVOID DeferredContext,
 651     IN PVOID SystemArgument1,
 652     IN PVOID SystemArgument2
 653 );
 654
 655 //
 656 // Custom SAC Heap Allocator Routines
 657 //
 658 PVOID
 659 NTAPI
 660 MyAllocatePool(
 661     IN SIZE_T PoolSize,
 662     IN ULONG Tag,
 663     IN PCHAR File,
 664     IN ULONG Line
 665 );
 666
 667 VOID
 668 NTAPI
 669 MyFreePool(
 670     IN PVOID *Block
 671 );
 672
 673 //
 674 // Connection Manager Routines
 675 //
 676 NTSTATUS
 677 NTAPI
 678 ConMgrInitialize(
 679     VOID
 680 );
 681
 682 VOID
 683 NTAPI
 684 ConMgrWorkerProcessEvents(
 685     IN PSAC_DEVICE_EXTENSION DeviceExtension
 686 );
 687
 688 NTSTATUS
 689 NTAPI
 690 ConMgrShutdown(
 691     VOID
 692 );
 693
 694 BOOLEAN
 695 NTAPI
 696 ConMgrSimpleEventMessage(
 697     IN ULONG MessageIndex,
 698     IN BOOLEAN LockHeld
 699 );
 700
 701 BOOLEAN
 702 NTAPI
 703 SacPutSimpleMessage(
 704     IN ULONG MessageIndex
 705 );
 706
 707 VOID
 708 NTAPI
 709 SacPutString(
 710     IN PWCHAR String
 711 );
 712
 713 NTSTATUS
 714 NTAPI
 715 ConMgrWriteData(
 716     IN PSAC_CHANNEL Channel,
 717     IN PVOID Buffer,
 718     IN ULONG BufferLength
 719 );
 720
 721 NTSTATUS
 722 NTAPI
 723 ConMgrFlushData(
 724     IN PSAC_CHANNEL Channel
 725 );
 726
 727 BOOLEAN
 728 NTAPI
 729 ConMgrIsWriteEnabled(
 730     IN PSAC_CHANNEL Channel
 731 );
 732
 733 NTSTATUS
 734 NTAPI
 735 ConMgrHandleEvent(
 736     IN ULONG EventCode,
 737     IN PSAC_CHANNEL Channel,
 738     OUT PVOID Data
 739 );
 740
 741 //
 742 // Channel Manager Routines
 743 //
 744 NTSTATUS
 745 NTAPI
 746 ChanMgrInitialize(
 747     VOID
 748 );
 749
 750 NTSTATUS
 751 NTAPI
 752 ChanMgrShutdown(
 753     VOID
 754 );
 755
 756 NTSTATUS
 757 NTAPI
 758 ChanMgrCreateChannel(
 759     OUT PSAC_CHANNEL *Channel,
 760     IN PSAC_CHANNEL_ATTRIBUTES Attributes
 761 );
 762
 763 NTSTATUS
 764 NTAPI
 765 ChanMgrGetByHandle(
 766     IN SAC_CHANNEL_ID ChannelId,
 767     OUT PSAC_CHANNEL* TargetChannel
 768 );
 769
 770 NTSTATUS
 771 NTAPI
 772 ChanMgrReleaseChannel(
 773     IN PSAC_CHANNEL Channel
 774 );
 775
 776 NTSTATUS
 777 NTAPI
 778 ChanMgrGetNextActiveChannel(
 779     IN PSAC_CHANNEL CurrentChannel,
 780     IN PULONG TargetIndex,
 781     OUT PSAC_CHANNEL *TargetChannel
 782 );
 783
 784 NTSTATUS
 785 NTAPI
 786 ChanMgrCloseChannel(
 787     IN PSAC_CHANNEL Channel
 788 );
 789
 790 //
 791 // Channel Routines
 792 //
 793 NTSTATUS
 794 NTAPI
 795 ChannelClose(
 796     IN PSAC_CHANNEL Channel
 797 );
 798
 799 BOOLEAN
 800 NTAPI
 801 ChannelIsEqual(
 802     IN PSAC_CHANNEL Channel,
 803     IN PSAC_CHANNEL_ID ChannelId
 804 );
 805
 806 NTSTATUS
 807 NTAPI
 808 ChannelOWrite(
 809     IN PSAC_CHANNEL Channel,
 810     IN PCHAR Buffer,
 811     IN ULONG BufferSize
 812 );
 813
 814 NTSTATUS
 815 NTAPI
 816 ChannelOFlush(
 817     IN PSAC_CHANNEL Channel
 818 );
 819
 820 NTSTATUS
 821 NTAPI
 822 ChannelSetRedrawEvent(
 823     IN PSAC_CHANNEL Channel
 824 );
 825
 826 NTSTATUS
 827 NTAPI
 828 ChannelClearRedrawEvent(
 829     IN PSAC_CHANNEL Channel
 830 );
 831
 832 NTSTATUS
 833 NTAPI
 834 ChannelHasRedrawEvent(
 835     IN PSAC_CHANNEL Channel,
 836     OUT PBOOLEAN Present
 837 );
 838
 839 BOOLEAN
 840 NTAPI
 841 ChannelIsActive(
 842     IN PSAC_CHANNEL Channel
 843 );
 844
 845 NTSTATUS
 846 NTAPI
 847 ChannelGetName(
 848     IN PSAC_CHANNEL Channel,
 849     OUT PWCHAR *Name
 850 );
 851
 852 BOOLEAN
 853 NTAPI
 854 ChannelIsEqual(
 855     IN PSAC_CHANNEL Channel,
 856     IN PSAC_CHANNEL_ID ChannelId
 857 );
 858
 859 NTSTATUS
 860 NTAPI
 861 ChannelCreate(
 862     IN PSAC_CHANNEL Channel,
 863     IN PSAC_CHANNEL_ATTRIBUTES Attributes,
 864     IN SAC_CHANNEL_ID ChannelId
 865 );
 866
 867 NTSTATUS
 868 NTAPI
 869 ChannelDestroy(
 870     IN PSAC_CHANNEL Channel
 871 );
 872
 873 NTSTATUS
 874 NTAPI
 875 ChannelIWrite(
 876     IN PSAC_CHANNEL Channel,
 877     IN PCHAR Buffer,
 878     IN ULONG BufferSize
 879 );
 880
 881 WCHAR
 882 NTAPI
 883 ChannelIReadLast(
 884     IN PSAC_CHANNEL Channel
 885 );
 886
 887 ULONG
 888 NTAPI
 889 ChannelIBufferLength(
 890     IN PSAC_CHANNEL Channel
 891 );
 892
 893 NTSTATUS
 894 NTAPI
 895 ChannelIRead(
 896     IN PSAC_CHANNEL Channel,
 897     IN PCHAR Buffer,
 898     IN ULONG BufferSize,
 899     IN OUT PULONG ResultBufferSize
 900 );
 901
 902 //
 903 // RAW Channel Table
 904 //
 905 NTSTATUS
 906 NTAPI
 907 RawChannelCreate(
 908     IN PSAC_CHANNEL Channel
 909 );
 910
 911 NTSTATUS
 912 NTAPI
 913 RawChannelDestroy(
 914     IN PSAC_CHANNEL Channel
 915 );
 916
 917 NTSTATUS
 918 NTAPI
 919 RawChannelORead(
 920     IN PSAC_CHANNEL Channel,
 921     IN PCHAR Buffer,
 922     IN ULONG BufferSize,
 923     OUT PULONG ByteCount
 924 );
 925
 926 NTSTATUS
 927 NTAPI
 928 RawChannelOEcho(
 929     IN PSAC_CHANNEL Channel,
 930     IN PCHAR String,
 931     IN ULONG Length
 932 );
 933
 934 NTSTATUS
 935 NTAPI
 936 RawChannelOFlush(
 937     IN PSAC_CHANNEL Channel
 938 );
 939
 940 NTSTATUS
 941 NTAPI
 942 RawChannelOWrite(
 943     IN PSAC_CHANNEL Channel,
 944     IN PCHAR String,
 945     IN ULONG Length
 946 );
 947
 948 NTSTATUS
 949 NTAPI
 950 RawChannelIRead(
 951     IN PSAC_CHANNEL Channel,
 952     IN PCHAR Buffer,
 953     IN ULONG BufferSize,
 954     IN PULONG ReturnBufferSize
 955 );
 956
 957 NTSTATUS
 958 NTAPI
 959 RawChannelIBufferIsFull(
 960     IN PSAC_CHANNEL Channel,
 961     OUT PBOOLEAN BufferStatus
 962 );
 963
 964 ULONG
 965 NTAPI
 966 RawChannelIBufferLength(
 967     IN PSAC_CHANNEL Channel
 968 );
 969
 970 WCHAR
 971 NTAPI
 972 RawChannelIReadLast(
 973     IN PSAC_CHANNEL Channel
 974 );
 975
 976 NTSTATUS
 977 NTAPI
 978 RawChannelIWrite(
 979     IN PSAC_CHANNEL Channel,
 980     IN PCHAR Buffer,
 981     IN ULONG BufferSize
 982 );
 983
 984 //
 985 // VT-UTF8 Channel Table
 986 //
 987 NTSTATUS
 988 NTAPI
 989 VTUTF8ChannelCreate(
 990     IN PSAC_CHANNEL Channel
 991 );
 992
 993 NTSTATUS
 994 NTAPI
 995 VTUTF8ChannelDestroy(
 996     IN PSAC_CHANNEL Channel
 997 );
 998
 999 NTSTATUS
1000 NTAPI
1001 VTUTF8ChannelORead(
1002     IN PSAC_CHANNEL Channel,
1003     IN PCHAR Buffer,
1004     IN ULONG BufferSize,
1005     OUT PULONG ByteCount
1006 );
1007
1008 NTSTATUS
1009 NTAPI
1010 VTUTF8ChannelOEcho(
1011     IN PSAC_CHANNEL Channel,
1012     IN PCHAR String,
1013     IN ULONG Length
1014 );
1015
1016 NTSTATUS
1017 NTAPI
1018 VTUTF8ChannelOFlush(
1019     IN PSAC_CHANNEL Channel
1020 );
1021
1022 NTSTATUS
1023 NTAPI
1024 VTUTF8ChannelOWrite(
1025     IN PSAC_CHANNEL Channel,
1026     IN PCHAR String,
1027     IN ULONG Length
1028 );
1029
1030 NTSTATUS
1031 NTAPI
1032 VTUTF8ChannelIRead(
1033     IN PSAC_CHANNEL Channel,
1034     IN PCHAR Buffer,
1035     IN ULONG BufferSize,
1036     IN PULONG ReturnBufferSize
1037 );
1038
1039 NTSTATUS
1040 NTAPI
1041 VTUTF8ChannelIBufferIsFull(
1042     IN PSAC_CHANNEL Channel,
1043     OUT PBOOLEAN BufferStatus
1044 );
1045
1046 ULONG
1047 NTAPI
1048 VTUTF8ChannelIBufferLength(
1049     IN PSAC_CHANNEL Channel
1050 );
1051
1052 WCHAR
1053 NTAPI
1054 VTUTF8ChannelIReadLast(
1055     IN PSAC_CHANNEL Channel
1056 );
1057
1058 NTSTATUS
1059 NTAPI
1060 VTUTF8ChannelIWrite(
1061     IN PSAC_CHANNEL Channel,
1062     IN PCHAR Buffer,
1063     IN ULONG BufferSize
1064 );
1065
1066
1067 //
1068 // Helper Routines
1069 //
1070 BOOLEAN
1071 NTAPI
1072 SacTranslateUtf8ToUnicode(
1073     IN CHAR Utf8Char,
1074     IN PCHAR Utf8Buffer,
1075     OUT PWCHAR Utf8Value
1076 );
1077
1078 ULONG
1079 NTAPI
1080 GetMessageLineCount(
1081     IN ULONG MessageIndex
1082 );
1083
1084 NTSTATUS
1085 NTAPI
1086 SerialBufferGetChar(
1087     OUT PCHAR Char
1088 );
1089
1090 NTSTATUS
1091 NTAPI
1092 UTF8EncodeAndSend(
1093     IN PWCHAR String
1094 );
1095
1096 NTSTATUS
1097 NTAPI
1098 TranslateMachineInformationXML(
1099     IN PWCHAR *Buffer,
1100     IN PWCHAR ExtraData
1101 );
1102
1103 PWCHAR
1104 NTAPI
1105 GetMessage(
1106     IN ULONG MessageIndex
1107 );
1108
1109 BOOLEAN
1110 NTAPI
1111 VerifyEventWaitable(
1112     IN HANDLE Handle,
1113     OUT PVOID *WaitObject,
1114     OUT PVOID *ActualWaitObject
1115 );
1116
1117 BOOLEAN
1118 NTAPI
1119 SacTranslateUnicodeToUtf8(
1120     IN PWCHAR SourceBuffer,
1121     IN ULONG SourceBufferLength,
1122     OUT PCHAR DestinationBuffer,
1123     IN ULONG DestinationBufferSize,
1124     OUT PULONG UTF8Count,
1125     OUT PULONG ProcessedCount
1126 );
1127
1128 //
1129 // SAC Command Functions
1130 //
1131 VOID
1132 NTAPI
1133 DoRebootCommand(
1134     IN BOOLEAN Reboot
1135 );
1136
1137 VOID
1138 NTAPI
1139 DoFullInfoCommand(
1140     VOID
1141 );
1142
1143 VOID
1144 NTAPI
1145 DoPagingCommand(
1146     VOID
1147 );
1148
1149 VOID
1150 NTAPI
1151 DoSetTimeCommand(
1152     IN PCHAR InputTime
1153 );
1154
1155 VOID
1156 NTAPI
1157 DoKillCommand(
1158     IN PCHAR KillString
1159 );
1160
1161 VOID
1162 NTAPI
1163 DoLowerPriorityCommand(
1164     IN PCHAR PrioString
1165 );
1166
1167 VOID
1168 NTAPI
1169 DoRaisePriorityCommand(
1170     IN PCHAR PrioString
1171 );
1172
1173 VOID
1174 NTAPI
1175 DoLimitMemoryCommand(
1176     IN PCHAR LimitString
1177 );
1178
1179 VOID
1180 NTAPI
1181 DoCrashCommand(
1182     VOID
1183 );
1184
1185 VOID
1186 NTAPI
1187 DoMachineInformationCommand(
1188     VOID
1189 );
1190
1191 VOID
1192 NTAPI
1193 DoChannelCommand(
1194     IN PCHAR ChannelString
1195 );
1196
1197 VOID
1198 NTAPI
1199 DoCmdCommand(
1200     IN PCHAR InputString
1201 );
1202
1203 VOID
1204 NTAPI
1205 DoLockCommand(
1206     VOID
1207 );
1208
1209 VOID
1210 NTAPI
1211 DoHelpCommand(
1212     VOID
1213 );
1214
1215 VOID
1216 NTAPI
1217 DoGetNetInfo(
1218     IN BOOLEAN DoPrint
1219 );
1220
1221 VOID
1222 NTAPI
1223 DoSetIpAddressCommand(
1224     IN PCHAR IpString
1225 );
1226
1227 VOID
1228 NTAPI
1229 DoTlistCommand(
1230     VOID
1231 );
1232
1233 //
1234 // External data
1235 //
1236 extern ULONG SACDebug;
1237 extern PSAC_MESSAGE_ENTRY GlobalMessageTable;
1238 extern KMUTEX CurrentChannelLock;
1239 extern LONG CurrentChannelRefCount;
1240 extern PCHAR SerialPortBuffer;
1241 extern LONG SerialPortConsumerIndex, SerialPortProducerIndex;
1242 extern PCHAR Utf8ConversionBuffer;
1243 extern BOOLEAN GlobalPagingNeeded, GlobalDoThreads;
1244 extern ULONG Utf8ConversionBufferSize;
1245 extern BOOLEAN CommandConsoleLaunchingEnabled;
1246
1247 //
1248 // Function to initailize a SAC Semaphore Lock
1249 //
1250 FORCEINLINE
1251 VOID
1252 SacInitializeLock(IN PSAC_CHANNEL_LOCK Lock)
1253 {
1254     KeInitializeSemaphore(&Lock->Lock, 1, 1);
1255 }
1256
1257 //
1258 // Function to acquire a SAC Semaphore Lock
1259 //
1260 FORCEINLINE
1261 VOID
1262 SacAcquireLock(IN PSAC_CHANNEL_LOCK Lock)
1263 {
1264     KeWaitForSingleObject(&Lock->Lock, Executive, KernelMode, FALSE, NULL);
1265     ASSERT(Lock->RefCount == 0);
1266     _InterlockedIncrement(&Lock->RefCount);
1267 }
1268
1269 //
1270 // Function to release a SAC Semaphore Lock
1271 //
1272 FORCEINLINE
1273 VOID
1274 SacReleaseLock(IN PSAC_CHANNEL_LOCK Lock)
1275 {
1276     ASSERT(Lock->RefCount == 1);
1277     _InterlockedDecrement(&Lock->RefCount);
1278     KeReleaseSemaphore(&Lock->Lock, SEMAPHORE_INCREMENT, 1, FALSE);
1279 }
1280
1281 //
1282 // Function to check if the SAC Mutex Lock is held
1283 //
1284 FORCEINLINE
1285 VOID
1286 SacAssertMutexLockHeld(VOID)
1287 {
1288     ASSERT(CurrentChannelRefCount == 1);
1289     ASSERT(KeReadStateMutex(&CurrentChannelLock) == 0);
1290 }
1291
1292 //
1293 // Function to check if the SAC Mutex Lock is held
1294 //
1295 FORCEINLINE
1296 VOID
1297 SacInitializeMutexLock(VOID)
1298 {
1299     KeInitializeMutex(&CurrentChannelLock, 0);
1300     CurrentChannelRefCount = 0;
1301 }
1302
1303 //
1304 // Function to acquire the SAC Mutex Lock
1305 //
1306 FORCEINLINE
1307 VOID
1308 SacAcquireMutexLock(VOID)
1309 {
1310     KeWaitForSingleObject(&CurrentChannelLock, Executive, KernelMode, FALSE, NULL);
1311     ASSERT(CurrentChannelRefCount == 0);
1312     _InterlockedIncrement(&CurrentChannelRefCount);
1313 }
1314
1315 //
1316 // Function to release the SAC Mutex Lock
1317 //
1318 FORCEINLINE
1319 VOID
1320 SacReleaseMutexLock(VOID)
1321 {
1322     ASSERT(CurrentChannelRefCount == 1);
1323     _InterlockedDecrement(&CurrentChannelRefCount);
1324     KeReleaseMutex(&CurrentChannelLock, FALSE);
1325 }
1326
1327 //
1328 // Locking Macros
1329 //
1330 #define ChannelLockCreates()            SacAcquireLock(&ChannelCreateLock);
1331 #define ChannelUnlockCreates()          SacReleaseLock(&ChannelCreateLock);
1332 #define ChannelLockOBuffer(x)           SacAcquireLock(&x->ChannelOBufferLock);
1333 #define ChannelUnlockOBuffer(x)         SacReleaseLock(&x->ChannelOBufferLock);
1334 #define ChannelLockIBuffer(x)           SacAcquireLock(&x->ChannelIBufferLock);
1335 #define ChannelUnlockIBuffer(x)         SacReleaseLock(&x->ChannelIBufferLock);
1336 #define ChannelLockAttributes(x)        SacAcquireLock(&x->ChannelAttributeLock);
1337 #define ChannelUnlockAttributes(x)      SacReleaseLock(&x->ChannelAttributeLock);
1338 #define ChannelSlotLock(x)              SacAcquireLock(&ChannelSlotLock[x]);
1339 #define ChannelSlotUnlock(x)            SacReleaseLock(&ChannelSlotLock[x]);
1340
1341 //
1342 // Channel Accessors
1343 //
1344 FORCEINLINE
1345 ULONG
1346 ChannelGetFlags(IN PSAC_CHANNEL Channel)
1347 {
1348     return Channel->Flags;
1349 }
1350
1351 FORCEINLINE
1352 LONG
1353 ChannelGetIndex(IN PSAC_CHANNEL Channel)
1354 {
1355     /* Return the index of the channel */
1356     return Channel->Index;
1357 }
1358
1359 FORCEINLINE
1360 BOOLEAN
1361 ChannelHasNewIBufferData(IN PSAC_CHANNEL Channel)
1362 {
1363     /* Return if there's any new data in the input buffer */
1364     return Channel->ChannelHasNewIBufferData;
1365 }
1366
1367 //
1368 // FIXME: ANSI.H
1369 //
1370 //
1371 // Source: http://en.wikipedia.org/wiki/ANSI_escape_code
1372 //
1373 typedef enum _VT_ANSI_ATTRIBUTES
1374 {
1375     //
1376     // Attribute modifiers (mostly supported)
1377     //
1378     Normal,
1379     Bold,
1380     Faint,
1381     Italic,
1382     Underline,
1383     SlowBlink,
1384     FastBlink,
1385     Inverse,
1386     Conceal,
1387     Strikethrough,
1388
1389     //
1390     // Font selectors (not supported)
1391     //
1392     PrimaryFont,
1393     AlternateFont1,
1394     AlternateFont2,
1395     AlternateFont3,
1396     Alternatefont4,
1397     AlteronateFont5,
1398     AlteronateFont6,
1399     AlternateFont7,
1400     AlternateFont8,
1401     AlternateFont9,
1402
1403     //
1404     // Additional attributes (not supported)
1405     //
1406     Fraktur,
1407     DoubleUnderline,
1408
1409     //
1410     // Attribute Un-modifiers (mostly supported)
1411     //
1412     BoldOff,
1413     ItalicOff,
1414     UnderlineOff,
1415     BlinkOff,
1416     Reserved,
1417     InverseOff,
1418     ConcealOff,
1419     StrikethroughOff,
1420
1421     //
1422     // Standard Text Color
1423     //
1424     SetColorStart,
1425     SetColorBlack = SetColorStart,
1426     SetColorRed,
1427     SetColorGreen,
1428     SetColorYellow,
1429     SetColorBlue,
1430     SetcolorMAgent,
1431     SetColorCyan,
1432     SetColorWhite,
1433     SetColorMax = SetColorWhite,
1434
1435     //
1436     // Extended Text Color (not supported)
1437     //
1438     SetColor256,
1439     SeTextColorDefault,
1440
1441     //
1442     // Standard Background Color
1443     //
1444     SetBackColorStart,
1445     SetBackColorBlack = SetBackColorStart,
1446     SetBackColorRed,
1447     SetBackColorGreen,
1448     SetBackColorYellow,
1449     SetBackColorBlue,
1450     SetBackcolorMAgent,
1451     SetBackColorCyan,
1452     SetBackColorWhite,
1453     SetBackColorMax = SetBackColorWhite,
1454
1455     //
1456     // Extended Background Color (not supported)
1457     //
1458     SetBackColor256,
1459     SetBackColorDefault,
1460
1461     //
1462     // Extra Attributes (not supported)
1463     //
1464     Reserved1,
1465     Framed,
1466     Encircled,
1467     Overlined,
1468     FramedOff,
1469     OverlinedOff,
1470     Reserved2,
1471     Reserved3,
1472     Reserved4,
1473     Reserved5
1474
1475     //
1476     // Ideograms (not supported)
1477     //
1478 } VT_ANSI_ATTRIBUTES;
1479
1480 //
1481 // The following site is a good reference on VT100/ANSI escape codes
1482 // http://www.termsys.demon.co.uk/vtansi.htm
1483 //
1484 #define VT_ANSI_ESCAPE              L'\x1B'
1485 #define VT_ANSI_COMMAND             L'['
1486
1487 #define VT_ANSI_CURSOR_UP_CHAR      L'A'
1488 #define VT_ANSI_CURSOR_UP           L"[A"
1489
1490 #define VT_ANSI_CURSOR_DOWN_CHAR    L'B'
1491 #define VT_ANSI_CURSOR_DOWN         L"[B"
1492
1493 #define VT_ANSI_CURSOR_RIGHT_CHAR   L'C'
1494 #define VT_ANSI_CURSOR_RIGHT        L"[C"
1495
1496 #define VT_ANSI_CURSOR_LEFT_CHAR    L'D'
1497 #define VT_ANSI_CURSOR_LEFT         L"[D"
1498
1499 #define VT_ANSI_ERASE_LINE_CHAR     L'K'
1500 #define VT_ANSI_ERASE_END_LINE      L"[K"
1501 #define VT_ANSI_ERASE_START_LINE    L"[1K"
1502 #define VT_ANSI_ERASE_ENTIRE_LINE   L"[2K"
1503
1504 #define VT_ANSI_ERASE_SCREEN_CHAR   L'J'
1505 #define VT_ANSI_ERASE_DOWN_SCREEN   L"[J"
1506 #define VT_ANSI_ERASE_UP_SCREEN     L"[1J"
1507 #define VT_ANSI_ERASE_ENTIRE_SCREEN L"[2J"
1508
1509 #define VT_ANSI_BACKTAB_CHAR        L'Z'
1510 #define VT_220_BACKTAB              L"[0Z"
1511
1512 #define VT_ANSI_SET_ATTRIBUTE_CHAR  L'm'
1513 #define VT_ANSI_SEPARATOR_CHAR      L';'
1514 #define VT_ANSI_HVP_CURSOR_CHAR     L'f'
1515 #define VT_ANSI_CUP_CURSOR_CHAR     L'H'
1516 #define VT_ANSI_SCROLL_CHAR         L'r'
1517
1518 #endif /* _SACDRV_H_ */