1 /* $Id: console.c,v 1.55 2003/03/09 21:37:18 hbirr Exp $
3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS system libraries
5 * FILE: lib/kernel32/misc/console.c
6 * PURPOSE: Win32 server console functions
10 * 19990204 EA SetConsoleTitleA
14 /* INCLUDES ******************************************************************/
19 #include <kernel32/kernel32.h>
21 /* GLOBALS *******************************************************************/
23 static BOOL IgnoreCtrlEvents
= FALSE
;
24 static ULONG NrCtrlHandlers
= 0;
25 static PHANDLER_ROUTINE
* CtrlHandlers
= NULL
;
27 /* FUNCTIONS *****************************************************************/
30 AddConsoleAliasA (LPSTR Source
,
34 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
39 AddConsoleAliasW (LPWSTR Source
,
43 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
48 ConsoleMenuControl (HANDLE hConsole
,
55 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
60 DuplicateConsoleHandle (HANDLE hConsole
,
61 DWORD dwDesiredAccess
,
65 CSRSS_API_REQUEST Request
;
66 CSRSS_API_REPLY Reply
;
69 if (IsConsoleHandle (hConsole
) == FALSE
)
71 SetLastError (ERROR_INVALID_PARAMETER
);
72 return INVALID_HANDLE_VALUE
;
75 Request
.Type
= CSRSS_DUPLICATE_HANDLE
;
76 Request
.Data
.DuplicateHandleRequest
.Handle
= hConsole
;
77 Request
.Data
.DuplicateHandleRequest
.ProcessId
= GetCurrentProcessId();
78 Status
= CsrClientCallServer(&Request
,
80 sizeof(CSRSS_API_REQUEST
),
81 sizeof(CSRSS_API_REPLY
));
82 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
=Reply
.Status
))
84 SetLastErrorByStatus(Status
);
85 return INVALID_HANDLE_VALUE
;
87 return Reply
.Data
.DuplicateHandleReply
.Handle
;
91 ExpungeConsoleCommandHistoryW (DWORD Unknown0
)
96 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
102 ExpungeConsoleCommandHistoryA (DWORD Unknown0
)
107 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
112 GetConsoleAliasW (DWORD Unknown0
,
120 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
126 GetConsoleAliasA (DWORD Unknown0
,
134 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
139 GetConsoleAliasExesW (DWORD Unknown0
,
145 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
152 GetConsoleAliasExesA (DWORD Unknown0
,
158 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
165 GetConsoleAliasExesLengthA (VOID
)
170 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
175 GetConsoleAliasExesLengthW (VOID
)
180 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
185 GetConsoleAliasesW (DWORD Unknown0
,
192 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
197 GetConsoleAliasesA (DWORD Unknown0
,
204 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
209 GetConsoleAliasesLengthW (DWORD Unknown0
)
214 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
219 GetConsoleAliasesLengthA (DWORD Unknown0
)
224 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
229 GetConsoleCommandHistoryW (DWORD Unknown0
,
236 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
241 GetConsoleCommandHistoryA (DWORD Unknown0
,
248 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
253 GetConsoleCommandHistoryLengthW (DWORD Unknown0
)
258 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
263 GetConsoleCommandHistoryLengthA (DWORD Unknown0
)
268 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
273 GetConsoleDisplayMode (LPDWORD lpdwMode
)
275 * FUNCTION: Get the console display mode
277 * lpdwMode - Address of variable that receives the current value
279 * STATUS: Undocumented
282 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
287 GetConsoleFontInfo (DWORD Unknown0
,
295 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
300 GetConsoleFontSize(HANDLE hConsoleOutput
,
303 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
308 GetConsoleHardwareState (DWORD Unknown0
,
315 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
320 GetConsoleInputWaitHandle (VOID
)
325 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
330 GetCurrentConsoleFont(HANDLE hConsoleOutput
,
332 PCONSOLE_FONT_INFO lpConsoleCurrentFont
)
334 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
339 GetNumberOfConsoleFonts (VOID
)
344 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
345 return 1; /* FIXME: call csrss.exe */
349 InvalidateConsoleDIBits (DWORD Unknown0
,
355 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
360 OpenConsoleW (DWORD Unknown0
,
368 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
373 SetConsoleCommandHistoryMode (DWORD dwMode
)
378 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
383 SetConsoleCursor (DWORD Unknown0
,
389 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
394 SetConsoleDisplayMode (HANDLE hOut
,
398 * FUNCTION: Set the console display mode.
400 * hOut - Standard output handle.
401 * dwNewMode - New mode.
402 * lpdwOldMode - Address of a variable that receives the old mode.
405 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
410 SetConsoleFont (DWORD Unknown0
,
416 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
421 SetConsoleHardwareState (DWORD Unknown0
,
428 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
433 SetConsoleKeyShortcuts (DWORD Unknown0
,
441 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
446 SetConsoleMaximumWindowSize (DWORD Unknown0
,
452 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
457 SetConsoleMenuClose (DWORD Unknown0
)
462 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
467 SetConsoleNumberOfCommandsA (DWORD Unknown0
,
473 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
478 SetConsoleNumberOfCommandsW (DWORD Unknown0
,
484 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
489 SetConsolePalette (DWORD Unknown0
,
496 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
501 SetLastConsoleEventActive (VOID
)
506 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
511 ShowConsoleCursor (DWORD Unknown0
,
517 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
523 * FUNCTION: Checks whether the given handle is a valid console handle.
525 * Handle - Handle to be checked
527 * TRUE: Handle is a valid console handle
528 * FALSE: Handle is not a valid console handle.
529 * STATUS: Officially undocumented
532 VerifyConsoleIoHandle(HANDLE Handle
)
534 CSRSS_API_REQUEST Request
;
535 CSRSS_API_REPLY Reply
;
538 Request
.Type
= CSRSS_VERIFY_HANDLE
;
539 Request
.Data
.VerifyHandleRequest
.Handle
= Handle
;
540 Status
= CsrClientCallServer(&Request
,
542 sizeof(CSRSS_API_REQUEST
),
543 sizeof(CSRSS_API_REPLY
));
544 if (!NT_SUCCESS(Status
))
546 SetLastErrorByStatus(Status
);
550 return (BOOL
)NT_SUCCESS(Reply
.Status
);
555 WriteConsoleInputVDMA (DWORD Unknown0
,
560 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
565 WriteConsoleInputVDMW (DWORD Unknown0
,
570 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
575 CloseConsoleHandle(HANDLE Handle
)
580 CSRSS_API_REQUEST Request
;
581 CSRSS_API_REPLY Reply
;
584 if (IsConsoleHandle (Handle
) == FALSE
)
586 SetLastError (ERROR_INVALID_PARAMETER
);
590 Request
.Type
= CSRSS_CLOSE_HANDLE
;
591 Request
.Data
.CloseHandleRequest
.Handle
= Handle
;
592 Status
= CsrClientCallServer(&Request
,
594 sizeof(CSRSS_API_REQUEST
),
595 sizeof(CSRSS_API_REPLY
));
596 if (!NT_SUCCESS(Status
))
598 SetLastErrorByStatus(Status
);
607 IsConsoleHandle(HANDLE Handle
)
609 if ((((ULONG
)Handle
) & 0x10000003) == 0x3)
617 GetStdHandle(DWORD nStdHandle
)
619 * FUNCTION: Get a handle for the standard input, standard output
620 * and a standard error device.
622 * nStdHandle - Specifies the device for which to return the handle.
623 * RETURNS: If the function succeeds, the return value is the handle
624 * of the specified device. Otherwise the value is INVALID_HANDLE_VALUE.
627 PRTL_USER_PROCESS_PARAMETERS Ppb
;
629 Ppb
= NtCurrentPeb()->ProcessParameters
;
632 case STD_INPUT_HANDLE
:
633 return Ppb
->hStdInput
;
635 case STD_OUTPUT_HANDLE
:
636 return Ppb
->hStdOutput
;
638 case STD_ERROR_HANDLE
:
639 return Ppb
->hStdError
;
642 SetLastError (ERROR_INVALID_PARAMETER
);
643 return INVALID_HANDLE_VALUE
;
646 WINBASEAPI BOOL WINAPI
647 SetStdHandle(DWORD nStdHandle
,
650 * FUNCTION: Set the handle for the standard input, standard output or
651 * the standard error device.
653 * nStdHandle - Specifies the handle to be set.
654 * hHandle - The handle to set.
655 * RETURNS: TRUE if the function succeeds, FALSE otherwise.
658 PRTL_USER_PROCESS_PARAMETERS Ppb
;
660 Ppb
= NtCurrentPeb()->ProcessParameters
;
662 /* More checking needed? */
663 if (hHandle
== INVALID_HANDLE_VALUE
)
665 SetLastError (ERROR_INVALID_HANDLE
);
669 SetLastError(ERROR_SUCCESS
); /* OK */
673 case STD_INPUT_HANDLE
:
674 Ppb
->hStdInput
= hHandle
;
677 case STD_OUTPUT_HANDLE
:
678 Ppb
->hStdOutput
= hHandle
;
681 case STD_ERROR_HANDLE
:
682 Ppb
->hStdError
= hHandle
;
686 SetLastError (ERROR_INVALID_PARAMETER
);
691 /*--------------------------------------------------------------
695 WriteConsoleA(HANDLE hConsoleOutput
,
696 CONST VOID
*lpBuffer
,
697 DWORD nNumberOfCharsToWrite
,
698 LPDWORD lpNumberOfCharsWritten
,
701 PCSRSS_API_REQUEST Request
;
702 CSRSS_API_REPLY Reply
;
707 Request
= RtlAllocateHeap(GetProcessHeap(),
709 sizeof(CSRSS_API_REQUEST
) +
710 CSRSS_MAX_WRITE_CONSOLE_REQUEST
);
713 SetLastError(ERROR_OUTOFMEMORY
);
717 Request
->Type
= CSRSS_WRITE_CONSOLE
;
718 Request
->Data
.WriteConsoleRequest
.ConsoleHandle
= hConsoleOutput
;
719 if (lpNumberOfCharsWritten
!= NULL
)
720 *lpNumberOfCharsWritten
= nNumberOfCharsToWrite
;
721 while (nNumberOfCharsToWrite
)
723 if (nNumberOfCharsToWrite
> CSRSS_MAX_WRITE_CONSOLE_REQUEST
)
725 Size
= CSRSS_MAX_WRITE_CONSOLE_REQUEST
;
729 Size
= nNumberOfCharsToWrite
;
731 Request
->Data
.WriteConsoleRequest
.NrCharactersToWrite
= Size
;
733 memcpy(Request
->Data
.WriteConsoleRequest
.Buffer
, lpBuffer
, Size
);
735 MessageSize
= CSRSS_REQUEST_HEADER_SIZE
+
736 sizeof(CSRSS_WRITE_CONSOLE_REQUEST
) + Size
;
737 Status
= CsrClientCallServer(Request
,
740 sizeof(CSRSS_API_REPLY
));
742 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
744 RtlFreeHeap(GetProcessHeap(), 0, Request
);
745 SetLastErrorByStatus(Status
);
748 nNumberOfCharsToWrite
-= Size
;
752 RtlFreeHeap(GetProcessHeap(), 0, Request
);
758 /*--------------------------------------------------------------
761 WINBOOL STDCALL
ReadConsoleA(HANDLE hConsoleInput
,
763 DWORD nNumberOfCharsToRead
,
764 LPDWORD lpNumberOfCharsRead
,
767 CSRSS_API_REQUEST Request
;
768 PCSRSS_API_REPLY Reply
;
772 Reply
= RtlAllocateHeap(GetProcessHeap(),
774 sizeof(CSRSS_API_REPLY
) + nNumberOfCharsToRead
);
777 SetLastError(ERROR_OUTOFMEMORY
);
781 Request
.Type
= CSRSS_READ_CONSOLE
;
782 Request
.Data
.ReadConsoleRequest
.ConsoleHandle
= hConsoleInput
;
783 Request
.Data
.ReadConsoleRequest
.NrCharactersToRead
= nNumberOfCharsToRead
> CSRSS_MAX_READ_CONSOLE_REQUEST
? CSRSS_MAX_READ_CONSOLE_REQUEST
: nNumberOfCharsToRead
;
784 Request
.Data
.ReadConsoleRequest
.nCharsCanBeDeleted
= 0;
785 Status
= CsrClientCallServer(&Request
,
787 sizeof(CSRSS_API_REQUEST
),
788 sizeof(CSRSS_API_REPLY
) +
789 Request
.Data
.ReadConsoleRequest
.NrCharactersToRead
);
790 if (!NT_SUCCESS(Status
) || !NT_SUCCESS( Status
= Reply
->Status
))
792 DbgPrint( "CSR returned error in ReadConsole\n" );
793 SetLastErrorByStatus ( Status
);
794 RtlFreeHeap( GetProcessHeap(), 0, Reply
);
797 if( Reply
->Status
== STATUS_NOTIFY_CLEANUP
)
798 Reply
->Status
= STATUS_PENDING
; // ignore backspace because we have no chars to backspace
799 /* There may not be any chars or lines to read yet, so wait */
800 while( Reply
->Status
== STATUS_PENDING
)
802 /* some chars may have been returned, but not a whole line yet, so recompute buffer and try again */
803 nNumberOfCharsToRead
-= Reply
->Data
.ReadConsoleReply
.NrCharactersRead
;
804 /* don't overflow caller's buffer, even if you still don't have a complete line */
805 if( !nNumberOfCharsToRead
)
807 Request
.Data
.ReadConsoleRequest
.NrCharactersToRead
= nNumberOfCharsToRead
> CSRSS_MAX_READ_CONSOLE_REQUEST
? CSRSS_MAX_READ_CONSOLE_REQUEST
: nNumberOfCharsToRead
;
808 /* copy any chars already read to buffer */
809 memcpy( lpBuffer
+ CharsRead
, Reply
->Data
.ReadConsoleReply
.Buffer
, Reply
->Data
.ReadConsoleReply
.NrCharactersRead
);
810 CharsRead
+= Reply
->Data
.ReadConsoleReply
.NrCharactersRead
;
811 /* wait for csrss to signal there is more data to read, but not if we got STATUS_NOTIFY_CLEANUP for backspace */
812 Status
= NtWaitForSingleObject( Reply
->Data
.ReadConsoleReply
.EventHandle
, FALSE
, 0 );
813 if( !NT_SUCCESS( Status
) )
815 DbgPrint( "Wait for console input failed!\n" );
816 RtlFreeHeap( GetProcessHeap(), 0, Reply
);
819 Request
.Data
.ReadConsoleRequest
.nCharsCanBeDeleted
= CharsRead
;
820 Status
= CsrClientCallServer( &Request
, Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) + Request
.Data
.ReadConsoleRequest
.NrCharactersToRead
);
821 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
->Status
) )
823 SetLastErrorByStatus ( Status
);
824 RtlFreeHeap( GetProcessHeap(), 0, Reply
);
827 if( Reply
->Status
== STATUS_NOTIFY_CLEANUP
)
833 nNumberOfCharsToRead
++;
835 Reply
->Status
= STATUS_PENDING
; // retry
838 /* copy data to buffer, count total returned, and return */
839 memcpy( lpBuffer
+ CharsRead
, Reply
->Data
.ReadConsoleReply
.Buffer
, Reply
->Data
.ReadConsoleReply
.NrCharactersRead
);
840 CharsRead
+= Reply
->Data
.ReadConsoleReply
.NrCharactersRead
;
841 if (lpNumberOfCharsRead
!= NULL
)
842 *lpNumberOfCharsRead
= CharsRead
;
843 RtlFreeHeap(GetProcessHeap(),
851 /*--------------------------------------------------------------
854 WINBOOL STDCALL
AllocConsole(VOID
)
856 CSRSS_API_REQUEST Request
;
857 CSRSS_API_REPLY Reply
;
861 Request
.Type
= CSRSS_ALLOC_CONSOLE
;
862 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
863 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
865 SetLastErrorByStatus ( Status
);
868 SetStdHandle( STD_INPUT_HANDLE
, Reply
.Data
.AllocConsoleReply
.InputHandle
);
869 SetStdHandle( STD_OUTPUT_HANDLE
, Reply
.Data
.AllocConsoleReply
.OutputHandle
);
870 hStdError
= DuplicateConsoleHandle(Reply
.Data
.AllocConsoleReply
.OutputHandle
,
873 DUPLICATE_SAME_ACCESS
);
874 SetStdHandle( STD_ERROR_HANDLE
, hStdError
);
879 /*--------------------------------------------------------------
882 WINBOOL STDCALL
FreeConsole(VOID
)
884 DbgPrint("FreeConsole() is unimplemented\n");
889 /*--------------------------------------------------------------
890 * GetConsoleScreenBufferInfo
894 GetConsoleScreenBufferInfo(
895 HANDLE hConsoleOutput
,
896 PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo
899 CSRSS_API_REQUEST Request
;
900 CSRSS_API_REPLY Reply
;
903 Request
.Type
= CSRSS_SCREEN_BUFFER_INFO
;
904 Request
.Data
.ScreenBufferInfoRequest
.ConsoleHandle
= hConsoleOutput
;
905 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
906 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
908 SetLastErrorByStatus ( Status
);
911 *lpConsoleScreenBufferInfo
= Reply
.Data
.ScreenBufferInfoReply
.Info
;
916 /*--------------------------------------------------------------
917 * SetConsoleCursorPosition
921 SetConsoleCursorPosition(
922 HANDLE hConsoleOutput
,
923 COORD dwCursorPosition
926 CSRSS_API_REQUEST Request
;
927 CSRSS_API_REPLY Reply
;
930 Request
.Type
= CSRSS_SET_CURSOR
;
931 Request
.Data
.SetCursorRequest
.ConsoleHandle
= hConsoleOutput
;
932 Request
.Data
.SetCursorRequest
.Position
= dwCursorPosition
;
933 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
934 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
936 SetLastErrorByStatus ( Status
);
943 /*--------------------------------------------------------------
944 * FillConsoleOutputCharacterA
947 FillConsoleOutputCharacterA(
948 HANDLE hConsoleOutput
,
952 LPDWORD lpNumberOfCharsWritten
955 CSRSS_API_REQUEST Request
;
956 CSRSS_API_REPLY Reply
;
959 Request
.Type
= CSRSS_FILL_OUTPUT
;
960 Request
.Data
.FillOutputRequest
.ConsoleHandle
= hConsoleOutput
;
961 Request
.Data
.FillOutputRequest
.Char
= cCharacter
;
962 Request
.Data
.FillOutputRequest
.Position
= dwWriteCoord
;
963 Request
.Data
.FillOutputRequest
.Length
= nLength
;
964 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
965 if ( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
967 SetLastErrorByStatus(Status
);
970 if (lpNumberOfCharsWritten
!= NULL
)
971 *lpNumberOfCharsWritten
= nLength
;
976 /*--------------------------------------------------------------
977 * FillConsoleOutputCharacterW
981 FillConsoleOutputCharacterW(
982 HANDLE hConsoleOutput
,
986 LPDWORD lpNumberOfCharsWritten
994 /*--------------------------------------------------------------
1001 HANDLE hConsoleInput
,
1002 PINPUT_RECORD lpBuffer
,
1004 LPDWORD lpNumberOfEventsRead
1007 PCSRSS_API_REQUEST Request
;
1008 CSRSS_API_REPLY Reply
;
1011 PVOID BufferTargetBase
;
1014 if(lpBuffer
== NULL
)
1016 SetLastError(ERROR_INVALID_PARAMETER
);
1020 Size
= nLength
* sizeof(INPUT_RECORD
);
1022 Status
= CsrCaptureParameterBuffer((PVOID
)lpBuffer
, Size
, &BufferBase
, &BufferTargetBase
);
1023 if(!NT_SUCCESS(Status
))
1025 SetLastErrorByStatus(Status
);
1029 Request
= RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(CSRSS_API_REQUEST
));
1032 CsrReleaseParameterBuffer(BufferBase
);
1033 SetLastError(ERROR_OUTOFMEMORY
);
1037 Request
->Type
= CSRSS_PEEK_CONSOLE_INPUT
;
1038 Request
->Data
.PeekConsoleInputRequest
.ConsoleHandle
= hConsoleInput
;
1039 Request
->Data
.PeekConsoleInputRequest
.Length
= nLength
;
1040 Request
->Data
.PeekConsoleInputRequest
.InputRecord
= (INPUT_RECORD
*)BufferTargetBase
;
1042 Status
= CsrClientCallServer(Request
, &Reply
, sizeof(CSRSS_API_REQUEST
), sizeof(CSRSS_API_REPLY
));
1044 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1046 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1047 CsrReleaseParameterBuffer(BufferBase
);
1051 memcpy(lpBuffer
, BufferBase
, sizeof(INPUT_RECORD
) * Reply
.Data
.PeekConsoleInputReply
.Length
);
1053 if(lpNumberOfEventsRead
!= NULL
)
1054 *lpNumberOfEventsRead
= Reply
.Data
.PeekConsoleInputReply
.Length
;
1056 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1057 CsrReleaseParameterBuffer(BufferBase
);
1063 /*--------------------------------------------------------------
1070 HANDLE hConsoleInput
,
1071 PINPUT_RECORD lpBuffer
,
1073 LPDWORD lpNumberOfEventsRead
1081 /*--------------------------------------------------------------
1084 WINBASEAPI BOOL WINAPI
1085 ReadConsoleInputA(HANDLE hConsoleInput
,
1086 PINPUT_RECORD lpBuffer
,
1088 LPDWORD lpNumberOfEventsRead
)
1090 CSRSS_API_REQUEST Request
;
1091 CSRSS_API_REPLY Reply
;
1092 DWORD NumEventsRead
;
1095 Request
.Type
= CSRSS_READ_INPUT
;
1096 Request
.Data
.ReadInputRequest
.ConsoleHandle
= hConsoleInput
;
1097 Status
= CsrClientCallServer(&Request
, &Reply
, sizeof(CSRSS_API_REQUEST
),
1098 sizeof(CSRSS_API_REPLY
));
1099 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1101 SetLastErrorByStatus(Status
);
1105 while (Status
== STATUS_PENDING
)
1107 Status
= NtWaitForSingleObject(Reply
.Data
.ReadInputReply
.Event
, FALSE
,
1109 if(!NT_SUCCESS(Status
))
1111 SetLastErrorByStatus(Status
);
1115 Request
.Type
= CSRSS_READ_INPUT
;
1116 Request
.Data
.ReadInputRequest
.ConsoleHandle
= hConsoleInput
;
1117 Status
= CsrClientCallServer(&Request
, &Reply
, sizeof(CSRSS_API_REQUEST
),
1118 sizeof(CSRSS_API_REPLY
));
1119 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1121 SetLastErrorByStatus(Status
);
1127 *lpBuffer
= Reply
.Data
.ReadInputReply
.Input
;
1131 while ((NumEventsRead
< nLength
) && (Reply
.Data
.ReadInputReply
.MoreEvents
))
1133 Status
= CsrClientCallServer(&Request
, &Reply
, sizeof(CSRSS_API_REQUEST
),
1134 sizeof(CSRSS_API_REPLY
));
1135 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1137 SetLastErrorByStatus(Status
);
1141 if (Status
== STATUS_PENDING
)
1146 *lpBuffer
= Reply
.Data
.ReadInputReply
.Input
;
1151 *lpNumberOfEventsRead
= NumEventsRead
;
1157 /*--------------------------------------------------------------
1164 HANDLE hConsoleInput
,
1165 PINPUT_RECORD lpBuffer
,
1167 LPDWORD lpNumberOfEventsRead
1175 /*--------------------------------------------------------------
1176 * WriteConsoleInputA
1182 HANDLE hConsoleInput
,
1183 CONST INPUT_RECORD
*lpBuffer
,
1185 LPDWORD lpNumberOfEventsWritten
1188 PCSRSS_API_REQUEST Request
;
1189 CSRSS_API_REPLY Reply
;
1190 PVOID BufferBase
, BufferTargetBase
;
1194 if(lpBuffer
== NULL
)
1196 SetLastError(ERROR_INVALID_PARAMETER
);
1200 Size
= nLength
* sizeof(INPUT_RECORD
);
1202 Status
= CsrCaptureParameterBuffer((PVOID
)lpBuffer
, Size
, &BufferBase
, &BufferTargetBase
);
1203 if(!NT_SUCCESS(Status
))
1205 SetLastErrorByStatus(Status
);
1209 Request
= RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(CSRSS_API_REQUEST
));
1212 SetLastError(ERROR_OUTOFMEMORY
);
1213 CsrReleaseParameterBuffer(BufferBase
);
1217 Request
->Type
= CSRSS_WRITE_CONSOLE_INPUT
;
1218 Request
->Data
.WriteConsoleInputRequest
.ConsoleHandle
= hConsoleInput
;
1219 Request
->Data
.WriteConsoleInputRequest
.Length
= nLength
;
1220 Request
->Data
.WriteConsoleInputRequest
.InputRecord
= (PINPUT_RECORD
)BufferTargetBase
;
1222 Status
= CsrClientCallServer(Request
, &Reply
, sizeof(CSRSS_API_REQUEST
), sizeof(CSRSS_API_REPLY
));
1223 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1225 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1226 CsrReleaseParameterBuffer(BufferBase
);
1230 if(lpNumberOfEventsWritten
!= NULL
)
1231 *lpNumberOfEventsWritten
= Reply
.Data
.WriteConsoleInputReply
.Length
;
1233 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1234 CsrReleaseParameterBuffer(BufferBase
);
1240 /*--------------------------------------------------------------
1241 * WriteConsoleInputW
1247 HANDLE hConsoleInput
,
1248 CONST INPUT_RECORD
*lpBuffer
,
1250 LPDWORD lpNumberOfEventsWritten
1258 /*--------------------------------------------------------------
1259 * ReadConsoleOutputA
1265 HANDLE hConsoleOutput
,
1266 PCHAR_INFO lpBuffer
,
1268 COORD dwBufferCoord
,
1269 PSMALL_RECT lpReadRegion
1272 PCSRSS_API_REQUEST Request
;
1273 CSRSS_API_REPLY Reply
;
1275 PVOID BufferTargetBase
;
1277 DWORD Size
, SizeX
, SizeY
;
1279 if(lpBuffer
== NULL
)
1281 SetLastError(ERROR_INVALID_PARAMETER
);
1285 Size
= dwBufferSize
.X
* dwBufferSize
.Y
* sizeof(CHAR_INFO
);
1287 Status
= CsrCaptureParameterBuffer((PVOID
)lpBuffer
, Size
, &BufferBase
, &BufferTargetBase
);
1288 if(!NT_SUCCESS(Status
))
1290 SetLastErrorByStatus(Status
);
1294 Request
= RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(CSRSS_API_REQUEST
));
1297 SetLastError(ERROR_OUTOFMEMORY
);
1298 CsrReleaseParameterBuffer(BufferBase
);
1302 Request
->Type
= CSRSS_READ_CONSOLE_OUTPUT
;
1303 Request
->Data
.ReadConsoleOutputRequest
.ConsoleHandle
= hConsoleOutput
;
1304 Request
->Data
.ReadConsoleOutputRequest
.BufferSize
= dwBufferSize
;
1305 Request
->Data
.ReadConsoleOutputRequest
.BufferCoord
= dwBufferCoord
;
1306 Request
->Data
.ReadConsoleOutputRequest
.ReadRegion
= *lpReadRegion
;
1307 Request
->Data
.ReadConsoleOutputRequest
.CharInfo
= (PCHAR_INFO
)BufferTargetBase
;
1309 Status
= CsrClientCallServer(Request
, &Reply
, sizeof(CSRSS_API_REQUEST
), sizeof(CSRSS_API_REPLY
));
1310 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1312 SetLastErrorByStatus(Status
);
1313 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1314 CsrReleaseParameterBuffer(BufferBase
);
1318 SizeX
= Reply
.Data
.ReadConsoleOutputReply
.ReadRegion
.Right
- Reply
.Data
.ReadConsoleOutputReply
.ReadRegion
.Left
+ 1;
1319 SizeY
= Reply
.Data
.ReadConsoleOutputReply
.ReadRegion
.Bottom
- Reply
.Data
.ReadConsoleOutputReply
.ReadRegion
.Top
+ 1;
1321 memcpy(lpBuffer
, BufferBase
, sizeof(CHAR_INFO
) * SizeX
* SizeY
);
1322 *lpReadRegion
= Reply
.Data
.ReadConsoleOutputReply
.ReadRegion
;
1324 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1325 CsrReleaseParameterBuffer(BufferBase
);
1331 /*--------------------------------------------------------------
1332 * ReadConsoleOutputW
1338 HANDLE hConsoleOutput
,
1339 PCHAR_INFO lpBuffer
,
1341 COORD dwBufferCoord
,
1342 PSMALL_RECT lpReadRegion
1349 /*--------------------------------------------------------------
1350 * WriteConsoleOutputA
1352 WINBASEAPI BOOL WINAPI
1353 WriteConsoleOutputA(HANDLE hConsoleOutput
,
1354 CONST CHAR_INFO
*lpBuffer
,
1356 COORD dwBufferCoord
,
1357 PSMALL_RECT lpWriteRegion
)
1359 PCSRSS_API_REQUEST Request
;
1360 CSRSS_API_REPLY Reply
;
1366 PVOID BufferTargetBase
;
1368 Size
= dwBufferSize
.Y
* dwBufferSize
.X
* sizeof(CHAR_INFO
);
1370 Status
= CsrCaptureParameterBuffer((PVOID
)lpBuffer
,
1374 if (!NT_SUCCESS(Status
))
1376 SetLastErrorByStatus(Status
);
1380 Request
= RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY
,
1381 sizeof(CSRSS_API_REQUEST
));
1382 if (Request
== NULL
)
1384 CsrReleaseParameterBuffer(BufferBase
);
1385 SetLastError(ERROR_OUTOFMEMORY
);
1388 Request
->Type
= CSRSS_WRITE_CONSOLE_OUTPUT
;
1389 Request
->Data
.WriteConsoleOutputRequest
.ConsoleHandle
= hConsoleOutput
;
1390 Request
->Data
.WriteConsoleOutputRequest
.BufferSize
= dwBufferSize
;
1391 Request
->Data
.WriteConsoleOutputRequest
.BufferCoord
= dwBufferCoord
;
1392 Request
->Data
.WriteConsoleOutputRequest
.WriteRegion
= *lpWriteRegion
;
1393 Request
->Data
.WriteConsoleOutputRequest
.CharInfo
=
1394 (CHAR_INFO
*)BufferTargetBase
;
1396 Status
= CsrClientCallServer(Request
, &Reply
,
1397 sizeof(CSRSS_API_REQUEST
),
1398 sizeof(CSRSS_API_REPLY
));
1399 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1401 CsrReleaseParameterBuffer(BufferBase
);
1402 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1403 SetLastErrorByStatus(Status
);
1407 *lpWriteRegion
= Reply
.Data
.WriteConsoleOutputReply
.WriteRegion
;
1408 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1409 CsrReleaseParameterBuffer(BufferBase
);
1414 /*--------------------------------------------------------------
1415 * WriteConsoleOutputW
1420 WriteConsoleOutputW(
1421 HANDLE hConsoleOutput
,
1422 CONST CHAR_INFO
*lpBuffer
,
1424 COORD dwBufferCoord
,
1425 PSMALL_RECT lpWriteRegion
1433 /*--------------------------------------------------------------
1434 * ReadConsoleOutputCharacterA
1439 ReadConsoleOutputCharacterA(
1440 HANDLE hConsoleOutput
,
1444 LPDWORD lpNumberOfCharsRead
1447 CSRSS_API_REQUEST Request
;
1448 PCSRSS_API_REPLY Reply
;
1452 Reply
= RtlAllocateHeap(GetProcessHeap(),
1454 sizeof(CSRSS_API_REPLY
) + CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR
);
1457 SetLastError(ERROR_OUTOFMEMORY
);
1461 if (lpNumberOfCharsRead
!= NULL
)
1462 *lpNumberOfCharsRead
= nLength
;
1464 Request
.Type
= CSRSS_READ_CONSOLE_OUTPUT_CHAR
;
1465 Request
.Data
.ReadConsoleOutputCharRequest
.ConsoleHandle
= hConsoleOutput
;
1466 Request
.Data
.ReadConsoleOutputCharRequest
.ReadCoord
= dwReadCoord
;
1468 while (nLength
!= 0)
1470 if (nLength
> CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR
)
1471 Size
= CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR
;
1475 Request
.Data
.ReadConsoleOutputCharRequest
.NumCharsToRead
= Size
;
1477 Status
= CsrClientCallServer(&Request
,
1479 sizeof(CSRSS_API_REQUEST
),
1480 sizeof(CSRSS_API_REPLY
) + Size
);
1481 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Reply
->Status
))
1483 RtlFreeHeap(GetProcessHeap(), 0, Reply
);
1484 SetLastErrorByStatus(Status
);
1488 memcpy(lpCharacter
, &Reply
->Data
.ReadConsoleOutputCharReply
.String
[0], Size
);
1489 lpCharacter
+= Size
;
1491 Request
.Data
.ReadConsoleOutputCharRequest
.ReadCoord
= Reply
->Data
.ReadConsoleOutputCharReply
.EndCoord
;
1494 RtlFreeHeap(GetProcessHeap(), 0, Reply
);
1500 /*--------------------------------------------------------------
1501 * ReadConsoleOutputCharacterW
1506 ReadConsoleOutputCharacterW(
1507 HANDLE hConsoleOutput
,
1511 LPDWORD lpNumberOfCharsRead
1519 /*--------------------------------------------------------------
1520 * ReadConsoleOutputAttribute
1525 ReadConsoleOutputAttribute(
1526 HANDLE hConsoleOutput
,
1530 LPDWORD lpNumberOfAttrsRead
1533 CSRSS_API_REQUEST Request
;
1534 PCSRSS_API_REPLY Reply
;
1538 Reply
= RtlAllocateHeap(GetProcessHeap(),
1540 sizeof(CSRSS_API_REPLY
) + CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB
);
1543 SetLastError(ERROR_OUTOFMEMORY
);
1547 if (lpNumberOfAttrsRead
!= NULL
)
1548 *lpNumberOfAttrsRead
= nLength
;
1550 Request
.Type
= CSRSS_READ_CONSOLE_OUTPUT_ATTRIB
;
1551 Request
.Data
.ReadConsoleOutputAttribRequest
.ConsoleHandle
= hConsoleOutput
;
1552 Request
.Data
.ReadConsoleOutputAttribRequest
.ReadCoord
= dwReadCoord
;
1554 while (nLength
!= 0)
1556 if (nLength
> CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB
)
1557 Size
= CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB
;
1561 Request
.Data
.ReadConsoleOutputAttribRequest
.NumAttrsToRead
= Size
;
1563 Status
= CsrClientCallServer(&Request
,
1565 sizeof(CSRSS_API_REQUEST
),
1566 sizeof(CSRSS_API_REPLY
) + Size
);
1567 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Reply
->Status
))
1569 RtlFreeHeap(GetProcessHeap(), 0, Reply
);
1570 SetLastErrorByStatus(Status
);
1574 // Convert CHARs to WORDs
1575 for(i
= 0; i
< Size
; ++i
)
1576 *lpAttribute
++ = Reply
->Data
.ReadConsoleOutputAttribReply
.String
[i
];
1579 Request
.Data
.ReadConsoleOutputAttribRequest
.ReadCoord
= Reply
->Data
.ReadConsoleOutputAttribReply
.EndCoord
;
1582 RtlFreeHeap(GetProcessHeap(), 0, Reply
);
1588 /*--------------------------------------------------------------
1589 * WriteConsoleOutputCharacterA
1591 WINBASEAPI BOOL WINAPI
1592 WriteConsoleOutputCharacterA(HANDLE hConsoleOutput
,
1596 LPDWORD lpNumberOfCharsWritten
)
1598 PCSRSS_API_REQUEST Request
;
1599 CSRSS_API_REPLY Reply
;
1603 Request
= RtlAllocateHeap(GetProcessHeap(),
1605 sizeof(CSRSS_API_REQUEST
) + CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR
);
1608 SetLastError( ERROR_OUTOFMEMORY
);
1611 Request
->Type
= CSRSS_WRITE_CONSOLE_OUTPUT_CHAR
;
1612 Request
->Data
.WriteConsoleOutputCharRequest
.ConsoleHandle
= hConsoleOutput
;
1613 Request
->Data
.WriteConsoleOutputCharRequest
.Coord
= dwWriteCoord
;
1614 if( lpNumberOfCharsWritten
)
1615 *lpNumberOfCharsWritten
= nLength
;
1618 Size
= nLength
> CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR
? CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR
: nLength
;
1619 Request
->Data
.WriteConsoleOutputCharRequest
.Length
= Size
;
1620 memcpy( &Request
->Data
.WriteConsoleOutputCharRequest
.String
[0],
1623 Status
= CsrClientCallServer( Request
, &Reply
, sizeof( CSRSS_API_REQUEST
) + Size
, sizeof( CSRSS_API_REPLY
) );
1624 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1626 RtlFreeHeap( GetProcessHeap(), 0, Request
);
1627 SetLastErrorByStatus ( Status
);
1631 lpCharacter
+= Size
;
1632 Request
->Data
.WriteConsoleOutputCharRequest
.Coord
= Reply
.Data
.WriteConsoleOutputCharReply
.EndCoord
;
1635 RtlFreeHeap( GetProcessHeap(), 0, Request
);
1640 /*--------------------------------------------------------------
1641 * WriteConsoleOutputCharacterW
1646 WriteConsoleOutputCharacterW(
1647 HANDLE hConsoleOutput
,
1648 LPCWSTR lpCharacter
,
1651 LPDWORD lpNumberOfCharsWritten
1660 /*--------------------------------------------------------------
1661 * WriteConsoleOutputAttribute
1666 WriteConsoleOutputAttribute(
1667 HANDLE hConsoleOutput
,
1668 CONST WORD
*lpAttribute
,
1671 LPDWORD lpNumberOfAttrsWritten
1674 PCSRSS_API_REQUEST Request
;
1675 CSRSS_API_REPLY Reply
;
1680 Request
= RtlAllocateHeap(GetProcessHeap(),
1682 sizeof(CSRSS_API_REQUEST
) + CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB
);
1685 SetLastError( ERROR_OUTOFMEMORY
);
1688 Request
->Type
= CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB
;
1689 Request
->Data
.WriteConsoleOutputAttribRequest
.ConsoleHandle
= hConsoleOutput
;
1690 Request
->Data
.WriteConsoleOutputAttribRequest
.Coord
= dwWriteCoord
;
1691 if( lpNumberOfAttrsWritten
)
1692 *lpNumberOfAttrsWritten
= nLength
;
1695 Size
= nLength
> CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB
? CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB
: nLength
;
1696 Request
->Data
.WriteConsoleOutputAttribRequest
.Length
= Size
;
1697 for( c
= 0; c
< ( Size
* 2 ); c
++ )
1698 Request
->Data
.WriteConsoleOutputAttribRequest
.String
[c
] = (char)lpAttribute
[c
];
1699 Status
= CsrClientCallServer( Request
, &Reply
, sizeof( CSRSS_API_REQUEST
) + (Size
* 2), sizeof( CSRSS_API_REPLY
) );
1700 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1702 RtlFreeHeap( GetProcessHeap(), 0, Request
);
1703 SetLastErrorByStatus ( Status
);
1707 lpAttribute
+= Size
;
1708 Request
->Data
.WriteConsoleOutputAttribRequest
.Coord
= Reply
.Data
.WriteConsoleOutputAttribReply
.EndCoord
;
1711 RtlFreeHeap( GetProcessHeap(), 0, Request
);
1716 /*--------------------------------------------------------------
1717 * FillConsoleOutputAttribute
1722 FillConsoleOutputAttribute(
1723 HANDLE hConsoleOutput
,
1727 LPDWORD lpNumberOfAttrsWritten
1730 CSRSS_API_REQUEST Request
;
1731 CSRSS_API_REPLY Reply
;
1734 Request
.Type
= CSRSS_FILL_OUTPUT_ATTRIB
;
1735 Request
.Data
.FillOutputAttribRequest
.ConsoleHandle
= hConsoleOutput
;
1736 Request
.Data
.FillOutputAttribRequest
.Attribute
= wAttribute
;
1737 Request
.Data
.FillOutputAttribRequest
.Coord
= dwWriteCoord
;
1738 Request
.Data
.FillOutputAttribRequest
.Length
= nLength
;
1739 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
1740 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1742 SetLastErrorByStatus ( Status
);
1745 if( lpNumberOfAttrsWritten
)
1746 *lpNumberOfAttrsWritten
= nLength
;
1751 /*--------------------------------------------------------------
1758 HANDLE hConsoleHandle
,
1762 CSRSS_API_REQUEST Request
;
1763 CSRSS_API_REPLY Reply
;
1766 Request
.Type
= CSRSS_GET_MODE
;
1767 Request
.Data
.GetConsoleModeRequest
.ConsoleHandle
= hConsoleHandle
;
1768 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
1769 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1771 SetLastErrorByStatus ( Status
);
1774 *lpMode
= Reply
.Data
.GetConsoleModeReply
.ConsoleMode
;
1779 /*--------------------------------------------------------------
1780 * GetNumberOfConsoleInputEvents
1785 GetNumberOfConsoleInputEvents(
1786 HANDLE hConsoleInput
,
1787 LPDWORD lpNumberOfEvents
1790 CSRSS_API_REQUEST Request
;
1791 CSRSS_API_REPLY Reply
;
1794 if(lpNumberOfEvents
== NULL
)
1796 SetLastError(ERROR_INVALID_PARAMETER
);
1800 Request
.Type
= CSRSS_GET_NUM_INPUT_EVENTS
;
1801 Request
.Data
.GetNumInputEventsRequest
.ConsoleHandle
= hConsoleInput
;
1802 Status
= CsrClientCallServer(&Request
, &Reply
, sizeof(CSRSS_API_REQUEST
), sizeof(CSRSS_API_REPLY
));
1803 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1805 SetLastErrorByStatus(Status
);
1809 *lpNumberOfEvents
= Reply
.Data
.GetNumInputEventsReply
.NumInputEvents
;
1815 /*--------------------------------------------------------------
1816 * GetLargestConsoleWindowSize
1821 GetLargestConsoleWindowSize(
1822 HANDLE hConsoleOutput
1826 COORD Coord
= {80,25};
1834 /*--------------------------------------------------------------
1835 * GetConsoleCursorInfo
1840 GetConsoleCursorInfo(
1841 HANDLE hConsoleOutput
,
1842 PCONSOLE_CURSOR_INFO lpConsoleCursorInfo
1845 CSRSS_API_REQUEST Request
;
1846 CSRSS_API_REPLY Reply
;
1849 Request
.Type
= CSRSS_GET_CURSOR_INFO
;
1850 Request
.Data
.GetCursorInfoRequest
.ConsoleHandle
= hConsoleOutput
;
1851 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
1853 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1855 SetLastErrorByStatus ( Status
);
1858 *lpConsoleCursorInfo
= Reply
.Data
.GetCursorInfoReply
.Info
;
1863 /*--------------------------------------------------------------
1864 * GetNumberOfConsoleMouseButtons
1869 GetNumberOfConsoleMouseButtons(
1870 LPDWORD lpNumberOfMouseButtons
1878 /*--------------------------------------------------------------
1885 HANDLE hConsoleHandle
,
1889 CSRSS_API_REQUEST Request
;
1890 CSRSS_API_REPLY Reply
;
1893 Request
.Type
= CSRSS_SET_MODE
;
1894 Request
.Data
.SetConsoleModeRequest
.ConsoleHandle
= hConsoleHandle
;
1895 Request
.Data
.SetConsoleModeRequest
.Mode
= dwMode
;
1896 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
1897 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1899 SetLastErrorByStatus ( Status
);
1906 /*--------------------------------------------------------------
1907 * SetConsoleActiveScreenBuffer
1912 SetConsoleActiveScreenBuffer(
1913 HANDLE hConsoleOutput
1916 CSRSS_API_REQUEST Request
;
1917 CSRSS_API_REPLY Reply
;
1920 Request
.Type
= CSRSS_SET_SCREEN_BUFFER
;
1921 Request
.Data
.SetActiveScreenBufferRequest
.OutputHandle
= hConsoleOutput
;
1922 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
1923 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1925 SetLastErrorByStatus ( Status
);
1932 /*--------------------------------------------------------------
1933 * FlushConsoleInputBuffer
1938 FlushConsoleInputBuffer(
1939 HANDLE hConsoleInput
1942 CSRSS_API_REQUEST Request
;
1943 CSRSS_API_REPLY Reply
;
1946 Request
.Type
= CSRSS_FLUSH_INPUT_BUFFER
;
1947 Request
.Data
.FlushInputBufferRequest
.ConsoleInput
= hConsoleInput
;
1948 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
1949 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1951 SetLastErrorByStatus ( Status
);
1958 /*--------------------------------------------------------------
1959 * SetConsoleScreenBufferSize
1964 SetConsoleScreenBufferSize(
1965 HANDLE hConsoleOutput
,
1973 /*--------------------------------------------------------------
1974 * SetConsoleCursorInfo
1979 SetConsoleCursorInfo(
1980 HANDLE hConsoleOutput
,
1981 CONST CONSOLE_CURSOR_INFO
*lpConsoleCursorInfo
1984 CSRSS_API_REQUEST Request
;
1985 CSRSS_API_REPLY Reply
;
1988 Request
.Type
= CSRSS_SET_CURSOR_INFO
;
1989 Request
.Data
.SetCursorInfoRequest
.ConsoleHandle
= hConsoleOutput
;
1990 Request
.Data
.SetCursorInfoRequest
.Info
= *lpConsoleCursorInfo
;
1991 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
1993 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1995 SetLastErrorByStatus ( Status
);
2002 /*--------------------------------------------------------------
2003 * ScrollConsoleScreenBufferA
2008 ScrollConsoleScreenBufferA(
2009 HANDLE hConsoleOutput
,
2010 CONST SMALL_RECT
*lpScrollRectangle
,
2011 CONST SMALL_RECT
*lpClipRectangle
,
2012 COORD dwDestinationOrigin
,
2013 CONST CHAR_INFO
*lpFill
2016 CSRSS_API_REQUEST Request
;
2017 CSRSS_API_REPLY Reply
;
2020 Request
.Type
= CSRSS_SCROLL_CONSOLE_SCREEN_BUFFER
;
2021 Request
.Data
.ScrollConsoleScreenBufferRequest
.ConsoleHandle
= hConsoleOutput
;
2022 Request
.Data
.ScrollConsoleScreenBufferRequest
.ScrollRectangle
= *lpScrollRectangle
;
2024 if (lpClipRectangle
!= NULL
)
2026 Request
.Data
.ScrollConsoleScreenBufferRequest
.UseClipRectangle
= TRUE
;
2027 Request
.Data
.ScrollConsoleScreenBufferRequest
.ClipRectangle
= *lpClipRectangle
;
2031 Request
.Data
.ScrollConsoleScreenBufferRequest
.UseClipRectangle
= FALSE
;
2034 Request
.Data
.ScrollConsoleScreenBufferRequest
.DestinationOrigin
= dwDestinationOrigin
;
2035 Request
.Data
.ScrollConsoleScreenBufferRequest
.Fill
= *lpFill
;
2036 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
2038 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2040 SetLastErrorByStatus ( Status
);
2047 /*--------------------------------------------------------------
2048 * ScrollConsoleScreenBufferW
2053 ScrollConsoleScreenBufferW(
2054 HANDLE hConsoleOutput
,
2055 CONST SMALL_RECT
*lpScrollRectangle
,
2056 CONST SMALL_RECT
*lpClipRectangle
,
2057 COORD dwDestinationOrigin
,
2058 CONST CHAR_INFO
*lpFill
2066 /*--------------------------------------------------------------
2067 * SetConsoleWindowInfo
2072 SetConsoleWindowInfo(
2073 HANDLE hConsoleOutput
,
2075 CONST SMALL_RECT
*lpConsoleWindow
2083 /*--------------------------------------------------------------
2084 * SetConsoleTextAttribute
2089 SetConsoleTextAttribute(
2090 HANDLE hConsoleOutput
,
2094 CSRSS_API_REQUEST Request
;
2095 CSRSS_API_REPLY Reply
;
2098 Request
.Type
= CSRSS_SET_ATTRIB
;
2099 Request
.Data
.SetAttribRequest
.ConsoleHandle
= hConsoleOutput
;
2100 Request
.Data
.SetAttribRequest
.Attrib
= wAttributes
;
2101 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
2102 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2104 SetLastErrorByStatus ( Status
);
2111 AddConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine
)
2113 if (HandlerRoutine
== NULL
)
2115 IgnoreCtrlEvents
= TRUE
;
2122 RtlReAllocateHeap(RtlGetProcessHeap(),
2124 (PVOID
)CtrlHandlers
,
2125 NrCtrlHandlers
* sizeof(PHANDLER_ROUTINE
));
2126 if (CtrlHandlers
== NULL
)
2128 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2131 CtrlHandlers
[NrCtrlHandlers
- 1] = HandlerRoutine
;
2137 RemoveConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine
)
2141 if (HandlerRoutine
== NULL
)
2143 IgnoreCtrlEvents
= FALSE
;
2148 for (i
= 0; i
< NrCtrlHandlers
; i
++)
2150 if (CtrlHandlers
[i
] == HandlerRoutine
)
2152 CtrlHandlers
[i
] = CtrlHandlers
[NrCtrlHandlers
- 1];
2155 RtlReAllocateHeap(RtlGetProcessHeap(),
2157 (PVOID
)CtrlHandlers
,
2158 NrCtrlHandlers
* sizeof(PHANDLER_ROUTINE
));
2166 WINBASEAPI BOOL WINAPI
2167 SetConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine
,
2172 RtlEnterCriticalSection(&DllLock
);
2175 Ret
= AddConsoleCtrlHandler(HandlerRoutine
);
2179 Ret
= RemoveConsoleCtrlHandler(HandlerRoutine
);
2181 RtlLeaveCriticalSection(&DllLock
);
2186 /*--------------------------------------------------------------
2187 * GenerateConsoleCtrlEvent
2189 WINBASEAPI BOOL WINAPI
2190 GenerateConsoleCtrlEvent(
2192 DWORD dwProcessGroupId
2200 /*--------------------------------------------------------------
2208 LPWSTR lpConsoleTitle
,
2212 CSRSS_API_REQUEST Request
;
2213 PCSRSS_API_REPLY Reply
;
2217 hConsole
= CreateFileW(L
"CONIN$", GENERIC_READ
, 0, NULL
, OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
2218 if (hConsole
== INVALID_HANDLE_VALUE
)
2223 Reply
= RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(CSRSS_API_REPLY
) + CSRSS_MAX_TITLE_LENGTH
* sizeof(WCHAR
));
2226 CloseHandle(hConsole
);
2227 SetLastError(ERROR_OUTOFMEMORY
);
2231 Request
.Type
= CSRSS_GET_TITLE
;
2232 Request
.Data
.GetTitleRequest
.ConsoleHandle
= hConsole
;
2234 Status
= CsrClientCallServer(&Request
, Reply
, sizeof(CSRSS_API_REQUEST
), sizeof(CSRSS_API_REPLY
) + CSRSS_MAX_TITLE_LENGTH
* sizeof(WCHAR
));
2235 CloseHandle(hConsole
);
2236 if(!NT_SUCCESS(Status
) || !(NT_SUCCESS(Status
= Reply
->Status
)))
2238 SetLastErrorByStatus(Status
);
2239 RtlFreeHeap(GetProcessHeap(), 0, Reply
);
2243 if(nSize
* sizeof(WCHAR
) < Reply
->Data
.GetTitleReply
.Length
)
2245 wcsncpy(lpConsoleTitle
, Reply
->Data
.GetTitleReply
.Title
, nSize
- 1);
2246 lpConsoleTitle
[nSize
--] = L
'\0';
2250 nSize
= Reply
->Data
.GetTitleReply
.Length
/ sizeof (WCHAR
);
2251 wcscpy(lpConsoleTitle
, Reply
->Data
.GetTitleReply
.Title
);
2252 lpConsoleTitle
[nSize
] = L
'\0';
2255 RtlFreeHeap(GetProcessHeap(), 0, Reply
);
2260 /*--------------------------------------------------------------
2269 LPSTR lpConsoleTitle
,
2273 wchar_t WideTitle
[CSRSS_MAX_TITLE_LENGTH
];
2274 DWORD nWideTitle
= sizeof WideTitle
;
2277 if (!lpConsoleTitle
|| !nSize
) return 0;
2278 nWideTitle
= GetConsoleTitleW( (LPWSTR
) WideTitle
, nWideTitle
);
2279 if (!nWideTitle
) return 0;
2281 if ( (nWritten
= WideCharToMultiByte(
2282 CP_ACP
, // ANSI code page
2283 0, // performance and mapping flags
2284 (LPWSTR
) WideTitle
, // address of wide-character string
2285 nWideTitle
, // number of characters in string
2286 lpConsoleTitle
, // address of buffer for new string
2287 nSize
, // size of buffer
2292 lpConsoleTitle
[nWritten
] = '\0';
2300 /*--------------------------------------------------------------
2307 LPCWSTR lpConsoleTitle
2310 PCSRSS_API_REQUEST Request
;
2311 CSRSS_API_REPLY Reply
;
2316 hConsole
= CreateFileW(L
"CONIN$", GENERIC_WRITE
, 0, NULL
, OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
2317 if (hConsole
== INVALID_HANDLE_VALUE
)
2322 Request
= RtlAllocateHeap(GetProcessHeap(),
2324 sizeof(CSRSS_API_REQUEST
) + CSRSS_MAX_SET_TITLE_REQUEST
);
2325 if (Request
== NULL
)
2327 CloseHandle(hConsole
);
2328 SetLastError(ERROR_OUTOFMEMORY
);
2332 Request
->Type
= CSRSS_SET_TITLE
;
2333 Request
->Data
.SetTitleRequest
.Console
= hConsole
;
2335 for( c
= 0; lpConsoleTitle
[c
] && c
< CSRSS_MAX_TITLE_LENGTH
; c
++ )
2336 Request
->Data
.SetTitleRequest
.Title
[c
] = lpConsoleTitle
[c
];
2338 Request
->Data
.SetTitleRequest
.Title
[c
] = 0;
2339 Request
->Data
.SetTitleRequest
.Length
= c
;
2340 Status
= CsrClientCallServer(Request
,
2342 sizeof(CSRSS_API_REQUEST
) +
2344 sizeof(CSRSS_API_REPLY
));
2345 CloseHandle(hConsole
);
2346 if (!NT_SUCCESS(Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2348 RtlFreeHeap( GetProcessHeap(), 0, Request
);
2349 SetLastErrorByStatus (Status
);
2352 RtlFreeHeap( GetProcessHeap(), 0, Request
);
2357 /*--------------------------------------------------------------
2366 LPCSTR lpConsoleTitle
2369 PCSRSS_API_REQUEST Request
;
2370 CSRSS_API_REPLY Reply
;
2375 hConsole
= CreateFileW(L
"CONIN$", GENERIC_WRITE
, 0, NULL
, OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
2376 if (hConsole
== INVALID_HANDLE_VALUE
)
2381 Request
= RtlAllocateHeap(GetProcessHeap(),
2383 sizeof(CSRSS_API_REQUEST
) + CSRSS_MAX_SET_TITLE_REQUEST
);
2384 if (Request
== NULL
)
2386 CloseHandle(hConsole
);
2387 SetLastError(ERROR_OUTOFMEMORY
);
2391 Request
->Type
= CSRSS_SET_TITLE
;
2392 Request
->Data
.SetTitleRequest
.Console
= hConsole
;
2394 for( c
= 0; lpConsoleTitle
[c
] && c
< CSRSS_MAX_TITLE_LENGTH
; c
++ )
2395 Request
->Data
.SetTitleRequest
.Title
[c
] = lpConsoleTitle
[c
];
2397 Request
->Data
.SetTitleRequest
.Title
[c
] = 0;
2398 Request
->Data
.SetTitleRequest
.Length
= c
;
2399 Status
= CsrClientCallServer(Request
,
2401 sizeof(CSRSS_API_REQUEST
) +
2403 sizeof(CSRSS_API_REPLY
));
2404 CloseHandle(hConsole
);
2405 if (!NT_SUCCESS(Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2407 RtlFreeHeap( GetProcessHeap(), 0, Request
);
2408 SetLastErrorByStatus (Status
);
2411 RtlFreeHeap( GetProcessHeap(), 0, Request
);
2416 /*--------------------------------------------------------------
2423 HANDLE hConsoleInput
,
2425 DWORD nNumberOfCharsToRead
,
2426 LPDWORD lpNumberOfCharsRead
,
2435 /*--------------------------------------------------------------
2442 HANDLE hConsoleOutput
,
2443 CONST VOID
*lpBuffer
,
2444 DWORD nNumberOfCharsToWrite
,
2445 LPDWORD lpNumberOfCharsWritten
,
2450 PCSRSS_API_REQUEST Request
;
2451 CSRSS_API_REPLY Reply
;
2454 Request
= RtlAllocateHeap(GetProcessHeap(),
2456 sizeof(CSRSS_API_REQUEST
) + nNumberOfCharsToWrite
* sizeof(WCHAR
));
2457 if (Request
== NULL
)
2459 SetLastError(ERROR_OUTOFMEMORY
);
2463 Request
->Type
= CSRSS_WRITE_CONSOLE
;
2464 Request
->Data
.WriteConsoleRequest
.ConsoleHandle
= hConsoleOutput
;
2465 Request
->Data
.WriteConsoleRequest
.NrCharactersToWrite
=
2466 nNumberOfCharsToWrite
;
2467 // DbgPrint("nNumberOfCharsToWrite %d\n", nNumberOfCharsToWrite);
2468 // DbgPrint("Buffer %s\n", Request->Data.WriteConsoleRequest.Buffer);
2469 memcpy(Request
->Data
.WriteConsoleRequest
.Buffer
,
2471 nNumberOfCharsToWrite
* sizeof(WCHAR
));
2473 Status
= CsrClientCallServer(Request
,
2475 sizeof(CSRSS_API_REQUEST
) + nNumberOfCharsToWrite
,
2476 sizeof(CSRSS_API_REPLY
));
2478 RtlFreeHeap(GetProcessHeap(),
2482 if (!NT_SUCCESS(Status
))
2487 if (lpNumberOfCharsWritten
!= NULL
)
2489 *lpNumberOfCharsWritten
=
2490 Reply
.Data
.WriteConsoleReply
.NrCharactersWritten
;
2499 /*--------------------------------------------------------------
2500 * CreateConsoleScreenBuffer
2505 CreateConsoleScreenBuffer(
2506 DWORD dwDesiredAccess
,
2508 CONST SECURITY_ATTRIBUTES
*lpSecurityAttributes
,
2510 LPVOID lpScreenBufferData
2513 // FIXME: don't ignore access, share mode, and security
2514 CSRSS_API_REQUEST Request
;
2515 CSRSS_API_REPLY Reply
;
2518 Request
.Type
= CSRSS_CREATE_SCREEN_BUFFER
;
2519 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
2520 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2522 SetLastErrorByStatus ( Status
);
2525 return Reply
.Data
.CreateScreenBufferReply
.OutputHandle
;
2529 /*--------------------------------------------------------------
2535 GetConsoleCP( VOID
)
2538 return CP_OEMCP
; /* FIXME */
2542 /*--------------------------------------------------------------
2557 /*--------------------------------------------------------------
2558 * GetConsoleOutputCP
2563 GetConsoleOutputCP( VOID
)
2566 return 0; /* FIXME */
2570 /*--------------------------------------------------------------
2571 * SetConsoleOutputCP
2585 /*--------------------------------------------------------------
2586 * GetConsoleProcessList
2589 GetConsoleProcessList(LPDWORD lpdwProcessList
,
2590 DWORD dwProcessCount
)
2592 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2598 /*--------------------------------------------------------------
2599 * GetConsoleSelectionInfo
2602 GetConsoleSelectionInfo(PCONSOLE_SELECTION_INFO lpConsoleSelectionInfo
)
2604 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2610 /*--------------------------------------------------------------
2614 AttachConsole(DWORD dwProcessId
)
2616 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);