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
7 * PROGRAMMER: James Tabor
8 * <jimtabor@adsl-64-217-116-74.dsl.hstntx.swbell.net>
11 * 19990204 EA SetConsoleTitleA
15 /* INCLUDES ******************************************************************/
20 #include "../include/debug.h"
22 extern BOOL WINAPI
DefaultConsoleCtrlHandler(DWORD Event
);
23 extern __declspec(noreturn
) VOID CALLBACK
ConsoleControlDispatcher(DWORD CodeAndFlag
);
24 extern RTL_CRITICAL_SECTION ConsoleLock
;
25 extern BOOL WINAPI
IsDebuggerPresent(VOID
);
28 /* GLOBALS *******************************************************************/
30 static BOOL IgnoreCtrlEvents
= FALSE
;
32 static PHANDLER_ROUTINE
* CtrlHandlers
= NULL
;
33 static ULONG NrCtrlHandlers
= 0;
34 static WCHAR InputExeName
[MAX_PATH
+ 1] = L
"";
36 /* Default Console Control Handler *******************************************/
38 BOOL WINAPI
DefaultConsoleCtrlHandler(DWORD Event
)
43 DPRINT("Ctrl-C Event\n");
46 case CTRL_BREAK_EVENT
:
47 DPRINT("Ctrl-Break Event\n");
50 case CTRL_SHUTDOWN_EVENT
:
51 DPRINT("Ctrl Shutdown Event\n");
54 case CTRL_CLOSE_EVENT
:
55 DPRINT("Ctrl Close Event\n");
58 case CTRL_LOGOFF_EVENT
:
59 DPRINT("Ctrl Logoff Event\n");
67 __declspec(noreturn
) VOID CALLBACK
ConsoleControlDispatcher(DWORD CodeAndFlag
)
70 DWORD nCode
= CodeAndFlag
& MAXLONG
;
73 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST
);
78 case CTRL_BREAK_EVENT
:
80 if(IsDebuggerPresent())
82 EXCEPTION_RECORD erException
;
83 erException
.ExceptionCode
=
84 (nCode
== CTRL_C_EVENT
? DBG_CONTROL_C
: DBG_CONTROL_BREAK
);
85 erException
.ExceptionFlags
= 0;
86 erException
.ExceptionRecord
= NULL
;
87 erException
.ExceptionAddress
= &DefaultConsoleCtrlHandler
;
88 erException
.NumberParameters
= 0;
89 RtlRaiseException(&erException
);
91 RtlEnterCriticalSection(&ConsoleLock
);
93 if(!(nCode
== CTRL_C_EVENT
&&
94 NtCurrentPeb()->ProcessParameters
->ConsoleFlags
& 1))
96 for(i
= NrCtrlHandlers
; i
> 0; -- i
)
97 if(CtrlHandlers
[i
- 1](nCode
)) break;
99 RtlLeaveCriticalSection(&ConsoleLock
);
102 case CTRL_CLOSE_EVENT
:
103 case CTRL_LOGOFF_EVENT
:
104 case CTRL_SHUTDOWN_EVENT
:
107 default: ExitThread(0);
110 RtlEnterCriticalSection(&ConsoleLock
);
112 if(!(nCode
== CTRL_C_EVENT
&&
113 NtCurrentPeb()->ProcessParameters
->ConsoleFlags
& 1))
118 if (i
== 1 && (CodeAndFlag
& MINLONG
) &&
119 (nCode
== CTRL_LOGOFF_EVENT
|| nCode
== CTRL_SHUTDOWN_EVENT
))
122 if(CtrlHandlers
[i
- 1](nCode
))
126 case CTRL_CLOSE_EVENT
:
127 case CTRL_LOGOFF_EVENT
:
128 case CTRL_SHUTDOWN_EVENT
:
129 nExitCode
= CodeAndFlag
;
136 RtlLeaveCriticalSection(&ConsoleLock
);
137 ExitThread(nExitCode
);
141 /* FUNCTIONS *****************************************************************/
147 AddConsoleAliasA (LPSTR Source
,
151 DPRINT1("AddConsoleAliasA(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Source
, Target
, ExeName
);
152 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
161 AddConsoleAliasW (LPWSTR Source
,
165 DPRINT1("AddConsoleAliasW(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Source
, Target
, ExeName
);
166 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
175 ConsoleMenuControl (HANDLE hConsole
,
182 DPRINT1("ConsoleMenuControl(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", hConsole
, Unknown1
, Unknown2
);
183 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
192 DuplicateConsoleHandle (HANDLE hConsole
,
193 DWORD dwDesiredAccess
,
197 CSR_API_MESSAGE Request
;
201 if (IsConsoleHandle (hConsole
) == FALSE
)
203 SetLastError (ERROR_INVALID_PARAMETER
);
204 return INVALID_HANDLE_VALUE
;
207 CsrRequest
= MAKE_CSR_API(DUPLICATE_HANDLE
, CSR_NATIVE
);
208 Request
.Data
.DuplicateHandleRequest
.Handle
= hConsole
;
209 Request
.Data
.DuplicateHandleRequest
.ProcessId
= GetTeb()->Cid
.UniqueProcess
;
210 Status
= CsrClientCallServer(&Request
,
213 sizeof(CSR_API_MESSAGE
));
214 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
=Request
.Status
))
216 SetLastErrorByStatus(Status
);
217 return INVALID_HANDLE_VALUE
;
219 return Request
.Data
.DuplicateHandleRequest
.Handle
;
227 ExpungeConsoleCommandHistoryW (DWORD Unknown0
)
232 DPRINT1("ExpungeConsoleCommandHistoryW(0x%x) UNIMPLEMENTED!\n", Unknown0
);
233 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
242 ExpungeConsoleCommandHistoryA (DWORD Unknown0
)
248 DPRINT1("ExpungeConsoleCommandHistoryW(0x%x) UNIMPLEMENTED!\n", Unknown0
);
249 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
258 GetConsoleAliasW (LPWSTR lpSource
,
259 LPWSTR lpTargetBuffer
,
260 DWORD TargetBufferLength
,
266 DPRINT1("GetConsoleAliasW(0x%p, 0x%p, 0x%x, 0x%p) UNIMPLEMENTED!\n", lpSource
, lpTargetBuffer
, TargetBufferLength
, lpExeName
);
267 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
276 GetConsoleAliasA (LPSTR lpSource
,
277 LPSTR lpTargetBuffer
,
278 DWORD TargetBufferLength
,
284 DPRINT1("GetConsoleAliasA(0x%p, 0x%p, 0x%x, 0x%p) UNIMPLEMENTED!\n", lpSource
, lpTargetBuffer
, TargetBufferLength
, lpExeName
);
285 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
294 GetConsoleAliasExesW (LPWSTR lpExeNameBuffer
,
295 DWORD ExeNameBufferLength
)
300 DPRINT1("GetConsoleAliasExesW(0x%p, 0x%x) UNIMPLEMENTED!\n", lpExeNameBuffer
, ExeNameBufferLength
);
301 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
310 GetConsoleAliasExesA (LPSTR lpExeNameBuffer
,
311 DWORD ExeNameBufferLength
)
316 DPRINT1("GetConsoleAliasExesA(0x%p, 0x%x) UNIMPLEMENTED!\n", lpExeNameBuffer
, ExeNameBufferLength
);
317 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
326 GetConsoleAliasExesLengthA (VOID
)
331 DPRINT1("GetConsoleAliasExesLengthA() UNIMPLEMENTED!\n");
332 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
341 GetConsoleAliasExesLengthW (VOID
)
346 DPRINT1("GetConsoleAliasExesLengthW() UNIMPLEMENTED!\n");
347 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
356 GetConsoleAliasesW (LPWSTR AliasBuffer
,
357 DWORD AliasBufferLength
,
363 DPRINT1("GetConsoleAliasesW(0x%p, 0x%x, 0x%p) UNIMPLEMENTED!\n", AliasBuffer
, AliasBufferLength
, ExeName
);
364 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
373 GetConsoleAliasesA (LPSTR AliasBuffer
,
374 DWORD AliasBufferLength
,
380 DPRINT1("GetConsoleAliasesA(0x%p, 0x%x, 0x%p) UNIMPLEMENTED!\n", AliasBuffer
, AliasBufferLength
, ExeName
);
381 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
390 GetConsoleAliasesLengthW (LPWSTR lpExeName
)
395 DPRINT1("GetConsoleAliasesLengthW(0x%p) UNIMPLEMENTED!\n", lpExeName
);
396 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
405 GetConsoleAliasesLengthA (LPSTR lpExeName
)
410 DPRINT1("GetConsoleAliasesLengthA(0x%p) UNIMPLEMENTED!\n", lpExeName
);
411 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
420 GetConsoleCommandHistoryW (DWORD Unknown0
,
427 DPRINT1("GetConsoleCommandHistoryW(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
);
428 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
437 GetConsoleCommandHistoryA (DWORD Unknown0
,
444 DPRINT1("GetConsoleCommandHistoryA(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
);
445 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
454 GetConsoleCommandHistoryLengthW (DWORD Unknown0
)
459 DPRINT1("GetConsoleCommandHistoryLengthW(0x%x) UNIMPLEMENTED!\n", Unknown0
);
460 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
469 GetConsoleCommandHistoryLengthA (DWORD Unknown0
)
474 DPRINT1("GetConsoleCommandHistoryLengthA(0x%x) UNIMPLEMENTED!\n", Unknown0
);
475 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
483 GetConsoleDisplayMode (LPDWORD lpdwMode
)
485 * FUNCTION: Get the console display mode
487 * lpdwMode - Address of variable that receives the current value
489 * STATUS: Undocumented
492 DPRINT1("GetConsoleDisplayMode(0x%x) UNIMPLEMENTED!\n", lpdwMode
);
493 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
502 GetConsoleFontInfo (DWORD Unknown0
,
510 DPRINT1("GetConsoleFontInfo(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
, Unknown3
);
511 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
520 GetConsoleFontSize(HANDLE hConsoleOutput
,
523 COORD Empty
= {0, 0};
524 DPRINT1("GetConsoleFontSize(0x%x, 0x%x) UNIMPLEMENTED!\n", hConsoleOutput
, nFont
);
525 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
534 GetConsoleHardwareState (HANDLE hConsole
,
541 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
545 CsrRequest
= MAKE_CSR_API(SETGET_CONSOLE_HW_STATE
, CSR_CONSOLE
);
546 Request
.Data
.ConsoleHardwareStateRequest
.ConsoleHandle
= hConsole
;
547 Request
.Data
.ConsoleHardwareStateRequest
.SetGet
= CONSOLE_HARDWARE_STATE_GET
;
549 Status
= CsrClientCallServer(& Request
,
552 sizeof(CSR_API_MESSAGE
));
553 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
555 SetLastErrorByStatus(Status
);
558 *State
= Request
.Data
.ConsoleHardwareStateRequest
.State
;
567 GetConsoleInputWaitHandle (VOID
)
572 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
576 CsrRequest
= MAKE_CSR_API(GET_INPUT_WAIT_HANDLE
, CSR_CONSOLE
);
577 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
,
578 sizeof(CSR_API_MESSAGE
));
579 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
581 SetLastErrorByStatus(Status
);
584 return Request
.Data
.GetConsoleInputWaitHandle
.InputWaitHandle
;
592 GetCurrentConsoleFont(HANDLE hConsoleOutput
,
594 PCONSOLE_FONT_INFO lpConsoleCurrentFont
)
596 DPRINT1("GetCurrentConsoleFont(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", hConsoleOutput
, bMaximumWindow
, lpConsoleCurrentFont
);
597 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
606 GetNumberOfConsoleFonts (VOID
)
611 DPRINT1("GetNumberOfConsoleFonts() UNIMPLEMENTED!\n");
612 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
613 return 1; /* FIXME: call csrss.exe */
621 InvalidateConsoleDIBits (DWORD Unknown0
,
627 DPRINT1("InvalidateConsoleDIBits(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
);
628 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
637 OpenConsoleW (LPWSTR wsName
,
638 DWORD dwDesiredAccess
,
640 DWORD dwCreationDistribution
)
645 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
647 PHANDLE phConsole
= NULL
;
648 NTSTATUS Status
= STATUS_SUCCESS
;
650 if(0 == _wcsicmp(wsName
, L
"CONIN$"))
652 CsrRequest
= MAKE_CSR_API(GET_INPUT_HANDLE
, CSR_NATIVE
);
653 phConsole
= & Request
.Data
.GetInputHandleRequest
.InputHandle
;
655 else if (0 == _wcsicmp(wsName
, L
"CONOUT$"))
657 CsrRequest
= MAKE_CSR_API(GET_OUTPUT_HANDLE
, CSR_NATIVE
);
658 phConsole
= & Request
.Data
.GetOutputHandleRequest
.OutputHandle
;
662 SetLastError(ERROR_INVALID_PARAMETER
);
663 return(INVALID_HANDLE_VALUE
);
665 if ((GENERIC_READ
|GENERIC_WRITE
) != dwDesiredAccess
)
667 SetLastError(ERROR_INVALID_PARAMETER
);
668 return(INVALID_HANDLE_VALUE
);
670 if (OPEN_EXISTING
!= dwCreationDistribution
)
672 SetLastError(ERROR_INVALID_PARAMETER
);
673 return(INVALID_HANDLE_VALUE
);
675 Status
= CsrClientCallServer(& Request
,
678 sizeof(CSR_API_MESSAGE
));
679 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
681 SetLastErrorByStatus(Status
);
682 return INVALID_HANDLE_VALUE
;
692 SetConsoleCommandHistoryMode (DWORD dwMode
)
697 DPRINT1("SetConsoleCommandHistoryMode(0x%x) UNIMPLEMENTED!\n", dwMode
);
698 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
707 SetConsoleCursor (DWORD Unknown0
,
713 DPRINT1("SetConsoleCursor(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
);
714 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
723 SetConsoleDisplayMode (HANDLE hOut
,
727 * FUNCTION: Set the console display mode.
729 * hOut - Standard output handle.
730 * dwNewMode - New mode.
731 * lpdwOldMode - Address of a variable that receives the old mode.
734 DPRINT1("SetConsoleDisplayMode(0x%x, 0x%x, 0x%p) UNIMPLEMENTED!\n", hOut
, dwNewMode
, lpdwOldMode
);
735 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
744 SetConsoleFont (DWORD Unknown0
,
750 DPRINT1("SetConsoleFont(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
);
751 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
760 SetConsoleHardwareState (HANDLE hConsole
,
767 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
771 CsrRequest
= MAKE_CSR_API(SETGET_CONSOLE_HW_STATE
, CSR_CONSOLE
);
772 Request
.Data
.ConsoleHardwareStateRequest
.ConsoleHandle
= hConsole
;
773 Request
.Data
.ConsoleHardwareStateRequest
.SetGet
= CONSOLE_HARDWARE_STATE_SET
;
774 Request
.Data
.ConsoleHardwareStateRequest
.State
= State
;
776 Status
= CsrClientCallServer(& Request
,
779 sizeof(CSR_API_MESSAGE
));
780 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
782 SetLastErrorByStatus(Status
);
793 SetConsoleKeyShortcuts (DWORD Unknown0
,
801 DPRINT1("SetConsoleKeyShortcuts(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
, Unknown3
);
802 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
811 SetConsoleMaximumWindowSize (DWORD Unknown0
,
817 DPRINT1("SetConsoleMaximumWindowSize(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
);
818 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
827 SetConsoleMenuClose (DWORD Unknown0
)
832 DPRINT1("SetConsoleMenuClose(0x%x) UNIMPLEMENTED!\n", Unknown0
);
833 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
842 SetConsoleNumberOfCommandsA (DWORD Unknown0
,
848 DPRINT1("SetConsoleNumberOfCommandsA(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
);
849 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
858 SetConsoleNumberOfCommandsW (DWORD Unknown0
,
864 DPRINT1("SetConsoleNumberOfCommandsW(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
);
865 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
874 SetConsolePalette (DWORD Unknown0
,
881 DPRINT1("SetConsolePalette(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
);
882 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
891 SetLastConsoleEventActive (VOID
)
896 DPRINT1("SetLastConsoleEventActive() UNIMPLEMENTED!\n");
897 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
906 ShowConsoleCursor (DWORD Unknown0
,
912 DPRINT1("ShowConsoleCursor(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
);
913 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
919 * FUNCTION: Checks whether the given handle is a valid console handle.
921 * Handle - Handle to be checked
923 * TRUE: Handle is a valid console handle
924 * FALSE: Handle is not a valid console handle.
925 * STATUS: Officially undocumented
930 VerifyConsoleIoHandle(HANDLE Handle
)
932 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
936 CsrRequest
= MAKE_CSR_API(VERIFY_HANDLE
, CSR_NATIVE
);
937 Request
.Data
.VerifyHandleRequest
.Handle
= Handle
;
938 Status
= CsrClientCallServer(&Request
,
941 sizeof(CSR_API_MESSAGE
));
942 if (!NT_SUCCESS(Status
))
944 SetLastErrorByStatus(Status
);
948 return (BOOL
)NT_SUCCESS(Request
.Status
);
956 WriteConsoleInputVDMA (DWORD Unknown0
,
961 DPRINT1("WriteConsoleInputVDMA(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
, Unknown3
);
962 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
971 WriteConsoleInputVDMW (DWORD Unknown0
,
976 DPRINT1("WriteConsoleInputVDMW(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
, Unknown3
);
977 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
986 CloseConsoleHandle(HANDLE Handle
)
991 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
995 if (IsConsoleHandle (Handle
) == FALSE
)
997 SetLastError (ERROR_INVALID_PARAMETER
);
1001 CsrRequest
= MAKE_CSR_API(CLOSE_HANDLE
, CSR_NATIVE
);
1002 Request
.Data
.CloseHandleRequest
.Handle
= Handle
;
1003 Status
= CsrClientCallServer(&Request
,
1006 sizeof(CSR_API_MESSAGE
));
1007 if (!NT_SUCCESS(Status
))
1009 SetLastErrorByStatus(Status
);
1020 GetStdHandle(DWORD nStdHandle
)
1022 * FUNCTION: Get a handle for the standard input, standard output
1023 * and a standard error device.
1025 * nStdHandle - Specifies the device for which to return the handle.
1026 * RETURNS: If the function succeeds, the return value is the handle
1027 * of the specified device. Otherwise the value is INVALID_HANDLE_VALUE.
1030 PRTL_USER_PROCESS_PARAMETERS Ppb
;
1032 Ppb
= NtCurrentPeb()->ProcessParameters
;
1035 case STD_INPUT_HANDLE
:
1036 return Ppb
->StandardInput
;
1038 case STD_OUTPUT_HANDLE
:
1039 return Ppb
->StandardOutput
;
1041 case STD_ERROR_HANDLE
:
1042 return Ppb
->StandardError
;
1045 SetLastError (ERROR_INVALID_PARAMETER
);
1046 return INVALID_HANDLE_VALUE
;
1054 SetStdHandle(DWORD nStdHandle
,
1057 * FUNCTION: Set the handle for the standard input, standard output or
1058 * the standard error device.
1060 * nStdHandle - Specifies the handle to be set.
1061 * hHandle - The handle to set.
1062 * RETURNS: TRUE if the function succeeds, FALSE otherwise.
1065 PRTL_USER_PROCESS_PARAMETERS Ppb
;
1067 /* no need to check if hHandle == INVALID_HANDLE_VALUE */
1069 Ppb
= NtCurrentPeb()->ProcessParameters
;
1073 case STD_INPUT_HANDLE
:
1074 Ppb
->StandardInput
= hHandle
;
1077 case STD_OUTPUT_HANDLE
:
1078 Ppb
->StandardOutput
= hHandle
;
1081 case STD_ERROR_HANDLE
:
1082 Ppb
->StandardError
= hHandle
;
1086 /* windows for whatever reason sets the last error to ERROR_INVALID_HANDLE here */
1087 SetLastError (ERROR_INVALID_HANDLE
);
1093 IntWriteConsole(HANDLE hConsoleOutput
,
1095 DWORD nNumberOfCharsToWrite
,
1096 LPDWORD lpNumberOfCharsWritten
,
1100 PCSR_API_MESSAGE Request
;
1104 ULONG SizeBytes
, CharSize
;
1107 CharSize
= (bUnicode
? sizeof(WCHAR
) : sizeof(CHAR
));
1108 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
1109 max(sizeof(CSR_API_MESSAGE
),
1110 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE
)
1111 + min(nNumberOfCharsToWrite
, CSRSS_MAX_WRITE_CONSOLE
/ CharSize
) * CharSize
));
1112 if (Request
== NULL
)
1114 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1118 CsrRequest
= MAKE_CSR_API(WRITE_CONSOLE
, CSR_CONSOLE
);
1120 while(nNumberOfCharsToWrite
> 0)
1122 Request
->Data
.WriteConsoleRequest
.ConsoleHandle
= hConsoleOutput
;
1123 Request
->Data
.WriteConsoleRequest
.Unicode
= bUnicode
;
1125 nChars
= (USHORT
)min(nNumberOfCharsToWrite
, CSRSS_MAX_WRITE_CONSOLE
/ CharSize
);
1126 Request
->Data
.WriteConsoleRequest
.NrCharactersToWrite
= nChars
;
1128 SizeBytes
= nChars
* CharSize
;
1130 memcpy(Request
->Data
.WriteConsoleRequest
.Buffer
, lpBuffer
, SizeBytes
);
1132 Status
= CsrClientCallServer(Request
,
1135 max(sizeof(CSR_API_MESSAGE
), CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE
) + SizeBytes
));
1137 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
->Status
))
1139 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
1140 SetLastErrorByStatus(Status
);
1144 nNumberOfCharsToWrite
-= nChars
;
1145 lpBuffer
= (PVOID
)((ULONG_PTR
)lpBuffer
+ (ULONG_PTR
)SizeBytes
);
1146 Written
+= Request
->Data
.WriteConsoleRequest
.NrCharactersWritten
;
1149 if(lpNumberOfCharsWritten
!= NULL
)
1151 *lpNumberOfCharsWritten
= Written
;
1153 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
1159 /*--------------------------------------------------------------
1165 WriteConsoleA(HANDLE hConsoleOutput
,
1166 CONST VOID
*lpBuffer
,
1167 DWORD nNumberOfCharsToWrite
,
1168 LPDWORD lpNumberOfCharsWritten
,
1171 return IntWriteConsole(hConsoleOutput
,
1173 nNumberOfCharsToWrite
,
1174 lpNumberOfCharsWritten
,
1180 /*--------------------------------------------------------------
1187 HANDLE hConsoleOutput
,
1188 CONST VOID
*lpBuffer
,
1189 DWORD nNumberOfCharsToWrite
,
1190 LPDWORD lpNumberOfCharsWritten
,
1194 return IntWriteConsole(hConsoleOutput
,
1196 nNumberOfCharsToWrite
,
1197 lpNumberOfCharsWritten
,
1204 IntReadConsole(HANDLE hConsoleInput
,
1206 DWORD nNumberOfCharsToRead
,
1207 LPDWORD lpNumberOfCharsRead
,
1208 PCONSOLE_READCONSOLE_CONTROL lpReserved
,
1211 PCSR_API_MESSAGE Request
;
1214 ULONG CharSize
, CharsRead
= 0;
1216 CharSize
= (bUnicode
? sizeof(WCHAR
) : sizeof(CHAR
));
1217 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
1218 max(sizeof(CSR_API_MESSAGE
),
1219 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE
)
1220 + min(nNumberOfCharsToRead
, CSRSS_MAX_READ_CONSOLE
/ CharSize
) * CharSize
));
1221 if (Request
== NULL
)
1223 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1227 Request
->Status
= STATUS_SUCCESS
;
1228 CsrRequest
= MAKE_CSR_API(READ_CONSOLE
, CSR_CONSOLE
);
1232 if(Request
->Status
== STATUS_PENDING
)
1234 Status
= NtWaitForSingleObject(Request
->Data
.ReadConsoleRequest
.EventHandle
, FALSE
, 0);
1235 if(!NT_SUCCESS(Status
))
1237 DPRINT1("Wait for console input failed!\n");
1242 Request
->Data
.ReadConsoleRequest
.ConsoleHandle
= hConsoleInput
;
1243 Request
->Data
.ReadConsoleRequest
.Unicode
= bUnicode
;
1244 Request
->Data
.ReadConsoleRequest
.NrCharactersToRead
= (WORD
)min(nNumberOfCharsToRead
, CSRSS_MAX_READ_CONSOLE
/ CharSize
);
1245 Request
->Data
.ReadConsoleRequest
.nCharsCanBeDeleted
= (WORD
)CharsRead
;
1246 Status
= CsrClientCallServer(Request
,
1249 max(sizeof(CSR_API_MESSAGE
),
1250 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE
)
1251 + Request
->Data
.ReadConsoleRequest
.NrCharactersToRead
* CharSize
));
1253 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
->Status
))
1255 DPRINT1("CSR returned error in ReadConsole\n");
1256 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
1257 SetLastErrorByStatus(Status
);
1261 nNumberOfCharsToRead
-= Request
->Data
.ReadConsoleRequest
.NrCharactersRead
;
1262 memcpy((PVOID
)((ULONG_PTR
)lpBuffer
+ (ULONG_PTR
)(CharsRead
* CharSize
)),
1263 Request
->Data
.ReadConsoleRequest
.Buffer
,
1264 Request
->Data
.ReadConsoleRequest
.NrCharactersRead
* CharSize
);
1265 CharsRead
+= Request
->Data
.ReadConsoleRequest
.NrCharactersRead
;
1267 if(Request
->Status
== STATUS_NOTIFY_CLEANUP
)
1272 nNumberOfCharsToRead
++;
1274 Request
->Status
= STATUS_PENDING
;
1276 } while(Request
->Status
== STATUS_PENDING
&& nNumberOfCharsToRead
> 0);
1278 if(lpNumberOfCharsRead
!= NULL
)
1280 *lpNumberOfCharsRead
= CharsRead
;
1283 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
1289 /*--------------------------------------------------------------
1295 ReadConsoleA(HANDLE hConsoleInput
,
1297 DWORD nNumberOfCharsToRead
,
1298 LPDWORD lpNumberOfCharsRead
,
1299 PCONSOLE_READCONSOLE_CONTROL pInputControl
)
1301 return IntReadConsole(hConsoleInput
,
1303 nNumberOfCharsToRead
,
1304 lpNumberOfCharsRead
,
1310 /*--------------------------------------------------------------
1316 ReadConsoleW(HANDLE hConsoleInput
,
1318 DWORD nNumberOfCharsToRead
,
1319 LPDWORD lpNumberOfCharsRead
,
1320 PCONSOLE_READCONSOLE_CONTROL pInputControl
)
1322 return IntReadConsole(hConsoleInput
,
1324 nNumberOfCharsToRead
,
1325 lpNumberOfCharsRead
,
1331 /*--------------------------------------------------------------
1336 BOOL STDCALL
AllocConsole(VOID
)
1338 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
1343 if(NtCurrentPeb()->ProcessParameters
->ConsoleHandle
)
1345 DPRINT("AllocConsole: Allocate duplicate console to the same Process\n");
1346 SetLastErrorByStatus (STATUS_OBJECT_NAME_EXISTS
);
1350 Request
.Data
.AllocConsoleRequest
.CtrlDispatcher
= ConsoleControlDispatcher
;
1351 Request
.Data
.AllocConsoleRequest
.ConsoleNeeded
= TRUE
;
1353 CsrRequest
= MAKE_CSR_API(ALLOC_CONSOLE
, CSR_CONSOLE
);
1354 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
1355 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
1357 SetLastErrorByStatus ( Status
);
1360 NtCurrentPeb()->ProcessParameters
->ConsoleHandle
= Request
.Data
.AllocConsoleRequest
.Console
;
1361 SetStdHandle( STD_INPUT_HANDLE
, Request
.Data
.AllocConsoleRequest
.InputHandle
);
1362 SetStdHandle( STD_OUTPUT_HANDLE
, Request
.Data
.AllocConsoleRequest
.OutputHandle
);
1363 hStdError
= DuplicateConsoleHandle(Request
.Data
.AllocConsoleRequest
.OutputHandle
,
1366 DUPLICATE_SAME_ACCESS
);
1367 SetStdHandle( STD_ERROR_HANDLE
, hStdError
);
1372 /*--------------------------------------------------------------
1377 BOOL STDCALL
FreeConsole(VOID
)
1379 // AG: I'm not sure if this is correct (what happens to std handles?)
1380 // but I just tried to reverse what AllocConsole() does...
1382 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
1386 CsrRequest
= MAKE_CSR_API(FREE_CONSOLE
, CSR_CONSOLE
);
1387 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
1388 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
1390 SetLastErrorByStatus ( Status
);
1398 /*--------------------------------------------------------------
1399 * GetConsoleScreenBufferInfo
1405 GetConsoleScreenBufferInfo(
1406 HANDLE hConsoleOutput
,
1407 PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo
1410 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
1414 CsrRequest
= MAKE_CSR_API(SCREEN_BUFFER_INFO
, CSR_CONSOLE
);
1415 Request
.Data
.ScreenBufferInfoRequest
.ConsoleHandle
= hConsoleOutput
;
1416 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
1417 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
1419 SetLastErrorByStatus ( Status
);
1422 *lpConsoleScreenBufferInfo
= Request
.Data
.ScreenBufferInfoRequest
.Info
;
1427 /*--------------------------------------------------------------
1428 * SetConsoleCursorPosition
1434 SetConsoleCursorPosition(
1435 HANDLE hConsoleOutput
,
1436 COORD dwCursorPosition
1439 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
1443 CsrRequest
= MAKE_CSR_API(SET_CURSOR
, CSR_CONSOLE
);
1444 Request
.Data
.SetCursorRequest
.ConsoleHandle
= hConsoleOutput
;
1445 Request
.Data
.SetCursorRequest
.Position
= dwCursorPosition
;
1446 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
1447 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
1449 SetLastErrorByStatus ( Status
);
1457 IntFillConsoleOutputCharacter(HANDLE hConsoleOutput
,
1461 LPDWORD lpNumberOfCharsWritten
,
1464 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
1468 CsrRequest
= MAKE_CSR_API(FILL_OUTPUT
, CSR_CONSOLE
);
1469 Request
.Data
.FillOutputRequest
.ConsoleHandle
= hConsoleOutput
;
1470 Request
.Data
.FillOutputRequest
.Unicode
= bUnicode
;
1472 Request
.Data
.FillOutputRequest
.Char
.UnicodeChar
= *((WCHAR
*)cCharacter
);
1474 Request
.Data
.FillOutputRequest
.Char
.AsciiChar
= *((CHAR
*)cCharacter
);
1475 Request
.Data
.FillOutputRequest
.Position
= dwWriteCoord
;
1476 Request
.Data
.FillOutputRequest
.Length
= (WORD
)nLength
;
1477 Status
= CsrClientCallServer(&Request
, NULL
,
1479 sizeof(CSR_API_MESSAGE
));
1481 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
1483 SetLastErrorByStatus(Status
);
1487 if(lpNumberOfCharsWritten
!= NULL
)
1489 *lpNumberOfCharsWritten
= Request
.Data
.FillOutputRequest
.NrCharactersWritten
;
1495 /*--------------------------------------------------------------
1496 * FillConsoleOutputCharacterA
1501 FillConsoleOutputCharacterA(
1502 HANDLE hConsoleOutput
,
1506 LPDWORD lpNumberOfCharsWritten
1509 return IntFillConsoleOutputCharacter(hConsoleOutput
,
1513 lpNumberOfCharsWritten
,
1518 /*--------------------------------------------------------------
1519 * FillConsoleOutputCharacterW
1525 FillConsoleOutputCharacterW(
1526 HANDLE hConsoleOutput
,
1530 LPDWORD lpNumberOfCharsWritten
1533 return IntFillConsoleOutputCharacter(hConsoleOutput
,
1537 lpNumberOfCharsWritten
,
1543 IntPeekConsoleInput(HANDLE hConsoleInput
,
1544 PINPUT_RECORD lpBuffer
,
1546 LPDWORD lpNumberOfEventsRead
,
1549 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
1550 PCSR_CAPTURE_BUFFER CaptureBuffer
;
1554 if(lpBuffer
== NULL
)
1556 SetLastError(ERROR_INVALID_PARAMETER
);
1560 Size
= nLength
* sizeof(INPUT_RECORD
);
1562 /* Allocate a Capture Buffer */
1563 DPRINT("IntPeekConsoleInput: %lx %p\n", Size
, lpNumberOfEventsRead
);
1564 CaptureBuffer
= CsrAllocateCaptureBuffer(1, Size
);
1566 /* Allocate space in the Buffer */
1567 CsrCaptureMessageBuffer(CaptureBuffer
,
1570 (PVOID
*)&Request
.Data
.PeekConsoleInputRequest
.InputRecord
);
1572 /* Set up the data to send to the Console Server */
1573 CsrRequest
= MAKE_CSR_API(PEEK_CONSOLE_INPUT
, CSR_CONSOLE
);
1574 Request
.Data
.PeekConsoleInputRequest
.ConsoleHandle
= hConsoleInput
;
1575 Request
.Data
.PeekConsoleInputRequest
.Unicode
= bUnicode
;
1576 Request
.Data
.PeekConsoleInputRequest
.Length
= nLength
;
1578 /* Call the server */
1579 Status
= CsrClientCallServer(&Request
,
1582 sizeof(CSR_API_MESSAGE
));
1583 DPRINT("Server returned: %x\n", Request
.Status
);
1585 /* Check for success*/
1586 if (NT_SUCCESS(Request
.Status
))
1588 /* Return the number of events read */
1589 DPRINT("Events read: %lx\n", Request
.Data
.PeekConsoleInputRequest
.Length
);
1590 *lpNumberOfEventsRead
= Request
.Data
.PeekConsoleInputRequest
.Length
;
1592 /* Copy into the buffer */
1593 DPRINT("Copying to buffer\n");
1594 RtlCopyMemory(lpBuffer
,
1595 Request
.Data
.PeekConsoleInputRequest
.InputRecord
,
1596 sizeof(INPUT_RECORD
) * *lpNumberOfEventsRead
);
1601 *lpNumberOfEventsRead
= 0;
1602 SetLastErrorByStatus(Request
.Status
);
1605 /* Release the capture buffer */
1606 CsrFreeCaptureBuffer(CaptureBuffer
);
1608 /* Return TRUE or FALSE */
1609 return NT_SUCCESS(Request
.Status
);
1612 /*--------------------------------------------------------------
1620 HANDLE hConsoleInput
,
1621 PINPUT_RECORD lpBuffer
,
1623 LPDWORD lpNumberOfEventsRead
1626 return IntPeekConsoleInput(hConsoleInput
, lpBuffer
, nLength
,
1627 lpNumberOfEventsRead
, FALSE
);
1631 /*--------------------------------------------------------------
1639 HANDLE hConsoleInput
,
1640 PINPUT_RECORD lpBuffer
,
1642 LPDWORD lpNumberOfEventsRead
1645 return IntPeekConsoleInput(hConsoleInput
, lpBuffer
, nLength
,
1646 lpNumberOfEventsRead
, TRUE
);
1651 IntReadConsoleInput(HANDLE hConsoleInput
,
1652 PINPUT_RECORD lpBuffer
,
1654 LPDWORD lpNumberOfEventsRead
,
1657 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
1662 CsrRequest
= MAKE_CSR_API(READ_INPUT
, CSR_CONSOLE
);
1666 Request
.Data
.ReadInputRequest
.ConsoleHandle
= hConsoleInput
;
1667 Request
.Data
.ReadInputRequest
.Unicode
= bUnicode
;
1668 Status
= CsrClientCallServer(&Request
, NULL
,
1670 sizeof(CSR_API_MESSAGE
));
1671 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
1675 /* we couldn't read a single record, fail */
1676 SetLastErrorByStatus(Status
);
1681 /* FIXME - fail gracefully in case we already read at least one record? */
1685 else if(Status
== STATUS_PENDING
)
1689 Status
= NtWaitForSingleObject(Request
.Data
.ReadInputRequest
.Event
, FALSE
, 0);
1690 if(!NT_SUCCESS(Status
))
1692 SetLastErrorByStatus(Status
);
1698 /* nothing more to read (waiting for more input??), let's just bail */
1704 lpBuffer
[Read
++] = Request
.Data
.ReadInputRequest
.Input
;
1707 if(!Request
.Data
.ReadInputRequest
.MoreEvents
)
1709 /* nothing more to read, bail */
1715 if(lpNumberOfEventsRead
!= NULL
)
1717 *lpNumberOfEventsRead
= Read
;
1724 /*--------------------------------------------------------------
1730 ReadConsoleInputA(HANDLE hConsoleInput
,
1731 PINPUT_RECORD lpBuffer
,
1733 LPDWORD lpNumberOfEventsRead
)
1735 return IntReadConsoleInput(hConsoleInput
, lpBuffer
, nLength
,
1736 lpNumberOfEventsRead
, FALSE
);
1740 /*--------------------------------------------------------------
1748 HANDLE hConsoleInput
,
1749 PINPUT_RECORD lpBuffer
,
1751 LPDWORD lpNumberOfEventsRead
1754 return IntReadConsoleInput(hConsoleInput
, lpBuffer
, nLength
,
1755 lpNumberOfEventsRead
, TRUE
);
1760 IntWriteConsoleInput(HANDLE hConsoleInput
,
1761 PINPUT_RECORD lpBuffer
,
1763 LPDWORD lpNumberOfEventsWritten
,
1766 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
1767 PCSR_CAPTURE_BUFFER CaptureBuffer
;
1771 if(lpBuffer
== NULL
)
1773 SetLastError(ERROR_INVALID_PARAMETER
);
1777 Size
= nLength
* sizeof(INPUT_RECORD
);
1779 /* Allocate a Capture Buffer */
1780 DPRINT("IntWriteConsoleInput: %lx %p\n", Size
, lpNumberOfEventsWritten
);
1781 CaptureBuffer
= CsrAllocateCaptureBuffer(1, Size
);
1783 /* Allocate space in the Buffer */
1784 CsrCaptureMessageBuffer(CaptureBuffer
,
1787 (PVOID
*)&Request
.Data
.WriteConsoleInputRequest
.InputRecord
);
1789 /* Set up the data to send to the Console Server */
1790 CsrRequest
= MAKE_CSR_API(WRITE_CONSOLE_INPUT
, CSR_CONSOLE
);
1791 Request
.Data
.WriteConsoleInputRequest
.ConsoleHandle
= hConsoleInput
;
1792 Request
.Data
.WriteConsoleInputRequest
.Unicode
= bUnicode
;
1793 Request
.Data
.WriteConsoleInputRequest
.Length
= nLength
;
1795 /* Call the server */
1796 Status
= CsrClientCallServer(&Request
,
1799 sizeof(CSR_API_MESSAGE
));
1800 DPRINT("Server returned: %x\n", Request
.Status
);
1802 /* Check for success*/
1803 if (NT_SUCCESS(Request
.Status
))
1805 /* Return the number of events read */
1806 DPRINT("Events read: %lx\n", Request
.Data
.WriteConsoleInputRequest
.Length
);
1807 *lpNumberOfEventsWritten
= Request
.Data
.WriteConsoleInputRequest
.Length
;
1809 /* Copy into the buffer */
1810 DPRINT("Copying to buffer\n");
1811 RtlCopyMemory(lpBuffer
,
1812 Request
.Data
.WriteConsoleInputRequest
.InputRecord
,
1813 sizeof(INPUT_RECORD
) * *lpNumberOfEventsWritten
);
1818 *lpNumberOfEventsWritten
= 0;
1819 SetLastErrorByStatus(Request
.Status
);
1822 /* Release the capture buffer */
1823 CsrFreeCaptureBuffer(CaptureBuffer
);
1825 /* Return TRUE or FALSE */
1826 return NT_SUCCESS(Request
.Status
);
1830 /*--------------------------------------------------------------
1831 * WriteConsoleInputA
1838 HANDLE hConsoleInput
,
1839 CONST INPUT_RECORD
*lpBuffer
,
1841 LPDWORD lpNumberOfEventsWritten
1844 return IntWriteConsoleInput(hConsoleInput
,
1845 (PINPUT_RECORD
)lpBuffer
,
1847 lpNumberOfEventsWritten
,
1852 /*--------------------------------------------------------------
1853 * WriteConsoleInputW
1860 HANDLE hConsoleInput
,
1861 CONST INPUT_RECORD
*lpBuffer
,
1863 LPDWORD lpNumberOfEventsWritten
1866 return IntWriteConsoleInput(hConsoleInput
,
1867 (PINPUT_RECORD
)lpBuffer
,
1869 lpNumberOfEventsWritten
,
1875 IntReadConsoleOutput(HANDLE hConsoleOutput
,
1876 PCHAR_INFO lpBuffer
,
1878 COORD dwBufferCoord
,
1879 PSMALL_RECT lpReadRegion
,
1882 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
1883 PCSR_CAPTURE_BUFFER CaptureBuffer
;
1885 DWORD Size
, SizeX
, SizeY
;
1887 if(lpBuffer
== NULL
)
1889 SetLastError(ERROR_INVALID_PARAMETER
);
1893 Size
= dwBufferSize
.X
* dwBufferSize
.Y
* sizeof(CHAR_INFO
);
1895 /* Allocate a Capture Buffer */
1896 DPRINT("IntReadConsoleOutput: %lx %p\n", Size
, lpReadRegion
);
1897 CaptureBuffer
= CsrAllocateCaptureBuffer(1, Size
);
1899 /* Allocate space in the Buffer */
1900 CsrCaptureMessageBuffer(CaptureBuffer
,
1903 (PVOID
*)&Request
.Data
.ReadConsoleOutputRequest
.CharInfo
);
1905 /* Set up the data to send to the Console Server */
1906 CsrRequest
= MAKE_CSR_API(READ_CONSOLE_OUTPUT
, CSR_CONSOLE
);
1907 Request
.Data
.ReadConsoleOutputRequest
.ConsoleHandle
= hConsoleOutput
;
1908 Request
.Data
.ReadConsoleOutputRequest
.Unicode
= bUnicode
;
1909 Request
.Data
.ReadConsoleOutputRequest
.BufferSize
= dwBufferSize
;
1910 Request
.Data
.ReadConsoleOutputRequest
.BufferCoord
= dwBufferCoord
;
1911 Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
= *lpReadRegion
;
1913 /* Call the server */
1914 Status
= CsrClientCallServer(&Request
,
1917 sizeof(CSR_API_MESSAGE
));
1918 DPRINT("Server returned: %x\n", Request
.Status
);
1920 /* Check for success*/
1921 if (NT_SUCCESS(Request
.Status
))
1923 /* Copy into the buffer */
1924 DPRINT("Copying to buffer\n");
1925 SizeX
= Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
.Right
-
1926 Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
.Left
+ 1;
1927 SizeY
= Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
.Bottom
-
1928 Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
.Top
+ 1;
1929 RtlCopyMemory(lpBuffer
,
1930 Request
.Data
.ReadConsoleOutputRequest
.CharInfo
,
1931 sizeof(CHAR_INFO
) * SizeX
* SizeY
);
1936 SetLastErrorByStatus(Request
.Status
);
1939 /* Return the read region */
1940 DPRINT("read region: %lx\n", Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
);
1941 *lpReadRegion
= Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
;
1943 /* Release the capture buffer */
1944 CsrFreeCaptureBuffer(CaptureBuffer
);
1946 /* Return TRUE or FALSE */
1947 return NT_SUCCESS(Request
.Status
);
1950 /*--------------------------------------------------------------
1951 * ReadConsoleOutputA
1958 HANDLE hConsoleOutput
,
1959 PCHAR_INFO lpBuffer
,
1961 COORD dwBufferCoord
,
1962 PSMALL_RECT lpReadRegion
1965 return IntReadConsoleOutput(hConsoleOutput
, lpBuffer
, dwBufferSize
,
1966 dwBufferCoord
, lpReadRegion
, FALSE
);
1970 /*--------------------------------------------------------------
1971 * ReadConsoleOutputW
1978 HANDLE hConsoleOutput
,
1979 PCHAR_INFO lpBuffer
,
1981 COORD dwBufferCoord
,
1982 PSMALL_RECT lpReadRegion
1985 return IntReadConsoleOutput(hConsoleOutput
, lpBuffer
, dwBufferSize
,
1986 dwBufferCoord
, lpReadRegion
, TRUE
);
1991 IntWriteConsoleOutput(HANDLE hConsoleOutput
,
1992 CONST CHAR_INFO
*lpBuffer
,
1994 COORD dwBufferCoord
,
1995 PSMALL_RECT lpWriteRegion
,
1998 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
1999 PCSR_CAPTURE_BUFFER CaptureBuffer
;
2003 Size
= dwBufferSize
.Y
* dwBufferSize
.X
* sizeof(CHAR_INFO
);
2005 /* Allocate a Capture Buffer */
2006 DPRINT("IntWriteConsoleOutput: %lx %p\n", Size
, lpWriteRegion
);
2007 CaptureBuffer
= CsrAllocateCaptureBuffer(1, Size
);
2009 /* Allocate space in the Buffer */
2010 CsrCaptureMessageBuffer(CaptureBuffer
,
2013 (PVOID
*)&Request
.Data
.WriteConsoleOutputRequest
.CharInfo
);
2015 /* Copy from the buffer */
2016 RtlCopyMemory(Request
.Data
.WriteConsoleOutputRequest
.CharInfo
, lpBuffer
, Size
);
2018 /* Set up the data to send to the Console Server */
2019 CsrRequest
= MAKE_CSR_API(WRITE_CONSOLE_OUTPUT
, CSR_CONSOLE
);
2020 Request
.Data
.WriteConsoleOutputRequest
.ConsoleHandle
= hConsoleOutput
;
2021 Request
.Data
.WriteConsoleOutputRequest
.Unicode
= bUnicode
;
2022 Request
.Data
.WriteConsoleOutputRequest
.BufferSize
= dwBufferSize
;
2023 Request
.Data
.WriteConsoleOutputRequest
.BufferCoord
= dwBufferCoord
;
2024 Request
.Data
.WriteConsoleOutputRequest
.WriteRegion
= *lpWriteRegion
;
2026 /* Call the server */
2027 Status
= CsrClientCallServer(&Request
,
2030 sizeof(CSR_API_MESSAGE
));
2031 DPRINT("Server returned: %x\n", Request
.Status
);
2033 /* Check for success*/
2034 if (!NT_SUCCESS(Request
.Status
))
2037 SetLastErrorByStatus(Request
.Status
);
2040 /* Return the read region */
2041 DPRINT("read region: %lx\n", Request
.Data
.WriteConsoleOutputRequest
.WriteRegion
);
2042 *lpWriteRegion
= Request
.Data
.WriteConsoleOutputRequest
.WriteRegion
;
2044 /* Release the capture buffer */
2045 CsrFreeCaptureBuffer(CaptureBuffer
);
2047 /* Return TRUE or FALSE */
2048 return NT_SUCCESS(Request
.Status
);
2051 /*--------------------------------------------------------------
2052 * WriteConsoleOutputA
2057 WriteConsoleOutputA(HANDLE hConsoleOutput
,
2058 CONST CHAR_INFO
*lpBuffer
,
2060 COORD dwBufferCoord
,
2061 PSMALL_RECT lpWriteRegion
)
2063 return IntWriteConsoleOutput(hConsoleOutput
, lpBuffer
, dwBufferSize
,
2064 dwBufferCoord
, lpWriteRegion
, FALSE
);
2068 /*--------------------------------------------------------------
2069 * WriteConsoleOutputW
2075 WriteConsoleOutputW(
2076 HANDLE hConsoleOutput
,
2077 CONST CHAR_INFO
*lpBuffer
,
2079 COORD dwBufferCoord
,
2080 PSMALL_RECT lpWriteRegion
2083 return IntWriteConsoleOutput(hConsoleOutput
, lpBuffer
, dwBufferSize
,
2084 dwBufferCoord
, lpWriteRegion
, TRUE
);
2089 IntReadConsoleOutputCharacter(HANDLE hConsoleOutput
,
2093 LPDWORD lpNumberOfCharsRead
,
2096 PCSR_API_MESSAGE Request
; ULONG CsrRequest
;
2098 ULONG nChars
, SizeBytes
, CharSize
;
2099 DWORD CharsRead
= 0;
2101 CharSize
= (bUnicode
? sizeof(WCHAR
) : sizeof(CHAR
));
2103 nChars
= min(nLength
, CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR
) / CharSize
;
2104 SizeBytes
= nChars
* CharSize
;
2106 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
2107 max(sizeof(CSR_API_MESSAGE
),
2108 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_CHAR
)
2109 + min (nChars
, CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR
/ CharSize
) * CharSize
));
2110 if (Request
== NULL
)
2112 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2116 CsrRequest
= MAKE_CSR_API(READ_CONSOLE_OUTPUT_CHAR
, CSR_CONSOLE
);
2117 Request
->Data
.ReadConsoleOutputCharRequest
.ReadCoord
= dwReadCoord
;
2123 Request
->Data
.ReadConsoleOutputCharRequest
.ConsoleHandle
= hConsoleOutput
;
2124 Request
->Data
.ReadConsoleOutputCharRequest
.Unicode
= bUnicode
;
2125 Request
->Data
.ReadConsoleOutputCharRequest
.NumCharsToRead
= min(nLength
, nChars
);
2126 SizeBytes
= Request
->Data
.ReadConsoleOutputCharRequest
.NumCharsToRead
* CharSize
;
2128 Status
= CsrClientCallServer(Request
,
2131 max (sizeof(CSR_API_MESSAGE
),
2132 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_CHAR
) + SizeBytes
));
2133 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Request
->Status
))
2135 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2136 SetLastErrorByStatus(Status
);
2140 BytesRead
= Request
->Data
.ReadConsoleOutputCharRequest
.CharsRead
* CharSize
;
2141 memcpy(lpCharacter
, Request
->Data
.ReadConsoleOutputCharRequest
.String
, BytesRead
);
2142 lpCharacter
= (PVOID
)((ULONG_PTR
)lpCharacter
+ (ULONG_PTR
)BytesRead
);
2143 CharsRead
+= Request
->Data
.ReadConsoleOutputCharRequest
.CharsRead
;
2144 nLength
-= Request
->Data
.ReadConsoleOutputCharRequest
.CharsRead
;
2146 Request
->Data
.ReadConsoleOutputCharRequest
.ReadCoord
= Request
->Data
.ReadConsoleOutputCharRequest
.EndCoord
;
2149 if(lpNumberOfCharsRead
!= NULL
)
2151 *lpNumberOfCharsRead
= CharsRead
;
2154 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2160 /*--------------------------------------------------------------
2161 * ReadConsoleOutputCharacterA
2167 ReadConsoleOutputCharacterA(
2168 HANDLE hConsoleOutput
,
2172 LPDWORD lpNumberOfCharsRead
2175 return IntReadConsoleOutputCharacter(hConsoleOutput
,
2179 lpNumberOfCharsRead
,
2184 /*--------------------------------------------------------------
2185 * ReadConsoleOutputCharacterW
2191 ReadConsoleOutputCharacterW(
2192 HANDLE hConsoleOutput
,
2196 LPDWORD lpNumberOfCharsRead
2199 return IntReadConsoleOutputCharacter(hConsoleOutput
,
2203 lpNumberOfCharsRead
,
2208 /*--------------------------------------------------------------
2209 * ReadConsoleOutputAttribute
2215 ReadConsoleOutputAttribute(
2216 HANDLE hConsoleOutput
,
2220 LPDWORD lpNumberOfAttrsRead
2223 PCSR_API_MESSAGE Request
; ULONG CsrRequest
;
2227 if (lpNumberOfAttrsRead
!= NULL
)
2228 *lpNumberOfAttrsRead
= nLength
;
2230 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
2231 max(sizeof(CSR_API_MESSAGE
),
2232 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_ATTRIB
)
2233 + min (nLength
, CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB
/ sizeof(WORD
)) * sizeof(WORD
)));
2234 if (Request
== NULL
)
2236 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2240 CsrRequest
= MAKE_CSR_API(READ_CONSOLE_OUTPUT_ATTRIB
, CSR_CONSOLE
);
2242 while (nLength
!= 0)
2244 Request
->Data
.ReadConsoleOutputAttribRequest
.ConsoleHandle
= hConsoleOutput
;
2245 Request
->Data
.ReadConsoleOutputAttribRequest
.ReadCoord
= dwReadCoord
;
2247 if (nLength
> CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB
/ sizeof(WORD
))
2248 Size
= CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB
/ sizeof(WCHAR
);
2252 Request
->Data
.ReadConsoleOutputAttribRequest
.NumAttrsToRead
= Size
;
2254 Status
= CsrClientCallServer(Request
,
2257 max (sizeof(CSR_API_MESSAGE
),
2258 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_ATTRIB
) + Size
* sizeof(WORD
)));
2259 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Request
->Status
))
2261 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2262 SetLastErrorByStatus(Status
);
2266 memcpy(lpAttribute
, Request
->Data
.ReadConsoleOutputAttribRequest
.Attribute
, Size
* sizeof(WORD
));
2267 lpAttribute
+= Size
;
2269 Request
->Data
.ReadConsoleOutputAttribRequest
.ReadCoord
= Request
->Data
.ReadConsoleOutputAttribRequest
.EndCoord
;
2272 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2279 IntWriteConsoleOutputCharacter(HANDLE hConsoleOutput
,
2283 LPDWORD lpNumberOfCharsWritten
,
2286 PCSR_API_MESSAGE Request
; ULONG CsrRequest
;
2288 ULONG SizeBytes
, CharSize
, nChars
;
2291 CharSize
= (bUnicode
? sizeof(WCHAR
) : sizeof(CHAR
));
2293 nChars
= min(nLength
, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR
/ CharSize
);
2294 SizeBytes
= nChars
* CharSize
;
2296 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
2297 max (sizeof(CSR_API_MESSAGE
),
2298 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE_OUTPUT_CHAR
)
2299 + min (nChars
, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR
/ CharSize
) * CharSize
));
2300 if (Request
== NULL
)
2302 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2306 CsrRequest
= MAKE_CSR_API(WRITE_CONSOLE_OUTPUT_CHAR
, CSR_CONSOLE
);
2307 Request
->Data
.WriteConsoleOutputCharRequest
.Coord
= dwWriteCoord
;
2313 Request
->Data
.WriteConsoleOutputCharRequest
.ConsoleHandle
= hConsoleOutput
;
2314 Request
->Data
.WriteConsoleOutputCharRequest
.Unicode
= bUnicode
;
2315 Request
->Data
.WriteConsoleOutputCharRequest
.Length
= (WORD
)min(nLength
, nChars
);
2316 BytesWrite
= Request
->Data
.WriteConsoleOutputCharRequest
.Length
* CharSize
;
2318 memcpy(Request
->Data
.WriteConsoleOutputCharRequest
.String
, lpCharacter
, BytesWrite
);
2320 Status
= CsrClientCallServer(Request
,
2323 max (sizeof(CSR_API_MESSAGE
),
2324 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE_OUTPUT_CHAR
) + BytesWrite
));
2326 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
->Status
))
2328 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2329 SetLastErrorByStatus(Status
);
2333 nLength
-= Request
->Data
.WriteConsoleOutputCharRequest
.NrCharactersWritten
;
2334 lpCharacter
= (PVOID
)((ULONG_PTR
)lpCharacter
+ (ULONG_PTR
)(Request
->Data
.WriteConsoleOutputCharRequest
.NrCharactersWritten
* CharSize
));
2335 Written
+= Request
->Data
.WriteConsoleOutputCharRequest
.NrCharactersWritten
;
2337 Request
->Data
.WriteConsoleOutputCharRequest
.Coord
= Request
->Data
.WriteConsoleOutputCharRequest
.EndCoord
;
2340 if(lpNumberOfCharsWritten
!= NULL
)
2342 *lpNumberOfCharsWritten
= Written
;
2345 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2351 /*--------------------------------------------------------------
2352 * WriteConsoleOutputCharacterA
2357 WriteConsoleOutputCharacterA(HANDLE hConsoleOutput
,
2361 LPDWORD lpNumberOfCharsWritten
)
2363 return IntWriteConsoleOutputCharacter(hConsoleOutput
,
2367 lpNumberOfCharsWritten
,
2372 /*--------------------------------------------------------------
2373 * WriteConsoleOutputCharacterW
2378 WriteConsoleOutputCharacterW(HANDLE hConsoleOutput
,
2379 LPCWSTR lpCharacter
,
2382 LPDWORD lpNumberOfCharsWritten
)
2384 return IntWriteConsoleOutputCharacter(hConsoleOutput
,
2388 lpNumberOfCharsWritten
,
2393 /*--------------------------------------------------------------
2394 * WriteConsoleOutputAttribute
2400 WriteConsoleOutputAttribute(
2401 HANDLE hConsoleOutput
,
2402 CONST WORD
*lpAttribute
,
2405 LPDWORD lpNumberOfAttrsWritten
2408 PCSR_API_MESSAGE Request
; ULONG CsrRequest
;
2412 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
2413 max (sizeof(CSR_API_MESSAGE
),
2414 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB
)
2415 + min(nLength
, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB
/ sizeof(WORD
)) * sizeof(WORD
)));
2416 if (Request
== NULL
)
2418 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2422 CsrRequest
= MAKE_CSR_API(WRITE_CONSOLE_OUTPUT_ATTRIB
, CSR_CONSOLE
);
2423 Request
->Data
.WriteConsoleOutputAttribRequest
.Coord
= dwWriteCoord
;
2425 if( lpNumberOfAttrsWritten
)
2426 *lpNumberOfAttrsWritten
= nLength
;
2429 Size
= (WORD
)min(nLength
, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB
/ sizeof(WORD
));
2430 Request
->Data
.WriteConsoleOutputAttribRequest
.ConsoleHandle
= hConsoleOutput
;
2431 Request
->Data
.WriteConsoleOutputAttribRequest
.Length
= Size
;
2432 memcpy(Request
->Data
.WriteConsoleOutputAttribRequest
.Attribute
, lpAttribute
, Size
* sizeof(WORD
));
2434 Status
= CsrClientCallServer( Request
,
2437 max (sizeof(CSR_API_MESSAGE
),
2438 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB
) + Size
* sizeof(WORD
)));
2440 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
->Status
) )
2442 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2443 SetLastErrorByStatus ( Status
);
2447 lpAttribute
+= Size
;
2448 Request
->Data
.WriteConsoleOutputAttribRequest
.Coord
= Request
->Data
.WriteConsoleOutputAttribRequest
.EndCoord
;
2451 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2457 /*--------------------------------------------------------------
2458 * FillConsoleOutputAttribute
2464 FillConsoleOutputAttribute(
2465 HANDLE hConsoleOutput
,
2469 LPDWORD lpNumberOfAttrsWritten
2472 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2476 CsrRequest
= MAKE_CSR_API(FILL_OUTPUT_ATTRIB
, CSR_CONSOLE
);
2477 Request
.Data
.FillOutputAttribRequest
.ConsoleHandle
= hConsoleOutput
;
2478 Request
.Data
.FillOutputAttribRequest
.Attribute
= (CHAR
)wAttribute
;
2479 Request
.Data
.FillOutputAttribRequest
.Coord
= dwWriteCoord
;
2480 Request
.Data
.FillOutputAttribRequest
.Length
= (WORD
)nLength
;
2481 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
2482 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
2484 SetLastErrorByStatus ( Status
);
2487 if( lpNumberOfAttrsWritten
)
2488 *lpNumberOfAttrsWritten
= nLength
;
2493 /*--------------------------------------------------------------
2501 HANDLE hConsoleHandle
,
2505 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2509 CsrRequest
= MAKE_CSR_API(GET_CONSOLE_MODE
, CSR_CONSOLE
);
2510 Request
.Data
.GetConsoleModeRequest
.ConsoleHandle
= hConsoleHandle
;
2511 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
2512 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
2514 SetLastErrorByStatus ( Status
);
2517 *lpMode
= Request
.Data
.GetConsoleModeRequest
.ConsoleMode
;
2522 /*--------------------------------------------------------------
2523 * GetNumberOfConsoleInputEvents
2529 GetNumberOfConsoleInputEvents(
2530 HANDLE hConsoleInput
,
2531 LPDWORD lpNumberOfEvents
2534 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2538 if(lpNumberOfEvents
== NULL
)
2540 SetLastError(ERROR_INVALID_PARAMETER
);
2544 CsrRequest
= MAKE_CSR_API(GET_NUM_INPUT_EVENTS
, CSR_CONSOLE
);
2545 Request
.Data
.GetNumInputEventsRequest
.ConsoleHandle
= hConsoleInput
;
2546 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
2547 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
2549 SetLastErrorByStatus(Status
);
2553 *lpNumberOfEvents
= Request
.Data
.GetNumInputEventsRequest
.NumInputEvents
;
2559 /*--------------------------------------------------------------
2560 * GetLargestConsoleWindowSize
2566 GetLargestConsoleWindowSize(
2567 HANDLE hConsoleOutput
2570 COORD Coord
= {80,25};
2571 DPRINT1("GetLargestConsoleWindowSize(0x%x) UNIMPLEMENTED!\n", hConsoleOutput
);
2572 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2577 /*--------------------------------------------------------------
2578 * GetConsoleCursorInfo
2584 GetConsoleCursorInfo(
2585 HANDLE hConsoleOutput
,
2586 PCONSOLE_CURSOR_INFO lpConsoleCursorInfo
2589 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2593 CsrRequest
= MAKE_CSR_API(GET_CURSOR_INFO
, CSR_CONSOLE
);
2594 Request
.Data
.GetCursorInfoRequest
.ConsoleHandle
= hConsoleOutput
;
2595 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
2597 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
2599 SetLastErrorByStatus ( Status
);
2602 *lpConsoleCursorInfo
= Request
.Data
.GetCursorInfoRequest
.Info
;
2607 /*--------------------------------------------------------------
2608 * GetNumberOfConsoleMouseButtons
2614 GetNumberOfConsoleMouseButtons(
2615 LPDWORD lpNumberOfMouseButtons
2618 DPRINT1("GetNumberOfConsoleMouseButtons(0x%x) UNIMPLEMENTED!\n", lpNumberOfMouseButtons
);
2619 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2624 /*--------------------------------------------------------------
2632 HANDLE hConsoleHandle
,
2636 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2640 if (!IsConsoleHandle (hConsoleHandle
))
2642 DPRINT("SetConsoleMode was called with a non console handle\n");
2643 SetLastError (ERROR_INVALID_PARAMETER
);
2648 CsrRequest
= MAKE_CSR_API(SET_CONSOLE_MODE
, CSR_CONSOLE
);
2649 Request
.Data
.SetConsoleModeRequest
.ConsoleHandle
= hConsoleHandle
;
2650 Request
.Data
.SetConsoleModeRequest
.Mode
= dwMode
;
2651 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
2652 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
2654 SetLastErrorByStatus ( Status
);
2661 /*--------------------------------------------------------------
2662 * SetConsoleActiveScreenBuffer
2668 SetConsoleActiveScreenBuffer(
2669 HANDLE hConsoleOutput
2672 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2676 CsrRequest
= MAKE_CSR_API(SET_SCREEN_BUFFER
, CSR_CONSOLE
);
2677 Request
.Data
.SetScreenBufferRequest
.OutputHandle
= hConsoleOutput
;
2678 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
2679 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
2681 SetLastErrorByStatus ( Status
);
2688 /*--------------------------------------------------------------
2689 * FlushConsoleInputBuffer
2695 FlushConsoleInputBuffer(
2696 HANDLE hConsoleInput
2699 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2703 CsrRequest
= MAKE_CSR_API(FLUSH_INPUT_BUFFER
, CSR_CONSOLE
);
2704 Request
.Data
.FlushInputBufferRequest
.ConsoleInput
= hConsoleInput
;
2705 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
2706 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
2708 SetLastErrorByStatus ( Status
);
2715 /*--------------------------------------------------------------
2716 * SetConsoleScreenBufferSize
2722 SetConsoleScreenBufferSize(
2723 HANDLE hConsoleOutput
,
2727 DPRINT1("SetConsoleScreenBufferSize(0x%x, 0x%x) UNIMPLEMENTED!\n", hConsoleOutput
, dwSize
);
2728 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2732 /*--------------------------------------------------------------
2733 * SetConsoleCursorInfo
2739 SetConsoleCursorInfo(
2740 HANDLE hConsoleOutput
,
2741 CONST CONSOLE_CURSOR_INFO
*lpConsoleCursorInfo
2744 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2748 CsrRequest
= MAKE_CSR_API(SET_CURSOR_INFO
, CSR_CONSOLE
);
2749 Request
.Data
.SetCursorInfoRequest
.ConsoleHandle
= hConsoleOutput
;
2750 Request
.Data
.SetCursorInfoRequest
.Info
= *lpConsoleCursorInfo
;
2751 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
2753 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
2755 SetLastErrorByStatus ( Status
);
2763 IntScrollConsoleScreenBuffer(HANDLE hConsoleOutput
,
2764 const SMALL_RECT
*lpScrollRectangle
,
2765 const SMALL_RECT
*lpClipRectangle
,
2766 COORD dwDestinationOrigin
,
2767 const CHAR_INFO
*lpFill
,
2770 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2774 CsrRequest
= MAKE_CSR_API(SCROLL_CONSOLE_SCREEN_BUFFER
, CSR_CONSOLE
);
2775 Request
.Data
.ScrollConsoleScreenBufferRequest
.ConsoleHandle
= hConsoleOutput
;
2776 Request
.Data
.ScrollConsoleScreenBufferRequest
.Unicode
= bUnicode
;
2777 Request
.Data
.ScrollConsoleScreenBufferRequest
.ScrollRectangle
= *lpScrollRectangle
;
2779 if(lpClipRectangle
!= NULL
)
2781 Request
.Data
.ScrollConsoleScreenBufferRequest
.UseClipRectangle
= TRUE
;
2782 Request
.Data
.ScrollConsoleScreenBufferRequest
.ClipRectangle
= *lpClipRectangle
;
2786 Request
.Data
.ScrollConsoleScreenBufferRequest
.UseClipRectangle
= FALSE
;
2789 Request
.Data
.ScrollConsoleScreenBufferRequest
.DestinationOrigin
= dwDestinationOrigin
;
2790 Request
.Data
.ScrollConsoleScreenBufferRequest
.Fill
= *lpFill
;
2791 Status
= CsrClientCallServer(&Request
, NULL
,
2793 sizeof(CSR_API_MESSAGE
));
2795 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
2797 SetLastErrorByStatus(Status
);
2805 /*--------------------------------------------------------------
2806 * ScrollConsoleScreenBufferA
2812 ScrollConsoleScreenBufferA(
2813 HANDLE hConsoleOutput
,
2814 CONST SMALL_RECT
*lpScrollRectangle
,
2815 CONST SMALL_RECT
*lpClipRectangle
,
2816 COORD dwDestinationOrigin
,
2817 CONST CHAR_INFO
*lpFill
2820 return IntScrollConsoleScreenBuffer(hConsoleOutput
,
2821 (PSMALL_RECT
)lpScrollRectangle
,
2822 (PSMALL_RECT
)lpClipRectangle
,
2823 dwDestinationOrigin
,
2829 /*--------------------------------------------------------------
2830 * ScrollConsoleScreenBufferW
2836 ScrollConsoleScreenBufferW(
2837 HANDLE hConsoleOutput
,
2838 CONST SMALL_RECT
*lpScrollRectangle
,
2839 CONST SMALL_RECT
*lpClipRectangle
,
2840 COORD dwDestinationOrigin
,
2841 CONST CHAR_INFO
*lpFill
2844 return IntScrollConsoleScreenBuffer(hConsoleOutput
,
2847 dwDestinationOrigin
,
2853 /*--------------------------------------------------------------
2854 * SetConsoleWindowInfo
2860 SetConsoleWindowInfo(
2861 HANDLE hConsoleOutput
,
2863 CONST SMALL_RECT
*lpConsoleWindow
2866 DPRINT1("SetConsoleWindowInfo(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", hConsoleOutput
, bAbsolute
, lpConsoleWindow
);
2867 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2872 /*--------------------------------------------------------------
2873 * SetConsoleTextAttribute
2879 SetConsoleTextAttribute(
2880 HANDLE hConsoleOutput
,
2884 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2888 CsrRequest
= MAKE_CSR_API(SET_ATTRIB
, CSR_CONSOLE
);
2889 Request
.Data
.SetAttribRequest
.ConsoleHandle
= hConsoleOutput
;
2890 Request
.Data
.SetAttribRequest
.Attrib
= (CHAR
)wAttributes
;
2891 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
2892 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
2894 SetLastErrorByStatus ( Status
);
2902 AddConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine
)
2904 if (HandlerRoutine
== NULL
)
2906 IgnoreCtrlEvents
= TRUE
;
2912 if (CtrlHandlers
== NULL
)
2914 CtrlHandlers
= RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY
,
2915 NrCtrlHandlers
* sizeof(PHANDLER_ROUTINE
));
2919 CtrlHandlers
= RtlReAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY
,
2920 (PVOID
)CtrlHandlers
,
2921 NrCtrlHandlers
* sizeof(PHANDLER_ROUTINE
));
2923 if (CtrlHandlers
== NULL
)
2926 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2929 CtrlHandlers
[NrCtrlHandlers
- 1] = HandlerRoutine
;
2936 RemoveConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine
)
2940 if (HandlerRoutine
== NULL
)
2942 IgnoreCtrlEvents
= FALSE
;
2947 for (i
= 0; i
< NrCtrlHandlers
; i
++)
2949 if ( ((void*)(CtrlHandlers
[i
])) == (void*)HandlerRoutine
)
2952 memmove(CtrlHandlers
+ i
, CtrlHandlers
+ i
+ 1,
2953 (NrCtrlHandlers
- i
) * sizeof(PHANDLER_ROUTINE
));
2955 RtlReAllocateHeap(RtlGetProcessHeap(),
2957 (PVOID
)CtrlHandlers
,
2958 NrCtrlHandlers
* sizeof(PHANDLER_ROUTINE
));
2971 SetConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine
,
2976 RtlEnterCriticalSection(&DllLock
);
2979 Ret
= AddConsoleCtrlHandler(HandlerRoutine
);
2983 Ret
= RemoveConsoleCtrlHandler(HandlerRoutine
);
2985 RtlLeaveCriticalSection(&DllLock
);
2990 /*--------------------------------------------------------------
2991 * GenerateConsoleCtrlEvent
2996 GenerateConsoleCtrlEvent(
2998 DWORD dwProcessGroupId
3001 DPRINT1("GenerateConsoleCtrlEvent(0x%x, 0x%x) UNIMPLEMENTED!\n", dwCtrlEvent
, dwProcessGroupId
);
3002 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3007 /*--------------------------------------------------------------
3015 LPWSTR lpConsoleTitle
,
3019 PCSR_API_MESSAGE Request
; ULONG CsrRequest
;
3023 hConsole
= CreateFileW(L
"CONIN$", GENERIC_READ
, 0, NULL
, OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
3024 if (hConsole
== INVALID_HANDLE_VALUE
)
3029 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
3030 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_GET_TITLE
) + CSRSS_MAX_TITLE_LENGTH
* sizeof(WCHAR
));
3031 if (Request
== NULL
)
3033 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
3037 CsrRequest
= MAKE_CSR_API(GET_TITLE
, CSR_CONSOLE
);
3038 Request
->Data
.GetTitleRequest
.ConsoleHandle
= hConsole
;
3040 Status
= CsrClientCallServer(Request
,
3043 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_GET_TITLE
) + CSRSS_MAX_TITLE_LENGTH
* sizeof(WCHAR
));
3044 CloseHandle(hConsole
);
3045 if(!NT_SUCCESS(Status
) || !(NT_SUCCESS(Status
= Request
->Status
)))
3047 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
3048 SetLastErrorByStatus(Status
);
3052 if(nSize
* sizeof(WCHAR
) <= Request
->Data
.GetTitleRequest
.Length
)
3058 nSize
= Request
->Data
.GetTitleRequest
.Length
/ sizeof (WCHAR
);
3060 memcpy(lpConsoleTitle
, Request
->Data
.GetTitleRequest
.Title
, nSize
* sizeof(WCHAR
));
3061 lpConsoleTitle
[nSize
] = L
'\0';
3063 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
3069 /*--------------------------------------------------------------
3079 LPSTR lpConsoleTitle
,
3083 WCHAR WideTitle
[CSRSS_MAX_TITLE_LENGTH
+ 1];
3084 DWORD nWideTitle
= CSRSS_MAX_TITLE_LENGTH
+ 1;
3087 if (!lpConsoleTitle
|| !nSize
) return 0;
3088 nWideTitle
= GetConsoleTitleW( (LPWSTR
) WideTitle
, nWideTitle
);
3089 if (!nWideTitle
) return 0;
3091 if ( (nWritten
= WideCharToMultiByte(
3092 CP_ACP
, // ANSI code page
3093 0, // performance and mapping flags
3094 (LPWSTR
) WideTitle
, // address of wide-character string
3095 nWideTitle
, // number of characters in string
3096 lpConsoleTitle
, // address of buffer for new string
3097 nSize
- 1, // size of buffer
3102 lpConsoleTitle
[nWritten
] = '\0';
3110 /*--------------------------------------------------------------
3118 LPCWSTR lpConsoleTitle
3121 PCSR_API_MESSAGE Request
; ULONG CsrRequest
;
3126 hConsole
= CreateFileW(L
"CONIN$", GENERIC_WRITE
, 0, NULL
, OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
3127 if (hConsole
== INVALID_HANDLE_VALUE
)
3132 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
3133 max (sizeof(CSR_API_MESSAGE
),
3134 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_SET_TITLE
) +
3135 min (wcslen(lpConsoleTitle
), CSRSS_MAX_TITLE_LENGTH
) * sizeof(WCHAR
)));
3136 if (Request
== NULL
)
3138 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
3142 CsrRequest
= MAKE_CSR_API(SET_TITLE
, CSR_CONSOLE
);
3143 Request
->Data
.SetTitleRequest
.Console
= hConsole
;
3145 for( c
= 0; lpConsoleTitle
[c
] && c
< CSRSS_MAX_TITLE_LENGTH
; c
++ )
3146 Request
->Data
.SetTitleRequest
.Title
[c
] = lpConsoleTitle
[c
];
3147 Request
->Data
.SetTitleRequest
.Length
= c
* sizeof(WCHAR
);
3148 Status
= CsrClientCallServer(Request
,
3151 max (sizeof(CSR_API_MESSAGE
), CSR_API_MESSAGE_HEADER_SIZE(CSRSS_SET_TITLE
) + c
* sizeof(WCHAR
)));
3152 CloseHandle(hConsole
);
3153 if (!NT_SUCCESS(Status
) || !NT_SUCCESS( Status
= Request
->Status
) )
3155 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
3156 SetLastErrorByStatus (Status
);
3160 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
3166 /*--------------------------------------------------------------
3176 LPCSTR lpConsoleTitle
3179 PCSR_API_MESSAGE Request
; ULONG CsrRequest
;
3184 hConsole
= CreateFileW(L
"CONIN$", GENERIC_WRITE
, 0, NULL
, OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
3185 if (hConsole
== INVALID_HANDLE_VALUE
)
3190 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
3191 max (sizeof(CSR_API_MESSAGE
),
3192 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_SET_TITLE
) +
3193 min (strlen(lpConsoleTitle
), CSRSS_MAX_TITLE_LENGTH
) * sizeof(WCHAR
)));
3194 if (Request
== NULL
)
3196 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
3200 CsrRequest
= MAKE_CSR_API(SET_TITLE
, CSR_CONSOLE
);
3201 Request
->Data
.SetTitleRequest
.Console
= hConsole
;
3203 for( c
= 0; lpConsoleTitle
[c
] && c
< CSRSS_MAX_TITLE_LENGTH
; c
++ )
3204 Request
->Data
.SetTitleRequest
.Title
[c
] = lpConsoleTitle
[c
];
3205 Request
->Data
.SetTitleRequest
.Length
= c
* sizeof(WCHAR
);
3206 Status
= CsrClientCallServer(Request
,
3209 max (sizeof(CSR_API_MESSAGE
), CSR_API_MESSAGE_HEADER_SIZE(CSRSS_SET_TITLE
) + c
* sizeof(WCHAR
)));
3210 CloseHandle(hConsole
);
3211 if (!NT_SUCCESS(Status
) || !NT_SUCCESS( Status
= Request
->Status
) )
3213 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
3214 SetLastErrorByStatus (Status
);
3218 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
3224 /*--------------------------------------------------------------
3225 * CreateConsoleScreenBuffer
3231 CreateConsoleScreenBuffer(
3232 DWORD dwDesiredAccess
,
3234 CONST SECURITY_ATTRIBUTES
*lpSecurityAttributes
,
3236 LPVOID lpScreenBufferData
3239 // FIXME: don't ignore access, share mode, and security
3240 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
3244 CsrRequest
= MAKE_CSR_API(CREATE_SCREEN_BUFFER
, CSR_CONSOLE
);
3245 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
3246 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
3248 SetLastErrorByStatus ( Status
);
3251 return Request
.Data
.CreateScreenBufferRequest
.OutputHandle
;
3255 /*--------------------------------------------------------------
3262 GetConsoleCP( VOID
)
3264 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
3268 CsrRequest
= MAKE_CSR_API(GET_CONSOLE_CP
, CSR_CONSOLE
);
3269 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
,
3270 sizeof(CSR_API_MESSAGE
));
3271 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3273 SetLastErrorByStatus (Status
);
3276 return Request
.Data
.GetConsoleCodePage
.CodePage
;
3280 /*--------------------------------------------------------------
3291 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
3295 CsrRequest
= MAKE_CSR_API(SET_CONSOLE_CP
, CSR_CONSOLE
);
3296 Request
.Data
.SetConsoleCodePage
.CodePage
= wCodePageID
;
3297 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
,
3298 sizeof(CSR_API_MESSAGE
));
3299 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3301 SetLastErrorByStatus (Status
);
3303 return NT_SUCCESS(Status
);
3307 /*--------------------------------------------------------------
3308 * GetConsoleOutputCP
3314 GetConsoleOutputCP( VOID
)
3316 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
3320 CsrRequest
= MAKE_CSR_API(GET_CONSOLE_OUTPUT_CP
, CSR_CONSOLE
);
3321 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
,
3322 sizeof(CSR_API_MESSAGE
));
3323 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3325 SetLastErrorByStatus (Status
);
3328 return Request
.Data
.GetConsoleOutputCodePage
.CodePage
;
3332 /*--------------------------------------------------------------
3333 * SetConsoleOutputCP
3343 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
3347 CsrRequest
= MAKE_CSR_API(SET_CONSOLE_OUTPUT_CP
, CSR_CONSOLE
);
3348 Request
.Data
.SetConsoleOutputCodePage
.CodePage
= wCodePageID
;
3349 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
,
3350 sizeof(CSR_API_MESSAGE
));
3351 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3353 SetLastErrorByStatus (Status
);
3355 return NT_SUCCESS(Status
);
3359 /*--------------------------------------------------------------
3360 * GetConsoleProcessList
3365 GetConsoleProcessList(LPDWORD lpdwProcessList
,
3366 DWORD dwProcessCount
)
3368 PCSR_API_MESSAGE Request
; ULONG CsrRequest
;
3372 if(lpdwProcessList
== NULL
|| dwProcessCount
== 0)
3374 SetLastError(ERROR_INVALID_PARAMETER
);
3378 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
3379 max (sizeof(CSR_API_MESSAGE
),
3380 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_GET_PROCESS_LIST
)
3381 + min (dwProcessCount
, CSRSS_MAX_GET_PROCESS_LIST
/ sizeof(DWORD
)) * sizeof(DWORD
)));
3382 if (Request
== NULL
)
3384 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
3388 CsrRequest
= MAKE_CSR_API(GET_PROCESS_LIST
, CSR_CONSOLE
);
3389 Request
->Data
.GetProcessListRequest
.nMaxIds
= min (dwProcessCount
, CSRSS_MAX_GET_PROCESS_LIST
/ sizeof(DWORD
));
3391 Status
= CsrClientCallServer(Request
,
3394 max (sizeof(CSR_API_MESSAGE
),
3395 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_GET_PROCESS_LIST
)
3396 + Request
->Data
.GetProcessListRequest
.nMaxIds
* sizeof(DWORD
)));
3397 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
->Status
))
3399 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
3400 SetLastErrorByStatus (Status
);
3405 nProcesses
= Request
->Data
.GetProcessListRequest
.nProcessIdsCopied
;
3406 if(dwProcessCount
>= nProcesses
)
3408 memcpy(lpdwProcessList
, Request
->Data
.GetProcessListRequest
.ProcessId
, nProcesses
* sizeof(DWORD
));
3412 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
3419 /*--------------------------------------------------------------
3420 * GetConsoleSelectionInfo
3425 GetConsoleSelectionInfo(PCONSOLE_SELECTION_INFO lpConsoleSelectionInfo
)
3427 DPRINT1("GetConsoleSelectionInfo(0x%x) UNIMPLEMENTED!\n", lpConsoleSelectionInfo
);
3428 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3434 /*--------------------------------------------------------------
3440 AttachConsole(DWORD dwProcessId
)
3442 DPRINT1("AttachConsole(0x%x) UNIMPLEMENTED!\n", dwProcessId
);
3443 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3447 /*--------------------------------------------------------------
3453 GetConsoleWindow (VOID
)
3455 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
3459 CsrRequest
= MAKE_CSR_API(GET_CONSOLE_WINDOW
, CSR_CONSOLE
);
3460 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
3461 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3463 SetLastErrorByStatus (Status
);
3466 return Request
.Data
.GetConsoleWindowRequest
.WindowHandle
;
3470 /*--------------------------------------------------------------
3475 BOOL STDCALL
SetConsoleIcon(HICON hicon
)
3477 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
3481 CsrRequest
= MAKE_CSR_API(SET_CONSOLE_ICON
, CSR_CONSOLE
);
3482 Request
.Data
.SetConsoleIconRequest
.WindowIcon
= hicon
;
3483 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
3484 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3486 SetLastErrorByStatus (Status
);
3489 return NT_SUCCESS(Status
);
3493 /*--------------------------------------------------------------
3494 * SetConsoleInputExeNameW
3499 SetConsoleInputExeNameW(LPCWSTR lpInputExeName
)
3502 int lenName
= lstrlenW(lpInputExeName
);
3505 lenName
> (int)(sizeof(InputExeName
) / sizeof(InputExeName
[0])) - 1)
3507 /* Fail if string is empty or too long */
3508 SetLastError(ERROR_INVALID_PARAMETER
);
3512 RtlEnterCriticalSection(&ConsoleLock
);
3513 /* wrap copying into SEH as we may copy from invalid buffer and in case of an
3514 exception the console lock would've never been released, which would cause
3515 further calls (if the exception was handled by the caller) to recursively
3516 acquire the lock... */
3519 RtlCopyMemory(InputExeName
, lpInputExeName
, lenName
* sizeof(WCHAR
));
3520 InputExeName
[lenName
] = L
'\0';
3526 SetLastErrorByStatus(_SEH_GetExceptionCode());
3529 RtlLeaveCriticalSection(&ConsoleLock
);
3535 /*--------------------------------------------------------------
3536 * SetConsoleInputExeNameA
3541 SetConsoleInputExeNameA(LPCSTR lpInputExeName
)
3543 ANSI_STRING InputExeNameA
;
3544 UNICODE_STRING InputExeNameU
;
3548 RtlInitAnsiString(&InputExeNameA
, lpInputExeName
);
3550 if(InputExeNameA
.Length
< sizeof(InputExeNameA
.Buffer
[0]) ||
3551 InputExeNameA
.Length
>= (sizeof(InputExeName
) / sizeof(InputExeName
[0])) - 1)
3553 /* Fail if string is empty or too long */
3554 SetLastError(ERROR_INVALID_PARAMETER
);
3558 Status
= RtlAnsiStringToUnicodeString(&InputExeNameU
, &InputExeNameA
, TRUE
);
3559 if(NT_SUCCESS(Status
))
3561 Ret
= SetConsoleInputExeNameW(InputExeNameU
.Buffer
);
3562 RtlFreeUnicodeString(&InputExeNameU
);
3566 SetLastErrorByStatus(Status
);
3574 /*--------------------------------------------------------------
3575 * GetConsoleInputExeNameW
3580 GetConsoleInputExeNameW(DWORD nBufferLength
, LPWSTR lpBuffer
)
3584 RtlEnterCriticalSection(&ConsoleLock
);
3586 lenName
= lstrlenW(InputExeName
);
3587 if(lenName
>= (int)nBufferLength
)
3589 /* buffer is not large enough, return the required size */
3590 RtlLeaveCriticalSection(&ConsoleLock
);
3594 /* wrap copying into SEH as we may copy to invalid buffer and in case of an
3595 exception the console lock would've never been released, which would cause
3596 further calls (if the exception was handled by the caller) to recursively
3597 acquire the lock... */
3600 RtlCopyMemory(lpBuffer
, InputExeName
, (lenName
+ 1) * sizeof(WCHAR
));
3605 SetLastErrorByStatus(_SEH_GetExceptionCode());
3609 RtlLeaveCriticalSection(&ConsoleLock
);
3615 /*--------------------------------------------------------------
3616 * GetConsoleInputExeNameA
3621 GetConsoleInputExeNameA(DWORD nBufferLength
, LPSTR lpBuffer
)
3626 if(nBufferLength
> 0)
3628 Buffer
= RtlAllocateHeap(RtlGetProcessHeap(), 0, nBufferLength
* sizeof(WCHAR
));
3631 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
3640 Ret
= GetConsoleInputExeNameW(nBufferLength
, Buffer
);
3641 if(nBufferLength
> 0)
3645 UNICODE_STRING BufferU
;
3646 ANSI_STRING BufferA
;
3648 RtlInitUnicodeString(&BufferU
, Buffer
);
3651 BufferA
.MaximumLength
= (USHORT
)nBufferLength
;
3652 BufferA
.Buffer
= lpBuffer
;
3654 RtlUnicodeStringToAnsiString(&BufferA
, &BufferU
, FALSE
);
3657 RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer
);
3664 /*--------------------------------------------------------------
3665 * GetConsoleHistoryInfo
3670 GetConsoleHistoryInfo(PCONSOLE_HISTORY_INFO lpConsoleHistoryInfo
)
3672 DPRINT1("GetConsoleHistoryInfo(0x%p) UNIMPLEMENTED!\n", lpConsoleHistoryInfo
);
3673 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3678 /*--------------------------------------------------------------
3679 * SetConsoleHistoryInfo
3684 SetConsoleHistoryInfo(IN PCONSOLE_HISTORY_INFO lpConsoleHistoryInfo
)
3686 DPRINT1("SetConsoleHistoryInfo(0x%p) UNIMPLEMENTED!\n", lpConsoleHistoryInfo
);
3687 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3692 /*--------------------------------------------------------------
3693 * GetConsoleOriginalTitleW
3698 GetConsoleOriginalTitleW(OUT LPWSTR lpConsoleTitle
,
3701 DPRINT1("GetConsoleOriginalTitleW(0x%p, 0x%x) UNIMPLEMENTED!\n", lpConsoleTitle
, nSize
);
3702 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3707 /*--------------------------------------------------------------
3708 * GetConsoleOriginalTitleA
3713 GetConsoleOriginalTitleA(OUT LPSTR lpConsoleTitle
,
3716 DPRINT1("GetConsoleOriginalTitleA(0x%p, 0x%x) UNIMPLEMENTED!\n", lpConsoleTitle
, nSize
);
3717 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3722 /*--------------------------------------------------------------
3723 * GetConsoleScreenBufferInfoEx
3728 GetConsoleScreenBufferInfoEx(IN HANDLE hConsoleOutput
,
3729 OUT PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx
)
3731 DPRINT1("GetConsoleScreenBufferInfoEx(0x%p, 0x%p) UNIMPLEMENTED!\n", hConsoleOutput
, lpConsoleScreenBufferInfoEx
);
3732 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3737 /*--------------------------------------------------------------
3738 * SetConsoleScreenBufferInfoEx
3743 SetConsoleScreenBufferInfoEx(IN HANDLE hConsoleOutput
,
3744 IN PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx
)
3746 DPRINT1("SetConsoleScreenBufferInfoEx(0x%p, 0x%p) UNIMPLEMENTED!\n", hConsoleOutput
, lpConsoleScreenBufferInfoEx
);
3747 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3752 /*--------------------------------------------------------------
3753 * GetCurrentConsoleFontEx
3758 GetCurrentConsoleFontEx(IN HANDLE hConsoleOutput
,
3759 IN BOOL bMaximumWindow
,
3760 OUT PCONSOLE_FONT_INFOEX lpConsoleCurrentFontEx
)
3762 DPRINT1("GetCurrentConsoleFontEx(0x%p, 0x%x, 0x%p) UNIMPLEMENTED!\n", hConsoleOutput
, bMaximumWindow
, lpConsoleCurrentFontEx
);
3763 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);