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 ******************************************************************/
17 /* File contains Vista Semantics */
19 #define _WIN32_WINNT 0x0600
24 #include "../include/debug.h"
26 extern BOOL WINAPI
DefaultConsoleCtrlHandler(DWORD Event
);
27 extern __declspec(noreturn
) VOID CALLBACK
ConsoleControlDispatcher(DWORD CodeAndFlag
);
28 extern RTL_CRITICAL_SECTION ConsoleLock
;
29 extern BOOL WINAPI
IsDebuggerPresent(VOID
);
32 /* GLOBALS *******************************************************************/
34 static BOOL IgnoreCtrlEvents
= FALSE
;
36 static PHANDLER_ROUTINE
* CtrlHandlers
= NULL
;
37 static ULONG NrCtrlHandlers
= 0;
38 static WCHAR InputExeName
[MAX_PATH
+ 1] = L
"";
40 /* Default Console Control Handler *******************************************/
42 BOOL WINAPI
DefaultConsoleCtrlHandler(DWORD Event
)
47 DPRINT("Ctrl-C Event\n");
50 case CTRL_BREAK_EVENT
:
51 DPRINT("Ctrl-Break Event\n");
54 case CTRL_SHUTDOWN_EVENT
:
55 DPRINT("Ctrl Shutdown Event\n");
58 case CTRL_CLOSE_EVENT
:
59 DPRINT("Ctrl Close Event\n");
62 case CTRL_LOGOFF_EVENT
:
63 DPRINT("Ctrl Logoff Event\n");
71 __declspec(noreturn
) VOID CALLBACK
ConsoleControlDispatcher(DWORD CodeAndFlag
)
74 DWORD nCode
= CodeAndFlag
& MAXLONG
;
77 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST
);
82 case CTRL_BREAK_EVENT
:
84 if(IsDebuggerPresent())
86 EXCEPTION_RECORD erException
;
87 erException
.ExceptionCode
=
88 (nCode
== CTRL_C_EVENT
? DBG_CONTROL_C
: DBG_CONTROL_BREAK
);
89 erException
.ExceptionFlags
= 0;
90 erException
.ExceptionRecord
= NULL
;
91 erException
.ExceptionAddress
= &DefaultConsoleCtrlHandler
;
92 erException
.NumberParameters
= 0;
93 RtlRaiseException(&erException
);
95 RtlEnterCriticalSection(&ConsoleLock
);
97 if(!(nCode
== CTRL_C_EVENT
&&
98 NtCurrentPeb()->ProcessParameters
->ConsoleFlags
& 1))
100 for(i
= NrCtrlHandlers
; i
> 0; -- i
)
101 if(CtrlHandlers
[i
- 1](nCode
)) break;
103 RtlLeaveCriticalSection(&ConsoleLock
);
106 case CTRL_CLOSE_EVENT
:
107 case CTRL_LOGOFF_EVENT
:
108 case CTRL_SHUTDOWN_EVENT
:
111 default: ExitThread(0);
114 RtlEnterCriticalSection(&ConsoleLock
);
116 if(!(nCode
== CTRL_C_EVENT
&&
117 NtCurrentPeb()->ProcessParameters
->ConsoleFlags
& 1))
122 if (i
== 1 && (CodeAndFlag
& MINLONG
) &&
123 (nCode
== CTRL_LOGOFF_EVENT
|| nCode
== CTRL_SHUTDOWN_EVENT
))
126 if(CtrlHandlers
[i
- 1](nCode
))
130 case CTRL_CLOSE_EVENT
:
131 case CTRL_LOGOFF_EVENT
:
132 case CTRL_SHUTDOWN_EVENT
:
133 nExitCode
= CodeAndFlag
;
140 RtlLeaveCriticalSection(&ConsoleLock
);
141 ExitThread(nExitCode
);
145 /* FUNCTIONS *****************************************************************/
151 AddConsoleAliasA (LPSTR Source
,
155 DPRINT1("AddConsoleAliasA(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Source
, Target
, ExeName
);
156 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
165 AddConsoleAliasW (LPWSTR Source
,
169 DPRINT1("AddConsoleAliasW(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Source
, Target
, ExeName
);
170 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
179 ConsoleMenuControl (HANDLE hConsole
,
186 DPRINT1("ConsoleMenuControl(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", hConsole
, Unknown1
, Unknown2
);
187 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
196 DuplicateConsoleHandle (HANDLE hConsole
,
197 DWORD dwDesiredAccess
,
201 CSR_API_MESSAGE Request
;
205 if (IsConsoleHandle (hConsole
) == FALSE
)
207 SetLastError (ERROR_INVALID_PARAMETER
);
208 return INVALID_HANDLE_VALUE
;
211 CsrRequest
= MAKE_CSR_API(DUPLICATE_HANDLE
, CSR_NATIVE
);
212 Request
.Data
.DuplicateHandleRequest
.Handle
= hConsole
;
213 Request
.Data
.DuplicateHandleRequest
.ProcessId
= GetTeb()->Cid
.UniqueProcess
;
214 Status
= CsrClientCallServer(&Request
,
217 sizeof(CSR_API_MESSAGE
));
218 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
=Request
.Status
))
220 SetLastErrorByStatus(Status
);
221 return INVALID_HANDLE_VALUE
;
223 return Request
.Data
.DuplicateHandleRequest
.Handle
;
231 ExpungeConsoleCommandHistoryW (DWORD Unknown0
)
236 DPRINT1("ExpungeConsoleCommandHistoryW(0x%x) UNIMPLEMENTED!\n", Unknown0
);
237 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
246 ExpungeConsoleCommandHistoryA (DWORD Unknown0
)
252 DPRINT1("ExpungeConsoleCommandHistoryW(0x%x) UNIMPLEMENTED!\n", Unknown0
);
253 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
262 GetConsoleAliasW (LPWSTR lpSource
,
263 LPWSTR lpTargetBuffer
,
264 DWORD TargetBufferLength
,
270 DPRINT1("GetConsoleAliasW(0x%p, 0x%p, 0x%x, 0x%p) UNIMPLEMENTED!\n", lpSource
, lpTargetBuffer
, TargetBufferLength
, lpExeName
);
271 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
280 GetConsoleAliasA (LPSTR lpSource
,
281 LPSTR lpTargetBuffer
,
282 DWORD TargetBufferLength
,
288 DPRINT1("GetConsoleAliasA(0x%p, 0x%p, 0x%x, 0x%p) UNIMPLEMENTED!\n", lpSource
, lpTargetBuffer
, TargetBufferLength
, lpExeName
);
289 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
298 GetConsoleAliasExesW (LPWSTR lpExeNameBuffer
,
299 DWORD ExeNameBufferLength
)
304 DPRINT1("GetConsoleAliasExesW(0x%p, 0x%x) UNIMPLEMENTED!\n", lpExeNameBuffer
, ExeNameBufferLength
);
305 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
314 GetConsoleAliasExesA (LPSTR lpExeNameBuffer
,
315 DWORD ExeNameBufferLength
)
320 DPRINT1("GetConsoleAliasExesA(0x%p, 0x%x) UNIMPLEMENTED!\n", lpExeNameBuffer
, ExeNameBufferLength
);
321 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
330 GetConsoleAliasExesLengthA (VOID
)
335 DPRINT1("GetConsoleAliasExesLengthA() UNIMPLEMENTED!\n");
336 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
345 GetConsoleAliasExesLengthW (VOID
)
350 DPRINT1("GetConsoleAliasExesLengthW() UNIMPLEMENTED!\n");
351 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
360 GetConsoleAliasesW (DWORD Unknown0
,
367 DPRINT1("GetConsoleAliasesW(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
);
368 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
377 GetConsoleAliasesA (DWORD Unknown0
,
384 DPRINT1("GetConsoleAliasesA(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
);
385 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
394 GetConsoleAliasesLengthW (LPWSTR lpExeName
)
399 DPRINT1("GetConsoleAliasesLengthW(0x%p) UNIMPLEMENTED!\n", lpExeName
);
400 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
409 GetConsoleAliasesLengthA (LPSTR lpExeName
)
414 DPRINT1("GetConsoleAliasesLengthA(0x%p) UNIMPLEMENTED!\n", lpExeName
);
415 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
424 GetConsoleCommandHistoryW (DWORD Unknown0
,
431 DPRINT1("GetConsoleCommandHistoryW(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
);
432 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
441 GetConsoleCommandHistoryA (DWORD Unknown0
,
448 DPRINT1("GetConsoleCommandHistoryA(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
);
449 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
458 GetConsoleCommandHistoryLengthW (DWORD Unknown0
)
463 DPRINT1("GetConsoleCommandHistoryLengthW(0x%x) UNIMPLEMENTED!\n", Unknown0
);
464 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
473 GetConsoleCommandHistoryLengthA (DWORD Unknown0
)
478 DPRINT1("GetConsoleCommandHistoryLengthA(0x%x) UNIMPLEMENTED!\n", Unknown0
);
479 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
487 GetConsoleDisplayMode (LPDWORD lpdwMode
)
489 * FUNCTION: Get the console display mode
491 * lpdwMode - Address of variable that receives the current value
493 * STATUS: Undocumented
496 DPRINT1("GetConsoleDisplayMode(0x%x) UNIMPLEMENTED!\n", lpdwMode
);
497 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
506 GetConsoleFontInfo (DWORD Unknown0
,
514 DPRINT1("GetConsoleFontInfo(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
, Unknown3
);
515 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
524 GetConsoleFontSize(HANDLE hConsoleOutput
,
527 COORD Empty
= {0, 0};
528 DPRINT1("GetConsoleFontSize(0x%x, 0x%x) UNIMPLEMENTED!\n", hConsoleOutput
, nFont
);
529 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
538 GetConsoleHardwareState (HANDLE hConsole
,
545 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
549 CsrRequest
= MAKE_CSR_API(SETGET_CONSOLE_HW_STATE
, CSR_CONSOLE
);
550 Request
.Data
.ConsoleHardwareStateRequest
.ConsoleHandle
= hConsole
;
551 Request
.Data
.ConsoleHardwareStateRequest
.SetGet
= CONSOLE_HARDWARE_STATE_GET
;
553 Status
= CsrClientCallServer(& Request
,
556 sizeof(CSR_API_MESSAGE
));
557 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
559 SetLastErrorByStatus(Status
);
562 *State
= Request
.Data
.ConsoleHardwareStateRequest
.State
;
571 GetConsoleInputWaitHandle (VOID
)
576 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
580 CsrRequest
= MAKE_CSR_API(GET_INPUT_WAIT_HANDLE
, CSR_CONSOLE
);
581 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
,
582 sizeof(CSR_API_MESSAGE
));
583 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
585 SetLastErrorByStatus(Status
);
588 return (DWORD
) Request
.Data
.GetConsoleInputWaitHandle
.InputWaitHandle
;
596 GetCurrentConsoleFont(HANDLE hConsoleOutput
,
598 PCONSOLE_FONT_INFO lpConsoleCurrentFont
)
600 DPRINT1("GetCurrentConsoleFont(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", hConsoleOutput
, bMaximumWindow
, lpConsoleCurrentFont
);
601 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
610 GetNumberOfConsoleFonts (VOID
)
615 DPRINT1("GetNumberOfConsoleFonts() UNIMPLEMENTED!\n");
616 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
617 return 1; /* FIXME: call csrss.exe */
625 InvalidateConsoleDIBits (DWORD Unknown0
,
631 DPRINT1("InvalidateConsoleDIBits(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
);
632 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
641 OpenConsoleW (LPWSTR wsName
,
642 DWORD dwDesiredAccess
,
644 DWORD dwCreationDistribution
)
649 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
651 PHANDLE phConsole
= NULL
;
652 NTSTATUS Status
= STATUS_SUCCESS
;
654 if(0 == _wcsicmp(wsName
, L
"CONIN$"))
656 CsrRequest
= MAKE_CSR_API(GET_INPUT_HANDLE
, CSR_NATIVE
);
657 phConsole
= & Request
.Data
.GetInputHandleRequest
.InputHandle
;
659 else if (0 == _wcsicmp(wsName
, L
"CONOUT$"))
661 CsrRequest
= MAKE_CSR_API(GET_OUTPUT_HANDLE
, CSR_NATIVE
);
662 phConsole
= & Request
.Data
.GetOutputHandleRequest
.OutputHandle
;
666 SetLastError(ERROR_INVALID_PARAMETER
);
667 return(INVALID_HANDLE_VALUE
);
669 if ((GENERIC_READ
|GENERIC_WRITE
) != dwDesiredAccess
)
671 SetLastError(ERROR_INVALID_PARAMETER
);
672 return(INVALID_HANDLE_VALUE
);
674 if (OPEN_EXISTING
!= dwCreationDistribution
)
676 SetLastError(ERROR_INVALID_PARAMETER
);
677 return(INVALID_HANDLE_VALUE
);
679 Status
= CsrClientCallServer(& Request
,
682 sizeof(CSR_API_MESSAGE
));
683 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
685 SetLastErrorByStatus(Status
);
686 return INVALID_HANDLE_VALUE
;
696 SetConsoleCommandHistoryMode (DWORD dwMode
)
701 DPRINT1("SetConsoleCommandHistoryMode(0x%x) UNIMPLEMENTED!\n", dwMode
);
702 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
711 SetConsoleCursor (DWORD Unknown0
,
717 DPRINT1("SetConsoleCursor(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
);
718 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
727 SetConsoleDisplayMode (HANDLE hOut
,
731 * FUNCTION: Set the console display mode.
733 * hOut - Standard output handle.
734 * dwNewMode - New mode.
735 * lpdwOldMode - Address of a variable that receives the old mode.
738 DPRINT1("SetConsoleDisplayMode(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", hOut
, dwNewMode
, lpdwOldMode
);
739 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
748 SetConsoleFont (DWORD Unknown0
,
754 DPRINT1("SetConsoleFont(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
);
755 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
764 SetConsoleHardwareState (HANDLE hConsole
,
771 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
775 CsrRequest
= MAKE_CSR_API(SETGET_CONSOLE_HW_STATE
, CSR_CONSOLE
);
776 Request
.Data
.ConsoleHardwareStateRequest
.ConsoleHandle
= hConsole
;
777 Request
.Data
.ConsoleHardwareStateRequest
.SetGet
= CONSOLE_HARDWARE_STATE_SET
;
778 Request
.Data
.ConsoleHardwareStateRequest
.State
= State
;
780 Status
= CsrClientCallServer(& Request
,
783 sizeof(CSR_API_MESSAGE
));
784 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
786 SetLastErrorByStatus(Status
);
797 SetConsoleKeyShortcuts (DWORD Unknown0
,
805 DPRINT1("SetConsoleKeyShortcuts(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
, Unknown3
);
806 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
815 SetConsoleMaximumWindowSize (DWORD Unknown0
,
821 DPRINT1("SetConsoleMaximumWindowSize(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
);
822 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
831 SetConsoleMenuClose (DWORD Unknown0
)
836 DPRINT1("SetConsoleMenuClose(0x%x) UNIMPLEMENTED!\n", Unknown0
);
837 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
846 SetConsoleNumberOfCommandsA (DWORD Unknown0
,
852 DPRINT1("SetConsoleNumberOfCommandsA(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
);
853 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
862 SetConsoleNumberOfCommandsW (DWORD Unknown0
,
868 DPRINT1("SetConsoleNumberOfCommandsW(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
);
869 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
878 SetConsolePalette (DWORD Unknown0
,
885 DPRINT1("SetConsolePalette(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
);
886 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
895 SetLastConsoleEventActive (VOID
)
900 DPRINT1("SetLastConsoleEventActive() UNIMPLEMENTED!\n");
901 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
910 ShowConsoleCursor (DWORD Unknown0
,
916 DPRINT1("ShowConsoleCursor(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
);
917 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
923 * FUNCTION: Checks whether the given handle is a valid console handle.
925 * Handle - Handle to be checked
927 * TRUE: Handle is a valid console handle
928 * FALSE: Handle is not a valid console handle.
929 * STATUS: Officially undocumented
934 VerifyConsoleIoHandle(HANDLE Handle
)
936 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
940 CsrRequest
= MAKE_CSR_API(VERIFY_HANDLE
, CSR_NATIVE
);
941 Request
.Data
.VerifyHandleRequest
.Handle
= Handle
;
942 Status
= CsrClientCallServer(&Request
,
945 sizeof(CSR_API_MESSAGE
));
946 if (!NT_SUCCESS(Status
))
948 SetLastErrorByStatus(Status
);
952 return (BOOL
)NT_SUCCESS(Request
.Status
);
960 WriteConsoleInputVDMA (DWORD Unknown0
,
965 DPRINT1("WriteConsoleInputVDMA(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
, Unknown3
);
966 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
975 WriteConsoleInputVDMW (DWORD Unknown0
,
980 DPRINT1("WriteConsoleInputVDMW(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
, Unknown3
);
981 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
990 CloseConsoleHandle(HANDLE Handle
)
995 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
999 if (IsConsoleHandle (Handle
) == FALSE
)
1001 SetLastError (ERROR_INVALID_PARAMETER
);
1005 CsrRequest
= MAKE_CSR_API(CLOSE_HANDLE
, CSR_NATIVE
);
1006 Request
.Data
.CloseHandleRequest
.Handle
= Handle
;
1007 Status
= CsrClientCallServer(&Request
,
1010 sizeof(CSR_API_MESSAGE
));
1011 if (!NT_SUCCESS(Status
))
1013 SetLastErrorByStatus(Status
);
1024 GetStdHandle(DWORD nStdHandle
)
1026 * FUNCTION: Get a handle for the standard input, standard output
1027 * and a standard error device.
1029 * nStdHandle - Specifies the device for which to return the handle.
1030 * RETURNS: If the function succeeds, the return value is the handle
1031 * of the specified device. Otherwise the value is INVALID_HANDLE_VALUE.
1034 PRTL_USER_PROCESS_PARAMETERS Ppb
;
1036 Ppb
= NtCurrentPeb()->ProcessParameters
;
1039 case STD_INPUT_HANDLE
:
1040 return Ppb
->StandardInput
;
1042 case STD_OUTPUT_HANDLE
:
1043 return Ppb
->StandardOutput
;
1045 case STD_ERROR_HANDLE
:
1046 return Ppb
->StandardError
;
1049 SetLastError (ERROR_INVALID_PARAMETER
);
1050 return INVALID_HANDLE_VALUE
;
1058 SetStdHandle(DWORD nStdHandle
,
1061 * FUNCTION: Set the handle for the standard input, standard output or
1062 * the standard error device.
1064 * nStdHandle - Specifies the handle to be set.
1065 * hHandle - The handle to set.
1066 * RETURNS: TRUE if the function succeeds, FALSE otherwise.
1069 PRTL_USER_PROCESS_PARAMETERS Ppb
;
1071 /* no need to check if hHandle == INVALID_HANDLE_VALUE */
1073 Ppb
= NtCurrentPeb()->ProcessParameters
;
1077 case STD_INPUT_HANDLE
:
1078 Ppb
->StandardInput
= hHandle
;
1081 case STD_OUTPUT_HANDLE
:
1082 Ppb
->StandardOutput
= hHandle
;
1085 case STD_ERROR_HANDLE
:
1086 Ppb
->StandardError
= hHandle
;
1090 /* windows for whatever reason sets the last error to ERROR_INVALID_HANDLE here */
1091 SetLastError (ERROR_INVALID_HANDLE
);
1097 IntWriteConsole(HANDLE hConsoleOutput
,
1099 DWORD nNumberOfCharsToWrite
,
1100 LPDWORD lpNumberOfCharsWritten
,
1104 PCSR_API_MESSAGE Request
;
1108 ULONG SizeBytes
, CharSize
;
1111 CharSize
= (bUnicode
? sizeof(WCHAR
) : sizeof(CHAR
));
1112 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
1113 max(sizeof(CSR_API_MESSAGE
),
1114 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE
)
1115 + min(nNumberOfCharsToWrite
, CSRSS_MAX_WRITE_CONSOLE
/ CharSize
) * CharSize
));
1116 if (Request
== NULL
)
1118 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1122 CsrRequest
= MAKE_CSR_API(WRITE_CONSOLE
, CSR_CONSOLE
);
1124 while(nNumberOfCharsToWrite
> 0)
1126 Request
->Data
.WriteConsoleRequest
.ConsoleHandle
= hConsoleOutput
;
1127 Request
->Data
.WriteConsoleRequest
.Unicode
= bUnicode
;
1129 nChars
= min(nNumberOfCharsToWrite
, CSRSS_MAX_WRITE_CONSOLE
/ CharSize
);
1130 Request
->Data
.WriteConsoleRequest
.NrCharactersToWrite
= nChars
;
1132 SizeBytes
= nChars
* CharSize
;
1134 memcpy(Request
->Data
.WriteConsoleRequest
.Buffer
, lpBuffer
, SizeBytes
);
1136 Status
= CsrClientCallServer(Request
,
1139 max(sizeof(CSR_API_MESSAGE
), CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE
) + SizeBytes
));
1141 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
->Status
))
1143 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
1144 SetLastErrorByStatus(Status
);
1148 nNumberOfCharsToWrite
-= nChars
;
1149 lpBuffer
= (PVOID
)((ULONG_PTR
)lpBuffer
+ (ULONG_PTR
)SizeBytes
);
1150 Written
+= Request
->Data
.WriteConsoleRequest
.NrCharactersWritten
;
1153 if(lpNumberOfCharsWritten
!= NULL
)
1155 *lpNumberOfCharsWritten
= Written
;
1157 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
1163 /*--------------------------------------------------------------
1169 WriteConsoleA(HANDLE hConsoleOutput
,
1170 CONST VOID
*lpBuffer
,
1171 DWORD nNumberOfCharsToWrite
,
1172 LPDWORD lpNumberOfCharsWritten
,
1175 return IntWriteConsole(hConsoleOutput
,
1177 nNumberOfCharsToWrite
,
1178 lpNumberOfCharsWritten
,
1184 /*--------------------------------------------------------------
1191 HANDLE hConsoleOutput
,
1192 CONST VOID
*lpBuffer
,
1193 DWORD nNumberOfCharsToWrite
,
1194 LPDWORD lpNumberOfCharsWritten
,
1198 return IntWriteConsole(hConsoleOutput
,
1200 nNumberOfCharsToWrite
,
1201 lpNumberOfCharsWritten
,
1208 IntReadConsole(HANDLE hConsoleInput
,
1210 DWORD nNumberOfCharsToRead
,
1211 LPDWORD lpNumberOfCharsRead
,
1215 PCSR_API_MESSAGE Request
;
1218 ULONG CharSize
, CharsRead
= 0;
1220 CharSize
= (bUnicode
? sizeof(WCHAR
) : sizeof(CHAR
));
1221 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
1222 max(sizeof(CSR_API_MESSAGE
),
1223 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE
)
1224 + min(nNumberOfCharsToRead
, CSRSS_MAX_READ_CONSOLE
/ CharSize
) * CharSize
));
1225 if (Request
== NULL
)
1227 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1231 Request
->Status
= STATUS_SUCCESS
;
1232 CsrRequest
= MAKE_CSR_API(READ_CONSOLE
, CSR_CONSOLE
);
1236 if(Request
->Status
== STATUS_PENDING
)
1238 Status
= NtWaitForSingleObject(Request
->Data
.ReadConsoleRequest
.EventHandle
, FALSE
, 0);
1239 if(!NT_SUCCESS(Status
))
1241 DPRINT1("Wait for console input failed!\n");
1246 Request
->Data
.ReadConsoleRequest
.ConsoleHandle
= hConsoleInput
;
1247 Request
->Data
.ReadConsoleRequest
.Unicode
= bUnicode
;
1248 Request
->Data
.ReadConsoleRequest
.NrCharactersToRead
= min(nNumberOfCharsToRead
, CSRSS_MAX_READ_CONSOLE
/ CharSize
);
1249 Request
->Data
.ReadConsoleRequest
.nCharsCanBeDeleted
= CharsRead
;
1250 Status
= CsrClientCallServer(Request
,
1253 max(sizeof(CSR_API_MESSAGE
),
1254 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE
)
1255 + Request
->Data
.ReadConsoleRequest
.NrCharactersToRead
* CharSize
));
1257 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
->Status
))
1259 DPRINT1("CSR returned error in ReadConsole\n");
1260 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
1261 SetLastErrorByStatus(Status
);
1265 nNumberOfCharsToRead
-= Request
->Data
.ReadConsoleRequest
.NrCharactersRead
;
1266 memcpy((PVOID
)((ULONG_PTR
)lpBuffer
+ (ULONG_PTR
)(CharsRead
* CharSize
)),
1267 Request
->Data
.ReadConsoleRequest
.Buffer
,
1268 Request
->Data
.ReadConsoleRequest
.NrCharactersRead
* CharSize
);
1269 CharsRead
+= Request
->Data
.ReadConsoleRequest
.NrCharactersRead
;
1271 if(Request
->Status
== STATUS_NOTIFY_CLEANUP
)
1276 nNumberOfCharsToRead
++;
1278 Request
->Status
= STATUS_PENDING
;
1280 } while(Request
->Status
== STATUS_PENDING
&& nNumberOfCharsToRead
> 0);
1282 if(lpNumberOfCharsRead
!= NULL
)
1284 *lpNumberOfCharsRead
= CharsRead
;
1287 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
1293 /*--------------------------------------------------------------
1299 ReadConsoleA(HANDLE hConsoleInput
,
1301 DWORD nNumberOfCharsToRead
,
1302 LPDWORD lpNumberOfCharsRead
,
1305 return IntReadConsole(hConsoleInput
,
1307 nNumberOfCharsToRead
,
1308 lpNumberOfCharsRead
,
1314 /*--------------------------------------------------------------
1320 ReadConsoleW(HANDLE hConsoleInput
,
1322 DWORD nNumberOfCharsToRead
,
1323 LPDWORD lpNumberOfCharsRead
,
1326 return IntReadConsole(hConsoleInput
,
1328 nNumberOfCharsToRead
,
1329 lpNumberOfCharsRead
,
1335 /*--------------------------------------------------------------
1340 BOOL STDCALL
AllocConsole(VOID
)
1342 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
1347 if(NtCurrentPeb()->ProcessParameters
->ConsoleHandle
)
1349 DPRINT("AllocConsole: Allocate duplicate console to the same Process\n");
1350 SetLastErrorByStatus (STATUS_OBJECT_NAME_EXISTS
);
1354 Request
.Data
.AllocConsoleRequest
.CtrlDispatcher
= ConsoleControlDispatcher
;
1355 Request
.Data
.AllocConsoleRequest
.ConsoleNeeded
= TRUE
;
1357 CsrRequest
= MAKE_CSR_API(ALLOC_CONSOLE
, CSR_CONSOLE
);
1358 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
1359 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
1361 SetLastErrorByStatus ( Status
);
1364 NtCurrentPeb()->ProcessParameters
->ConsoleHandle
= Request
.Data
.AllocConsoleRequest
.Console
;
1365 SetStdHandle( STD_INPUT_HANDLE
, Request
.Data
.AllocConsoleRequest
.InputHandle
);
1366 SetStdHandle( STD_OUTPUT_HANDLE
, Request
.Data
.AllocConsoleRequest
.OutputHandle
);
1367 hStdError
= DuplicateConsoleHandle(Request
.Data
.AllocConsoleRequest
.OutputHandle
,
1370 DUPLICATE_SAME_ACCESS
);
1371 SetStdHandle( STD_ERROR_HANDLE
, hStdError
);
1376 /*--------------------------------------------------------------
1381 BOOL STDCALL
FreeConsole(VOID
)
1383 // AG: I'm not sure if this is correct (what happens to std handles?)
1384 // but I just tried to reverse what AllocConsole() does...
1386 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
1390 CsrRequest
= MAKE_CSR_API(FREE_CONSOLE
, CSR_CONSOLE
);
1391 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
1392 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
1394 SetLastErrorByStatus ( Status
);
1402 /*--------------------------------------------------------------
1403 * GetConsoleScreenBufferInfo
1409 GetConsoleScreenBufferInfo(
1410 HANDLE hConsoleOutput
,
1411 PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo
1414 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
1418 CsrRequest
= MAKE_CSR_API(SCREEN_BUFFER_INFO
, CSR_CONSOLE
);
1419 Request
.Data
.ScreenBufferInfoRequest
.ConsoleHandle
= hConsoleOutput
;
1420 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
1421 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
1423 SetLastErrorByStatus ( Status
);
1426 *lpConsoleScreenBufferInfo
= Request
.Data
.ScreenBufferInfoRequest
.Info
;
1431 /*--------------------------------------------------------------
1432 * SetConsoleCursorPosition
1438 SetConsoleCursorPosition(
1439 HANDLE hConsoleOutput
,
1440 COORD dwCursorPosition
1443 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
1447 CsrRequest
= MAKE_CSR_API(SET_CURSOR
, CSR_CONSOLE
);
1448 Request
.Data
.SetCursorRequest
.ConsoleHandle
= hConsoleOutput
;
1449 Request
.Data
.SetCursorRequest
.Position
= dwCursorPosition
;
1450 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
1451 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
1453 SetLastErrorByStatus ( Status
);
1461 IntFillConsoleOutputCharacter(HANDLE hConsoleOutput
,
1465 LPDWORD lpNumberOfCharsWritten
,
1468 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
1472 CsrRequest
= MAKE_CSR_API(FILL_OUTPUT
, CSR_CONSOLE
);
1473 Request
.Data
.FillOutputRequest
.ConsoleHandle
= hConsoleOutput
;
1474 Request
.Data
.FillOutputRequest
.Unicode
= bUnicode
;
1476 Request
.Data
.FillOutputRequest
.Char
.UnicodeChar
= *((WCHAR
*)cCharacter
);
1478 Request
.Data
.FillOutputRequest
.Char
.AsciiChar
= *((CHAR
*)cCharacter
);
1479 Request
.Data
.FillOutputRequest
.Position
= dwWriteCoord
;
1480 Request
.Data
.FillOutputRequest
.Length
= nLength
;
1481 Status
= CsrClientCallServer(&Request
, NULL
,
1483 sizeof(CSR_API_MESSAGE
));
1485 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
1487 SetLastErrorByStatus(Status
);
1491 if(lpNumberOfCharsWritten
!= NULL
)
1493 *lpNumberOfCharsWritten
= Request
.Data
.FillOutputRequest
.NrCharactersWritten
;
1499 /*--------------------------------------------------------------
1500 * FillConsoleOutputCharacterA
1505 FillConsoleOutputCharacterA(
1506 HANDLE hConsoleOutput
,
1510 LPDWORD lpNumberOfCharsWritten
1513 return IntFillConsoleOutputCharacter(hConsoleOutput
,
1517 lpNumberOfCharsWritten
,
1522 /*--------------------------------------------------------------
1523 * FillConsoleOutputCharacterW
1529 FillConsoleOutputCharacterW(
1530 HANDLE hConsoleOutput
,
1534 LPDWORD lpNumberOfCharsWritten
1537 return IntFillConsoleOutputCharacter(hConsoleOutput
,
1541 lpNumberOfCharsWritten
,
1547 IntPeekConsoleInput(HANDLE hConsoleInput
,
1548 PINPUT_RECORD lpBuffer
,
1550 LPDWORD lpNumberOfEventsRead
,
1553 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
1554 PCSR_CAPTURE_BUFFER CaptureBuffer
;
1558 if(lpBuffer
== NULL
)
1560 SetLastError(ERROR_INVALID_PARAMETER
);
1564 Size
= nLength
* sizeof(INPUT_RECORD
);
1566 /* Allocate a Capture Buffer */
1567 DPRINT("IntPeekConsoleInput: %lx %p\n", Size
, lpNumberOfEventsRead
);
1568 CaptureBuffer
= CsrAllocateCaptureBuffer(1, Size
);
1570 /* Allocate space in the Buffer */
1571 CsrCaptureMessageBuffer(CaptureBuffer
,
1574 (PVOID
*)&Request
.Data
.PeekConsoleInputRequest
.InputRecord
);
1576 /* Set up the data to send to the Console Server */
1577 CsrRequest
= MAKE_CSR_API(PEEK_CONSOLE_INPUT
, CSR_CONSOLE
);
1578 Request
.Data
.PeekConsoleInputRequest
.ConsoleHandle
= hConsoleInput
;
1579 Request
.Data
.PeekConsoleInputRequest
.Unicode
= bUnicode
;
1580 Request
.Data
.PeekConsoleInputRequest
.Length
= nLength
;
1582 /* Call the server */
1583 Status
= CsrClientCallServer(&Request
,
1586 sizeof(CSR_API_MESSAGE
));
1587 DPRINT("Server returned: %x\n", Request
.Status
);
1589 /* Check for success*/
1590 if (NT_SUCCESS(Request
.Status
))
1592 /* Return the number of events read */
1593 DPRINT("Events read: %lx\n", Request
.Data
.PeekConsoleInputRequest
.Length
);
1594 *lpNumberOfEventsRead
= Request
.Data
.PeekConsoleInputRequest
.Length
;
1596 /* Copy into the buffer */
1597 DPRINT("Copying to buffer\n");
1598 RtlCopyMemory(lpBuffer
,
1599 Request
.Data
.PeekConsoleInputRequest
.InputRecord
,
1600 sizeof(INPUT_RECORD
) * *lpNumberOfEventsRead
);
1605 *lpNumberOfEventsRead
= 0;
1606 SetLastErrorByStatus(Request
.Status
);
1609 /* Release the capture buffer */
1610 CsrFreeCaptureBuffer(CaptureBuffer
);
1612 /* Return TRUE or FALSE */
1613 return NT_SUCCESS(Request
.Status
);
1616 /*--------------------------------------------------------------
1624 HANDLE hConsoleInput
,
1625 PINPUT_RECORD lpBuffer
,
1627 LPDWORD lpNumberOfEventsRead
1630 return IntPeekConsoleInput(hConsoleInput
, lpBuffer
, nLength
,
1631 lpNumberOfEventsRead
, FALSE
);
1635 /*--------------------------------------------------------------
1643 HANDLE hConsoleInput
,
1644 PINPUT_RECORD lpBuffer
,
1646 LPDWORD lpNumberOfEventsRead
1649 return IntPeekConsoleInput(hConsoleInput
, lpBuffer
, nLength
,
1650 lpNumberOfEventsRead
, TRUE
);
1655 IntReadConsoleInput(HANDLE hConsoleInput
,
1656 PINPUT_RECORD lpBuffer
,
1658 LPDWORD lpNumberOfEventsRead
,
1661 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
1666 CsrRequest
= MAKE_CSR_API(READ_INPUT
, CSR_CONSOLE
);
1670 Request
.Data
.ReadInputRequest
.ConsoleHandle
= hConsoleInput
;
1671 Request
.Data
.ReadInputRequest
.Unicode
= bUnicode
;
1672 Status
= CsrClientCallServer(&Request
, NULL
,
1674 sizeof(CSR_API_MESSAGE
));
1675 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
1679 /* we couldn't read a single record, fail */
1680 SetLastErrorByStatus(Status
);
1685 /* FIXME - fail gracefully in case we already read at least one record? */
1689 else if(Status
== STATUS_PENDING
)
1693 Status
= NtWaitForSingleObject(Request
.Data
.ReadInputRequest
.Event
, FALSE
, 0);
1694 if(!NT_SUCCESS(Status
))
1696 SetLastErrorByStatus(Status
);
1702 /* nothing more to read (waiting for more input??), let's just bail */
1708 lpBuffer
[Read
++] = Request
.Data
.ReadInputRequest
.Input
;
1711 if(!Request
.Data
.ReadInputRequest
.MoreEvents
)
1713 /* nothing more to read, bail */
1719 if(lpNumberOfEventsRead
!= NULL
)
1721 *lpNumberOfEventsRead
= Read
;
1728 /*--------------------------------------------------------------
1734 ReadConsoleInputA(HANDLE hConsoleInput
,
1735 PINPUT_RECORD lpBuffer
,
1737 LPDWORD lpNumberOfEventsRead
)
1739 return IntReadConsoleInput(hConsoleInput
, lpBuffer
, nLength
,
1740 lpNumberOfEventsRead
, FALSE
);
1744 /*--------------------------------------------------------------
1752 HANDLE hConsoleInput
,
1753 PINPUT_RECORD lpBuffer
,
1755 LPDWORD lpNumberOfEventsRead
1758 return IntReadConsoleInput(hConsoleInput
, lpBuffer
, nLength
,
1759 lpNumberOfEventsRead
, TRUE
);
1764 IntWriteConsoleInput(HANDLE hConsoleInput
,
1765 PINPUT_RECORD lpBuffer
,
1767 LPDWORD lpNumberOfEventsWritten
,
1770 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
1771 PCSR_CAPTURE_BUFFER CaptureBuffer
;
1775 if(lpBuffer
== NULL
)
1777 SetLastError(ERROR_INVALID_PARAMETER
);
1781 Size
= nLength
* sizeof(INPUT_RECORD
);
1783 /* Allocate a Capture Buffer */
1784 DPRINT("IntWriteConsoleInput: %lx %p\n", Size
, lpNumberOfEventsWritten
);
1785 CaptureBuffer
= CsrAllocateCaptureBuffer(1, Size
);
1787 /* Allocate space in the Buffer */
1788 CsrCaptureMessageBuffer(CaptureBuffer
,
1791 (PVOID
*)&Request
.Data
.WriteConsoleInputRequest
.InputRecord
);
1793 /* Set up the data to send to the Console Server */
1794 CsrRequest
= MAKE_CSR_API(WRITE_CONSOLE_INPUT
, CSR_CONSOLE
);
1795 Request
.Data
.WriteConsoleInputRequest
.ConsoleHandle
= hConsoleInput
;
1796 Request
.Data
.WriteConsoleInputRequest
.Unicode
= bUnicode
;
1797 Request
.Data
.WriteConsoleInputRequest
.Length
= nLength
;
1799 /* Call the server */
1800 Status
= CsrClientCallServer(&Request
,
1803 sizeof(CSR_API_MESSAGE
));
1804 DPRINT("Server returned: %x\n", Request
.Status
);
1806 /* Check for success*/
1807 if (NT_SUCCESS(Request
.Status
))
1809 /* Return the number of events read */
1810 DPRINT("Events read: %lx\n", Request
.Data
.WriteConsoleInputRequest
.Length
);
1811 *lpNumberOfEventsWritten
= Request
.Data
.WriteConsoleInputRequest
.Length
;
1813 /* Copy into the buffer */
1814 DPRINT("Copying to buffer\n");
1815 RtlCopyMemory(lpBuffer
,
1816 Request
.Data
.WriteConsoleInputRequest
.InputRecord
,
1817 sizeof(INPUT_RECORD
) * *lpNumberOfEventsWritten
);
1822 *lpNumberOfEventsWritten
= 0;
1823 SetLastErrorByStatus(Request
.Status
);
1826 /* Release the capture buffer */
1827 CsrFreeCaptureBuffer(CaptureBuffer
);
1829 /* Return TRUE or FALSE */
1830 return NT_SUCCESS(Request
.Status
);
1834 /*--------------------------------------------------------------
1835 * WriteConsoleInputA
1842 HANDLE hConsoleInput
,
1843 CONST INPUT_RECORD
*lpBuffer
,
1845 LPDWORD lpNumberOfEventsWritten
1848 return IntWriteConsoleInput(hConsoleInput
,
1849 (PINPUT_RECORD
)lpBuffer
,
1851 lpNumberOfEventsWritten
,
1856 /*--------------------------------------------------------------
1857 * WriteConsoleInputW
1864 HANDLE hConsoleInput
,
1865 CONST INPUT_RECORD
*lpBuffer
,
1867 LPDWORD lpNumberOfEventsWritten
1870 return IntWriteConsoleInput(hConsoleInput
,
1871 (PINPUT_RECORD
)lpBuffer
,
1873 lpNumberOfEventsWritten
,
1879 IntReadConsoleOutput(HANDLE hConsoleOutput
,
1880 PCHAR_INFO lpBuffer
,
1882 COORD dwBufferCoord
,
1883 PSMALL_RECT lpReadRegion
,
1886 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
1887 PCSR_CAPTURE_BUFFER CaptureBuffer
;
1889 DWORD Size
, SizeX
, SizeY
;
1891 if(lpBuffer
== NULL
)
1893 SetLastError(ERROR_INVALID_PARAMETER
);
1897 Size
= dwBufferSize
.X
* dwBufferSize
.Y
* sizeof(CHAR_INFO
);
1899 /* Allocate a Capture Buffer */
1900 DPRINT("IntReadConsoleOutput: %lx %p\n", Size
, lpReadRegion
);
1901 CaptureBuffer
= CsrAllocateCaptureBuffer(1, Size
);
1903 /* Allocate space in the Buffer */
1904 CsrCaptureMessageBuffer(CaptureBuffer
,
1907 (PVOID
*)&Request
.Data
.ReadConsoleOutputRequest
.CharInfo
);
1909 /* Set up the data to send to the Console Server */
1910 CsrRequest
= MAKE_CSR_API(READ_CONSOLE_OUTPUT
, CSR_CONSOLE
);
1911 Request
.Data
.ReadConsoleOutputRequest
.ConsoleHandle
= hConsoleOutput
;
1912 Request
.Data
.ReadConsoleOutputRequest
.Unicode
= bUnicode
;
1913 Request
.Data
.ReadConsoleOutputRequest
.BufferSize
= dwBufferSize
;
1914 Request
.Data
.ReadConsoleOutputRequest
.BufferCoord
= dwBufferCoord
;
1915 Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
= *lpReadRegion
;
1917 /* Call the server */
1918 Status
= CsrClientCallServer(&Request
,
1921 sizeof(CSR_API_MESSAGE
));
1922 DPRINT("Server returned: %x\n", Request
.Status
);
1924 /* Check for success*/
1925 if (NT_SUCCESS(Request
.Status
))
1927 /* Copy into the buffer */
1928 DPRINT("Copying to buffer\n");
1929 SizeX
= Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
.Right
-
1930 Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
.Left
+ 1;
1931 SizeY
= Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
.Bottom
-
1932 Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
.Top
+ 1;
1933 RtlCopyMemory(lpBuffer
,
1934 Request
.Data
.ReadConsoleOutputRequest
.CharInfo
,
1935 sizeof(CHAR_INFO
) * SizeX
* SizeY
);
1940 SetLastErrorByStatus(Request
.Status
);
1943 /* Return the read region */
1944 DPRINT("read region: %lx\n", Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
);
1945 *lpReadRegion
= Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
;
1947 /* Release the capture buffer */
1948 CsrFreeCaptureBuffer(CaptureBuffer
);
1950 /* Return TRUE or FALSE */
1951 return NT_SUCCESS(Request
.Status
);
1954 /*--------------------------------------------------------------
1955 * ReadConsoleOutputA
1962 HANDLE hConsoleOutput
,
1963 PCHAR_INFO lpBuffer
,
1965 COORD dwBufferCoord
,
1966 PSMALL_RECT lpReadRegion
1969 return IntReadConsoleOutput(hConsoleOutput
, lpBuffer
, dwBufferSize
,
1970 dwBufferCoord
, lpReadRegion
, FALSE
);
1974 /*--------------------------------------------------------------
1975 * ReadConsoleOutputW
1982 HANDLE hConsoleOutput
,
1983 PCHAR_INFO lpBuffer
,
1985 COORD dwBufferCoord
,
1986 PSMALL_RECT lpReadRegion
1989 return IntReadConsoleOutput(hConsoleOutput
, lpBuffer
, dwBufferSize
,
1990 dwBufferCoord
, lpReadRegion
, TRUE
);
1995 IntWriteConsoleOutput(HANDLE hConsoleOutput
,
1996 CONST CHAR_INFO
*lpBuffer
,
1998 COORD dwBufferCoord
,
1999 PSMALL_RECT lpWriteRegion
,
2002 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2003 PCSR_CAPTURE_BUFFER CaptureBuffer
;
2007 Size
= dwBufferSize
.Y
* dwBufferSize
.X
* sizeof(CHAR_INFO
);
2009 /* Allocate a Capture Buffer */
2010 DPRINT("IntWriteConsoleOutput: %lx %p\n", Size
, lpWriteRegion
);
2011 CaptureBuffer
= CsrAllocateCaptureBuffer(1, Size
);
2013 /* Allocate space in the Buffer */
2014 CsrCaptureMessageBuffer(CaptureBuffer
,
2017 (PVOID
*)&Request
.Data
.WriteConsoleOutputRequest
.CharInfo
);
2019 /* Copy from the buffer */
2020 RtlCopyMemory(Request
.Data
.WriteConsoleOutputRequest
.CharInfo
, lpBuffer
, Size
);
2022 /* Set up the data to send to the Console Server */
2023 CsrRequest
= MAKE_CSR_API(WRITE_CONSOLE_OUTPUT
, CSR_CONSOLE
);
2024 Request
.Data
.WriteConsoleOutputRequest
.ConsoleHandle
= hConsoleOutput
;
2025 Request
.Data
.WriteConsoleOutputRequest
.Unicode
= bUnicode
;
2026 Request
.Data
.WriteConsoleOutputRequest
.BufferSize
= dwBufferSize
;
2027 Request
.Data
.WriteConsoleOutputRequest
.BufferCoord
= dwBufferCoord
;
2028 Request
.Data
.WriteConsoleOutputRequest
.WriteRegion
= *lpWriteRegion
;
2030 /* Call the server */
2031 Status
= CsrClientCallServer(&Request
,
2034 sizeof(CSR_API_MESSAGE
));
2035 DPRINT("Server returned: %x\n", Request
.Status
);
2037 /* Check for success*/
2038 if (!NT_SUCCESS(Request
.Status
))
2041 SetLastErrorByStatus(Request
.Status
);
2044 /* Return the read region */
2045 DPRINT("read region: %lx\n", Request
.Data
.WriteConsoleOutputRequest
.WriteRegion
);
2046 *lpWriteRegion
= Request
.Data
.WriteConsoleOutputRequest
.WriteRegion
;
2048 /* Release the capture buffer */
2049 CsrFreeCaptureBuffer(CaptureBuffer
);
2051 /* Return TRUE or FALSE */
2052 return NT_SUCCESS(Request
.Status
);
2055 /*--------------------------------------------------------------
2056 * WriteConsoleOutputA
2061 WriteConsoleOutputA(HANDLE hConsoleOutput
,
2062 CONST CHAR_INFO
*lpBuffer
,
2064 COORD dwBufferCoord
,
2065 PSMALL_RECT lpWriteRegion
)
2067 return IntWriteConsoleOutput(hConsoleOutput
, lpBuffer
, dwBufferSize
,
2068 dwBufferCoord
, lpWriteRegion
, FALSE
);
2072 /*--------------------------------------------------------------
2073 * WriteConsoleOutputW
2079 WriteConsoleOutputW(
2080 HANDLE hConsoleOutput
,
2081 CONST CHAR_INFO
*lpBuffer
,
2083 COORD dwBufferCoord
,
2084 PSMALL_RECT lpWriteRegion
2087 return IntWriteConsoleOutput(hConsoleOutput
, lpBuffer
, dwBufferSize
,
2088 dwBufferCoord
, lpWriteRegion
, TRUE
);
2093 IntReadConsoleOutputCharacter(HANDLE hConsoleOutput
,
2097 LPDWORD lpNumberOfCharsRead
,
2100 PCSR_API_MESSAGE Request
; ULONG CsrRequest
;
2102 ULONG nChars
, SizeBytes
, CharSize
;
2103 DWORD CharsRead
= 0;
2105 CharSize
= (bUnicode
? sizeof(WCHAR
) : sizeof(CHAR
));
2107 nChars
= min(nLength
, CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR
) / CharSize
;
2108 SizeBytes
= nChars
* CharSize
;
2110 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
2111 max(sizeof(CSR_API_MESSAGE
),
2112 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_CHAR
)
2113 + min (nChars
, CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR
/ CharSize
) * CharSize
));
2114 if (Request
== NULL
)
2116 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2120 CsrRequest
= MAKE_CSR_API(READ_CONSOLE_OUTPUT_CHAR
, CSR_CONSOLE
);
2121 Request
->Data
.ReadConsoleOutputCharRequest
.ReadCoord
= dwReadCoord
;
2127 Request
->Data
.ReadConsoleOutputCharRequest
.ConsoleHandle
= hConsoleOutput
;
2128 Request
->Data
.ReadConsoleOutputCharRequest
.Unicode
= bUnicode
;
2129 Request
->Data
.ReadConsoleOutputCharRequest
.NumCharsToRead
= min(nLength
, nChars
);
2130 SizeBytes
= Request
->Data
.ReadConsoleOutputCharRequest
.NumCharsToRead
* CharSize
;
2132 Status
= CsrClientCallServer(Request
,
2135 max (sizeof(CSR_API_MESSAGE
),
2136 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_CHAR
) + SizeBytes
));
2137 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Request
->Status
))
2139 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2140 SetLastErrorByStatus(Status
);
2144 BytesRead
= Request
->Data
.ReadConsoleOutputCharRequest
.CharsRead
* CharSize
;
2145 memcpy(lpCharacter
, Request
->Data
.ReadConsoleOutputCharRequest
.String
, BytesRead
);
2146 lpCharacter
= (PVOID
)((ULONG_PTR
)lpCharacter
+ (ULONG_PTR
)BytesRead
);
2147 CharsRead
+= Request
->Data
.ReadConsoleOutputCharRequest
.CharsRead
;
2148 nLength
-= Request
->Data
.ReadConsoleOutputCharRequest
.CharsRead
;
2150 Request
->Data
.ReadConsoleOutputCharRequest
.ReadCoord
= Request
->Data
.ReadConsoleOutputCharRequest
.EndCoord
;
2153 if(lpNumberOfCharsRead
!= NULL
)
2155 *lpNumberOfCharsRead
= CharsRead
;
2158 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2164 /*--------------------------------------------------------------
2165 * ReadConsoleOutputCharacterA
2171 ReadConsoleOutputCharacterA(
2172 HANDLE hConsoleOutput
,
2176 LPDWORD lpNumberOfCharsRead
2179 return IntReadConsoleOutputCharacter(hConsoleOutput
,
2183 lpNumberOfCharsRead
,
2188 /*--------------------------------------------------------------
2189 * ReadConsoleOutputCharacterW
2195 ReadConsoleOutputCharacterW(
2196 HANDLE hConsoleOutput
,
2200 LPDWORD lpNumberOfCharsRead
2203 return IntReadConsoleOutputCharacter(hConsoleOutput
,
2207 lpNumberOfCharsRead
,
2212 /*--------------------------------------------------------------
2213 * ReadConsoleOutputAttribute
2219 ReadConsoleOutputAttribute(
2220 HANDLE hConsoleOutput
,
2224 LPDWORD lpNumberOfAttrsRead
2227 PCSR_API_MESSAGE Request
; ULONG CsrRequest
;
2231 if (lpNumberOfAttrsRead
!= NULL
)
2232 *lpNumberOfAttrsRead
= nLength
;
2234 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
2235 max(sizeof(CSR_API_MESSAGE
),
2236 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_ATTRIB
)
2237 + min (nLength
, CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB
/ sizeof(WORD
)) * sizeof(WORD
)));
2238 if (Request
== NULL
)
2240 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2244 CsrRequest
= MAKE_CSR_API(READ_CONSOLE_OUTPUT_ATTRIB
, CSR_CONSOLE
);
2246 while (nLength
!= 0)
2248 Request
->Data
.ReadConsoleOutputAttribRequest
.ConsoleHandle
= hConsoleOutput
;
2249 Request
->Data
.ReadConsoleOutputAttribRequest
.ReadCoord
= dwReadCoord
;
2251 if (nLength
> CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB
/ sizeof(WORD
))
2252 Size
= CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB
/ sizeof(WCHAR
);
2256 Request
->Data
.ReadConsoleOutputAttribRequest
.NumAttrsToRead
= Size
;
2258 Status
= CsrClientCallServer(Request
,
2261 max (sizeof(CSR_API_MESSAGE
),
2262 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_ATTRIB
) + Size
* sizeof(WORD
)));
2263 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Request
->Status
))
2265 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2266 SetLastErrorByStatus(Status
);
2270 memcpy(lpAttribute
, Request
->Data
.ReadConsoleOutputAttribRequest
.Attribute
, Size
* sizeof(WORD
));
2271 lpAttribute
+= Size
;
2273 Request
->Data
.ReadConsoleOutputAttribRequest
.ReadCoord
= Request
->Data
.ReadConsoleOutputAttribRequest
.EndCoord
;
2276 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2283 IntWriteConsoleOutputCharacter(HANDLE hConsoleOutput
,
2287 LPDWORD lpNumberOfCharsWritten
,
2290 PCSR_API_MESSAGE Request
; ULONG CsrRequest
;
2292 ULONG SizeBytes
, CharSize
, nChars
;
2295 CharSize
= (bUnicode
? sizeof(WCHAR
) : sizeof(CHAR
));
2297 nChars
= min(nLength
, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR
/ CharSize
);
2298 SizeBytes
= nChars
* CharSize
;
2300 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
2301 max (sizeof(CSR_API_MESSAGE
),
2302 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE_OUTPUT_CHAR
)
2303 + min (nChars
, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR
/ CharSize
) * CharSize
));
2304 if (Request
== NULL
)
2306 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2310 CsrRequest
= MAKE_CSR_API(WRITE_CONSOLE_OUTPUT_CHAR
, CSR_CONSOLE
);
2311 Request
->Data
.WriteConsoleOutputCharRequest
.Coord
= dwWriteCoord
;
2317 Request
->Data
.WriteConsoleOutputCharRequest
.ConsoleHandle
= hConsoleOutput
;
2318 Request
->Data
.WriteConsoleOutputCharRequest
.Unicode
= bUnicode
;
2319 Request
->Data
.WriteConsoleOutputCharRequest
.Length
= min(nLength
, nChars
);
2320 BytesWrite
= Request
->Data
.WriteConsoleOutputCharRequest
.Length
* CharSize
;
2322 memcpy(Request
->Data
.WriteConsoleOutputCharRequest
.String
, lpCharacter
, BytesWrite
);
2324 Status
= CsrClientCallServer(Request
,
2327 max (sizeof(CSR_API_MESSAGE
),
2328 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE_OUTPUT_CHAR
) + BytesWrite
));
2330 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
->Status
))
2332 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2333 SetLastErrorByStatus(Status
);
2337 nLength
-= Request
->Data
.WriteConsoleOutputCharRequest
.NrCharactersWritten
;
2338 lpCharacter
= (PVOID
)((ULONG_PTR
)lpCharacter
+ (ULONG_PTR
)(Request
->Data
.WriteConsoleOutputCharRequest
.NrCharactersWritten
* CharSize
));
2339 Written
+= Request
->Data
.WriteConsoleOutputCharRequest
.NrCharactersWritten
;
2341 Request
->Data
.WriteConsoleOutputCharRequest
.Coord
= Request
->Data
.WriteConsoleOutputCharRequest
.EndCoord
;
2344 if(lpNumberOfCharsWritten
!= NULL
)
2346 *lpNumberOfCharsWritten
= Written
;
2349 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2355 /*--------------------------------------------------------------
2356 * WriteConsoleOutputCharacterA
2361 WriteConsoleOutputCharacterA(HANDLE hConsoleOutput
,
2365 LPDWORD lpNumberOfCharsWritten
)
2367 return IntWriteConsoleOutputCharacter(hConsoleOutput
,
2371 lpNumberOfCharsWritten
,
2376 /*--------------------------------------------------------------
2377 * WriteConsoleOutputCharacterW
2382 WriteConsoleOutputCharacterW(HANDLE hConsoleOutput
,
2383 LPCWSTR lpCharacter
,
2386 LPDWORD lpNumberOfCharsWritten
)
2388 return IntWriteConsoleOutputCharacter(hConsoleOutput
,
2392 lpNumberOfCharsWritten
,
2397 /*--------------------------------------------------------------
2398 * WriteConsoleOutputAttribute
2404 WriteConsoleOutputAttribute(
2405 HANDLE hConsoleOutput
,
2406 CONST WORD
*lpAttribute
,
2409 LPDWORD lpNumberOfAttrsWritten
2412 PCSR_API_MESSAGE Request
; ULONG CsrRequest
;
2416 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
2417 max (sizeof(CSR_API_MESSAGE
),
2418 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB
)
2419 + min(nLength
, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB
/ sizeof(WORD
)) * sizeof(WORD
)));
2420 if (Request
== NULL
)
2422 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2426 CsrRequest
= MAKE_CSR_API(WRITE_CONSOLE_OUTPUT_ATTRIB
, CSR_CONSOLE
);
2427 Request
->Data
.WriteConsoleOutputAttribRequest
.Coord
= dwWriteCoord
;
2429 if( lpNumberOfAttrsWritten
)
2430 *lpNumberOfAttrsWritten
= nLength
;
2433 Size
= min(nLength
, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB
/ sizeof(WORD
));
2434 Request
->Data
.WriteConsoleOutputAttribRequest
.ConsoleHandle
= hConsoleOutput
;
2435 Request
->Data
.WriteConsoleOutputAttribRequest
.Length
= Size
;
2436 memcpy(Request
->Data
.WriteConsoleOutputAttribRequest
.Attribute
, lpAttribute
, Size
* sizeof(WORD
));
2438 Status
= CsrClientCallServer( Request
,
2441 max (sizeof(CSR_API_MESSAGE
),
2442 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB
) + Size
* sizeof(WORD
)));
2444 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
->Status
) )
2446 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2447 SetLastErrorByStatus ( Status
);
2451 lpAttribute
+= Size
;
2452 Request
->Data
.WriteConsoleOutputAttribRequest
.Coord
= Request
->Data
.WriteConsoleOutputAttribRequest
.EndCoord
;
2455 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2461 /*--------------------------------------------------------------
2462 * FillConsoleOutputAttribute
2468 FillConsoleOutputAttribute(
2469 HANDLE hConsoleOutput
,
2473 LPDWORD lpNumberOfAttrsWritten
2476 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2480 CsrRequest
= MAKE_CSR_API(FILL_OUTPUT_ATTRIB
, CSR_CONSOLE
);
2481 Request
.Data
.FillOutputAttribRequest
.ConsoleHandle
= hConsoleOutput
;
2482 Request
.Data
.FillOutputAttribRequest
.Attribute
= wAttribute
;
2483 Request
.Data
.FillOutputAttribRequest
.Coord
= dwWriteCoord
;
2484 Request
.Data
.FillOutputAttribRequest
.Length
= nLength
;
2485 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
2486 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
2488 SetLastErrorByStatus ( Status
);
2491 if( lpNumberOfAttrsWritten
)
2492 *lpNumberOfAttrsWritten
= nLength
;
2497 /*--------------------------------------------------------------
2505 HANDLE hConsoleHandle
,
2509 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2513 CsrRequest
= MAKE_CSR_API(GET_CONSOLE_MODE
, CSR_CONSOLE
);
2514 Request
.Data
.GetConsoleModeRequest
.ConsoleHandle
= hConsoleHandle
;
2515 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
2516 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
2518 SetLastErrorByStatus ( Status
);
2521 *lpMode
= Request
.Data
.GetConsoleModeRequest
.ConsoleMode
;
2526 /*--------------------------------------------------------------
2527 * GetNumberOfConsoleInputEvents
2533 GetNumberOfConsoleInputEvents(
2534 HANDLE hConsoleInput
,
2535 LPDWORD lpNumberOfEvents
2538 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2542 if(lpNumberOfEvents
== NULL
)
2544 SetLastError(ERROR_INVALID_PARAMETER
);
2548 CsrRequest
= MAKE_CSR_API(GET_NUM_INPUT_EVENTS
, CSR_CONSOLE
);
2549 Request
.Data
.GetNumInputEventsRequest
.ConsoleHandle
= hConsoleInput
;
2550 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
2551 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
2553 SetLastErrorByStatus(Status
);
2557 *lpNumberOfEvents
= Request
.Data
.GetNumInputEventsRequest
.NumInputEvents
;
2563 /*--------------------------------------------------------------
2564 * GetLargestConsoleWindowSize
2570 GetLargestConsoleWindowSize(
2571 HANDLE hConsoleOutput
2574 COORD Coord
= {80,25};
2575 DPRINT1("GetLargestConsoleWindowSize(0x%x) UNIMPLEMENTED!\n", hConsoleOutput
);
2576 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2581 /*--------------------------------------------------------------
2582 * GetConsoleCursorInfo
2588 GetConsoleCursorInfo(
2589 HANDLE hConsoleOutput
,
2590 PCONSOLE_CURSOR_INFO lpConsoleCursorInfo
2593 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2597 CsrRequest
= MAKE_CSR_API(GET_CURSOR_INFO
, CSR_CONSOLE
);
2598 Request
.Data
.GetCursorInfoRequest
.ConsoleHandle
= hConsoleOutput
;
2599 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
2601 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
2603 SetLastErrorByStatus ( Status
);
2606 *lpConsoleCursorInfo
= Request
.Data
.GetCursorInfoRequest
.Info
;
2611 /*--------------------------------------------------------------
2612 * GetNumberOfConsoleMouseButtons
2618 GetNumberOfConsoleMouseButtons(
2619 LPDWORD lpNumberOfMouseButtons
2622 DPRINT1("GetNumberOfConsoleMouseButtons(0x%x) UNIMPLEMENTED!\n", lpNumberOfMouseButtons
);
2623 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2628 /*--------------------------------------------------------------
2636 HANDLE hConsoleHandle
,
2640 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2644 if (!IsConsoleHandle (hConsoleHandle
))
2646 DPRINT("SetConsoleMode was called with a non console handle\n");
2647 SetLastError (ERROR_INVALID_PARAMETER
);
2652 CsrRequest
= MAKE_CSR_API(SET_CONSOLE_MODE
, CSR_CONSOLE
);
2653 Request
.Data
.SetConsoleModeRequest
.ConsoleHandle
= hConsoleHandle
;
2654 Request
.Data
.SetConsoleModeRequest
.Mode
= dwMode
;
2655 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
2656 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
2658 SetLastErrorByStatus ( Status
);
2665 /*--------------------------------------------------------------
2666 * SetConsoleActiveScreenBuffer
2672 SetConsoleActiveScreenBuffer(
2673 HANDLE hConsoleOutput
2676 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2680 CsrRequest
= MAKE_CSR_API(SET_SCREEN_BUFFER
, CSR_CONSOLE
);
2681 Request
.Data
.SetScreenBufferRequest
.OutputHandle
= hConsoleOutput
;
2682 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
2683 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
2685 SetLastErrorByStatus ( Status
);
2692 /*--------------------------------------------------------------
2693 * FlushConsoleInputBuffer
2699 FlushConsoleInputBuffer(
2700 HANDLE hConsoleInput
2703 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2707 CsrRequest
= MAKE_CSR_API(FLUSH_INPUT_BUFFER
, CSR_CONSOLE
);
2708 Request
.Data
.FlushInputBufferRequest
.ConsoleInput
= hConsoleInput
;
2709 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
2710 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
2712 SetLastErrorByStatus ( Status
);
2719 /*--------------------------------------------------------------
2720 * SetConsoleScreenBufferSize
2726 SetConsoleScreenBufferSize(
2727 HANDLE hConsoleOutput
,
2731 DPRINT1("SetConsoleScreenBufferSize(0x%x, 0x%x) UNIMPLEMENTED!\n", hConsoleOutput
, dwSize
);
2732 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2736 /*--------------------------------------------------------------
2737 * SetConsoleCursorInfo
2743 SetConsoleCursorInfo(
2744 HANDLE hConsoleOutput
,
2745 CONST CONSOLE_CURSOR_INFO
*lpConsoleCursorInfo
2748 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2752 CsrRequest
= MAKE_CSR_API(SET_CURSOR_INFO
, CSR_CONSOLE
);
2753 Request
.Data
.SetCursorInfoRequest
.ConsoleHandle
= hConsoleOutput
;
2754 Request
.Data
.SetCursorInfoRequest
.Info
= *lpConsoleCursorInfo
;
2755 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
2757 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
2759 SetLastErrorByStatus ( Status
);
2767 IntScrollConsoleScreenBuffer(HANDLE hConsoleOutput
,
2768 PSMALL_RECT lpScrollRectangle
,
2769 PSMALL_RECT lpClipRectangle
,
2770 COORD dwDestinationOrigin
,
2774 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2778 CsrRequest
= MAKE_CSR_API(SCROLL_CONSOLE_SCREEN_BUFFER
, CSR_CONSOLE
);
2779 Request
.Data
.ScrollConsoleScreenBufferRequest
.ConsoleHandle
= hConsoleOutput
;
2780 Request
.Data
.ScrollConsoleScreenBufferRequest
.Unicode
= bUnicode
;
2781 Request
.Data
.ScrollConsoleScreenBufferRequest
.ScrollRectangle
= *lpScrollRectangle
;
2783 if(lpClipRectangle
!= NULL
)
2785 Request
.Data
.ScrollConsoleScreenBufferRequest
.UseClipRectangle
= TRUE
;
2786 Request
.Data
.ScrollConsoleScreenBufferRequest
.ClipRectangle
= *lpClipRectangle
;
2790 Request
.Data
.ScrollConsoleScreenBufferRequest
.UseClipRectangle
= FALSE
;
2793 Request
.Data
.ScrollConsoleScreenBufferRequest
.DestinationOrigin
= dwDestinationOrigin
;
2794 Request
.Data
.ScrollConsoleScreenBufferRequest
.Fill
= *lpFill
;
2795 Status
= CsrClientCallServer(&Request
, NULL
,
2797 sizeof(CSR_API_MESSAGE
));
2799 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
2801 SetLastErrorByStatus(Status
);
2809 /*--------------------------------------------------------------
2810 * ScrollConsoleScreenBufferA
2816 ScrollConsoleScreenBufferA(
2817 HANDLE hConsoleOutput
,
2818 CONST SMALL_RECT
*lpScrollRectangle
,
2819 CONST SMALL_RECT
*lpClipRectangle
,
2820 COORD dwDestinationOrigin
,
2821 CONST CHAR_INFO
*lpFill
2824 return IntScrollConsoleScreenBuffer(hConsoleOutput
,
2825 (PSMALL_RECT
)lpScrollRectangle
,
2826 (PSMALL_RECT
)lpClipRectangle
,
2827 dwDestinationOrigin
,
2833 /*--------------------------------------------------------------
2834 * ScrollConsoleScreenBufferW
2840 ScrollConsoleScreenBufferW(
2841 HANDLE hConsoleOutput
,
2842 CONST SMALL_RECT
*lpScrollRectangle
,
2843 CONST SMALL_RECT
*lpClipRectangle
,
2844 COORD dwDestinationOrigin
,
2845 CONST CHAR_INFO
*lpFill
2848 return IntScrollConsoleScreenBuffer(hConsoleOutput
,
2849 (PSMALL_RECT
)lpScrollRectangle
,
2850 (PSMALL_RECT
)lpClipRectangle
,
2851 dwDestinationOrigin
,
2857 /*--------------------------------------------------------------
2858 * SetConsoleWindowInfo
2864 SetConsoleWindowInfo(
2865 HANDLE hConsoleOutput
,
2867 CONST SMALL_RECT
*lpConsoleWindow
2870 DPRINT1("SetConsoleWindowInfo(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", hConsoleOutput
, bAbsolute
, lpConsoleWindow
);
2871 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2876 /*--------------------------------------------------------------
2877 * SetConsoleTextAttribute
2883 SetConsoleTextAttribute(
2884 HANDLE hConsoleOutput
,
2888 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
2892 CsrRequest
= MAKE_CSR_API(SET_ATTRIB
, CSR_CONSOLE
);
2893 Request
.Data
.SetAttribRequest
.ConsoleHandle
= hConsoleOutput
;
2894 Request
.Data
.SetAttribRequest
.Attrib
= wAttributes
;
2895 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
2896 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
2898 SetLastErrorByStatus ( Status
);
2906 AddConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine
)
2908 if (HandlerRoutine
== NULL
)
2910 IgnoreCtrlEvents
= TRUE
;
2916 if (CtrlHandlers
== NULL
)
2918 CtrlHandlers
= RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY
,
2919 NrCtrlHandlers
* sizeof(PHANDLER_ROUTINE
));
2923 CtrlHandlers
= RtlReAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY
,
2924 (PVOID
)CtrlHandlers
,
2925 NrCtrlHandlers
* sizeof(PHANDLER_ROUTINE
));
2927 if (CtrlHandlers
== NULL
)
2930 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2933 CtrlHandlers
[NrCtrlHandlers
- 1] = HandlerRoutine
;
2940 RemoveConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine
)
2944 if (HandlerRoutine
== NULL
)
2946 IgnoreCtrlEvents
= FALSE
;
2951 for (i
= 0; i
< NrCtrlHandlers
; i
++)
2953 if ( ((void*)(CtrlHandlers
[i
])) == (void*)HandlerRoutine
)
2956 memmove(CtrlHandlers
+ i
, CtrlHandlers
+ i
+ 1,
2957 (NrCtrlHandlers
- i
) * sizeof(PHANDLER_ROUTINE
));
2959 RtlReAllocateHeap(RtlGetProcessHeap(),
2961 (PVOID
)CtrlHandlers
,
2962 NrCtrlHandlers
* sizeof(PHANDLER_ROUTINE
));
2975 SetConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine
,
2980 RtlEnterCriticalSection(&DllLock
);
2983 Ret
= AddConsoleCtrlHandler(HandlerRoutine
);
2987 Ret
= RemoveConsoleCtrlHandler(HandlerRoutine
);
2989 RtlLeaveCriticalSection(&DllLock
);
2994 /*--------------------------------------------------------------
2995 * GenerateConsoleCtrlEvent
3000 GenerateConsoleCtrlEvent(
3002 DWORD dwProcessGroupId
3005 DPRINT1("GenerateConsoleCtrlEvent(0x%x, 0x%x) UNIMPLEMENTED!\n", dwCtrlEvent
, dwProcessGroupId
);
3006 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3011 /*--------------------------------------------------------------
3019 LPWSTR lpConsoleTitle
,
3023 PCSR_API_MESSAGE Request
; ULONG CsrRequest
;
3027 hConsole
= CreateFileW(L
"CONIN$", GENERIC_READ
, 0, NULL
, OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
3028 if (hConsole
== INVALID_HANDLE_VALUE
)
3033 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
3034 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_GET_TITLE
) + CSRSS_MAX_TITLE_LENGTH
* sizeof(WCHAR
));
3035 if (Request
== NULL
)
3037 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
3041 CsrRequest
= MAKE_CSR_API(GET_TITLE
, CSR_CONSOLE
);
3042 Request
->Data
.GetTitleRequest
.ConsoleHandle
= hConsole
;
3044 Status
= CsrClientCallServer(Request
,
3047 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_GET_TITLE
) + CSRSS_MAX_TITLE_LENGTH
* sizeof(WCHAR
));
3048 CloseHandle(hConsole
);
3049 if(!NT_SUCCESS(Status
) || !(NT_SUCCESS(Status
= Request
->Status
)))
3051 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
3052 SetLastErrorByStatus(Status
);
3056 if(nSize
* sizeof(WCHAR
) <= Request
->Data
.GetTitleRequest
.Length
)
3062 nSize
= Request
->Data
.GetTitleRequest
.Length
/ sizeof (WCHAR
);
3064 memcpy(lpConsoleTitle
, Request
->Data
.GetTitleRequest
.Title
, nSize
* sizeof(WCHAR
));
3065 lpConsoleTitle
[nSize
] = L
'\0';
3067 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
3073 /*--------------------------------------------------------------
3083 LPSTR lpConsoleTitle
,
3087 WCHAR WideTitle
[CSRSS_MAX_TITLE_LENGTH
+ 1];
3088 DWORD nWideTitle
= CSRSS_MAX_TITLE_LENGTH
+ 1;
3091 if (!lpConsoleTitle
|| !nSize
) return 0;
3092 nWideTitle
= GetConsoleTitleW( (LPWSTR
) WideTitle
, nWideTitle
);
3093 if (!nWideTitle
) return 0;
3095 if ( (nWritten
= WideCharToMultiByte(
3096 CP_ACP
, // ANSI code page
3097 0, // performance and mapping flags
3098 (LPWSTR
) WideTitle
, // address of wide-character string
3099 nWideTitle
, // number of characters in string
3100 lpConsoleTitle
, // address of buffer for new string
3101 nSize
- 1, // size of buffer
3106 lpConsoleTitle
[nWritten
] = '\0';
3114 /*--------------------------------------------------------------
3122 LPCWSTR lpConsoleTitle
3125 PCSR_API_MESSAGE Request
; ULONG CsrRequest
;
3130 hConsole
= CreateFileW(L
"CONIN$", GENERIC_WRITE
, 0, NULL
, OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
3131 if (hConsole
== INVALID_HANDLE_VALUE
)
3136 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
3137 max (sizeof(CSR_API_MESSAGE
),
3138 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_SET_TITLE
) +
3139 min (wcslen(lpConsoleTitle
), CSRSS_MAX_TITLE_LENGTH
) * sizeof(WCHAR
)));
3140 if (Request
== NULL
)
3142 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
3146 CsrRequest
= MAKE_CSR_API(SET_TITLE
, CSR_CONSOLE
);
3147 Request
->Data
.SetTitleRequest
.Console
= hConsole
;
3149 for( c
= 0; lpConsoleTitle
[c
] && c
< CSRSS_MAX_TITLE_LENGTH
; c
++ )
3150 Request
->Data
.SetTitleRequest
.Title
[c
] = lpConsoleTitle
[c
];
3151 Request
->Data
.SetTitleRequest
.Length
= c
* sizeof(WCHAR
);
3152 Status
= CsrClientCallServer(Request
,
3155 max (sizeof(CSR_API_MESSAGE
), CSR_API_MESSAGE_HEADER_SIZE(CSRSS_SET_TITLE
) + c
* sizeof(WCHAR
)));
3156 CloseHandle(hConsole
);
3157 if (!NT_SUCCESS(Status
) || !NT_SUCCESS( Status
= Request
->Status
) )
3159 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
3160 SetLastErrorByStatus (Status
);
3164 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
3170 /*--------------------------------------------------------------
3180 LPCSTR lpConsoleTitle
3183 PCSR_API_MESSAGE Request
; ULONG CsrRequest
;
3188 hConsole
= CreateFileW(L
"CONIN$", GENERIC_WRITE
, 0, NULL
, OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
3189 if (hConsole
== INVALID_HANDLE_VALUE
)
3194 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
3195 max (sizeof(CSR_API_MESSAGE
),
3196 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_SET_TITLE
) +
3197 min (strlen(lpConsoleTitle
), CSRSS_MAX_TITLE_LENGTH
) * sizeof(WCHAR
)));
3198 if (Request
== NULL
)
3200 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
3204 CsrRequest
= MAKE_CSR_API(SET_TITLE
, CSR_CONSOLE
);
3205 Request
->Data
.SetTitleRequest
.Console
= hConsole
;
3207 for( c
= 0; lpConsoleTitle
[c
] && c
< CSRSS_MAX_TITLE_LENGTH
; c
++ )
3208 Request
->Data
.SetTitleRequest
.Title
[c
] = lpConsoleTitle
[c
];
3209 Request
->Data
.SetTitleRequest
.Length
= c
* sizeof(WCHAR
);
3210 Status
= CsrClientCallServer(Request
,
3213 max (sizeof(CSR_API_MESSAGE
), CSR_API_MESSAGE_HEADER_SIZE(CSRSS_SET_TITLE
) + c
* sizeof(WCHAR
)));
3214 CloseHandle(hConsole
);
3215 if (!NT_SUCCESS(Status
) || !NT_SUCCESS( Status
= Request
->Status
) )
3217 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
3218 SetLastErrorByStatus (Status
);
3222 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
3228 /*--------------------------------------------------------------
3229 * CreateConsoleScreenBuffer
3235 CreateConsoleScreenBuffer(
3236 DWORD dwDesiredAccess
,
3238 CONST SECURITY_ATTRIBUTES
*lpSecurityAttributes
,
3240 LPVOID lpScreenBufferData
3243 // FIXME: don't ignore access, share mode, and security
3244 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
3248 CsrRequest
= MAKE_CSR_API(CREATE_SCREEN_BUFFER
, CSR_CONSOLE
);
3249 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
3250 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Request
.Status
) )
3252 SetLastErrorByStatus ( Status
);
3255 return Request
.Data
.CreateScreenBufferRequest
.OutputHandle
;
3259 /*--------------------------------------------------------------
3266 GetConsoleCP( VOID
)
3268 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
3272 CsrRequest
= MAKE_CSR_API(GET_CONSOLE_CP
, CSR_CONSOLE
);
3273 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
,
3274 sizeof(CSR_API_MESSAGE
));
3275 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3277 SetLastErrorByStatus (Status
);
3280 return Request
.Data
.GetConsoleCodePage
.CodePage
;
3284 /*--------------------------------------------------------------
3295 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
3299 CsrRequest
= MAKE_CSR_API(SET_CONSOLE_CP
, CSR_CONSOLE
);
3300 Request
.Data
.SetConsoleCodePage
.CodePage
= wCodePageID
;
3301 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
,
3302 sizeof(CSR_API_MESSAGE
));
3303 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3305 SetLastErrorByStatus (Status
);
3307 return NT_SUCCESS(Status
);
3311 /*--------------------------------------------------------------
3312 * GetConsoleOutputCP
3318 GetConsoleOutputCP( VOID
)
3320 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
3324 CsrRequest
= MAKE_CSR_API(GET_CONSOLE_OUTPUT_CP
, CSR_CONSOLE
);
3325 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
,
3326 sizeof(CSR_API_MESSAGE
));
3327 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3329 SetLastErrorByStatus (Status
);
3332 return Request
.Data
.GetConsoleOutputCodePage
.CodePage
;
3336 /*--------------------------------------------------------------
3337 * SetConsoleOutputCP
3347 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
3351 CsrRequest
= MAKE_CSR_API(SET_CONSOLE_OUTPUT_CP
, CSR_CONSOLE
);
3352 Request
.Data
.SetConsoleOutputCodePage
.CodePage
= wCodePageID
;
3353 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
,
3354 sizeof(CSR_API_MESSAGE
));
3355 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3357 SetLastErrorByStatus (Status
);
3359 return NT_SUCCESS(Status
);
3363 /*--------------------------------------------------------------
3364 * GetConsoleProcessList
3369 GetConsoleProcessList(LPDWORD lpdwProcessList
,
3370 DWORD dwProcessCount
)
3372 PCSR_API_MESSAGE Request
; ULONG CsrRequest
;
3376 if(lpdwProcessList
== NULL
|| dwProcessCount
== 0)
3378 SetLastError(ERROR_INVALID_PARAMETER
);
3382 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
3383 max (sizeof(CSR_API_MESSAGE
),
3384 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_GET_PROCESS_LIST
)
3385 + min (dwProcessCount
, CSRSS_MAX_GET_PROCESS_LIST
/ sizeof(DWORD
)) * sizeof(DWORD
)));
3386 if (Request
== NULL
)
3388 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
3392 CsrRequest
= MAKE_CSR_API(GET_PROCESS_LIST
, CSR_CONSOLE
);
3393 Request
->Data
.GetProcessListRequest
.nMaxIds
= min (dwProcessCount
, CSRSS_MAX_GET_PROCESS_LIST
/ sizeof(DWORD
));
3395 Status
= CsrClientCallServer(Request
,
3398 max (sizeof(CSR_API_MESSAGE
),
3399 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_GET_PROCESS_LIST
)
3400 + Request
->Data
.GetProcessListRequest
.nMaxIds
* sizeof(DWORD
)));
3401 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
->Status
))
3403 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
3404 SetLastErrorByStatus (Status
);
3409 nProcesses
= Request
->Data
.GetProcessListRequest
.nProcessIdsCopied
;
3410 if(dwProcessCount
>= nProcesses
)
3412 memcpy(lpdwProcessList
, Request
->Data
.GetProcessListRequest
.ProcessId
, nProcesses
* sizeof(DWORD
));
3416 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
3423 /*--------------------------------------------------------------
3424 * GetConsoleSelectionInfo
3429 GetConsoleSelectionInfo(PCONSOLE_SELECTION_INFO lpConsoleSelectionInfo
)
3431 DPRINT1("GetConsoleSelectionInfo(0x%x) UNIMPLEMENTED!\n", lpConsoleSelectionInfo
);
3432 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3438 /*--------------------------------------------------------------
3444 AttachConsole(DWORD dwProcessId
)
3446 DPRINT1("AttachConsole(0x%x) UNIMPLEMENTED!\n", dwProcessId
);
3447 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3451 /*--------------------------------------------------------------
3457 GetConsoleWindow (VOID
)
3459 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
3463 CsrRequest
= MAKE_CSR_API(GET_CONSOLE_WINDOW
, CSR_CONSOLE
);
3464 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
3465 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3467 SetLastErrorByStatus (Status
);
3470 return Request
.Data
.GetConsoleWindowRequest
.WindowHandle
;
3474 /*--------------------------------------------------------------
3479 BOOL STDCALL
SetConsoleIcon(HICON hicon
)
3481 CSR_API_MESSAGE Request
; ULONG CsrRequest
;
3485 CsrRequest
= MAKE_CSR_API(SET_CONSOLE_ICON
, CSR_CONSOLE
);
3486 Request
.Data
.SetConsoleIconRequest
.WindowIcon
= hicon
;
3487 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
3488 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3490 SetLastErrorByStatus (Status
);
3493 return NT_SUCCESS(Status
);
3497 /*--------------------------------------------------------------
3498 * SetConsoleInputExeNameW
3503 SetConsoleInputExeNameW(LPCWSTR lpInputExeName
)
3506 int lenName
= lstrlenW(lpInputExeName
);
3509 lenName
> (int)(sizeof(InputExeName
) / sizeof(InputExeName
[0])) - 1)
3511 /* Fail if string is empty or too long */
3512 SetLastError(ERROR_INVALID_PARAMETER
);
3516 RtlEnterCriticalSection(&ConsoleLock
);
3517 /* wrap copying into SEH as we may copy from invalid buffer and in case of an
3518 exception the console lock would've never been released, which would cause
3519 further calls (if the exception was handled by the caller) to recursively
3520 acquire the lock... */
3523 RtlCopyMemory(InputExeName
, lpInputExeName
, lenName
* sizeof(WCHAR
));
3524 InputExeName
[lenName
] = L
'\0';
3530 SetLastErrorByStatus(_SEH_GetExceptionCode());
3533 RtlLeaveCriticalSection(&ConsoleLock
);
3539 /*--------------------------------------------------------------
3540 * SetConsoleInputExeNameA
3545 SetConsoleInputExeNameA(LPCSTR lpInputExeName
)
3547 ANSI_STRING InputExeNameA
;
3548 UNICODE_STRING InputExeNameU
;
3552 RtlInitAnsiString(&InputExeNameA
, lpInputExeName
);
3554 if(InputExeNameA
.Length
< sizeof(InputExeNameA
.Buffer
[0]) ||
3555 InputExeNameA
.Length
>= (sizeof(InputExeName
) / sizeof(InputExeName
[0])) - 1)
3557 /* Fail if string is empty or too long */
3558 SetLastError(ERROR_INVALID_PARAMETER
);
3562 Status
= RtlAnsiStringToUnicodeString(&InputExeNameU
, &InputExeNameA
, TRUE
);
3563 if(NT_SUCCESS(Status
))
3565 Ret
= SetConsoleInputExeNameW(InputExeNameU
.Buffer
);
3566 RtlFreeUnicodeString(&InputExeNameU
);
3570 SetLastErrorByStatus(Status
);
3578 /*--------------------------------------------------------------
3579 * GetConsoleInputExeNameW
3584 GetConsoleInputExeNameW(DWORD nBufferLength
, LPWSTR lpBuffer
)
3588 RtlEnterCriticalSection(&ConsoleLock
);
3590 lenName
= lstrlenW(InputExeName
);
3591 if(lenName
>= (int)nBufferLength
)
3593 /* buffer is not large enough, return the required size */
3594 RtlLeaveCriticalSection(&ConsoleLock
);
3598 /* wrap copying into SEH as we may copy to invalid buffer and in case of an
3599 exception the console lock would've never been released, which would cause
3600 further calls (if the exception was handled by the caller) to recursively
3601 acquire the lock... */
3604 RtlCopyMemory(lpBuffer
, InputExeName
, (lenName
+ 1) * sizeof(WCHAR
));
3609 SetLastErrorByStatus(_SEH_GetExceptionCode());
3613 RtlLeaveCriticalSection(&ConsoleLock
);
3619 /*--------------------------------------------------------------
3620 * GetConsoleInputExeNameA
3625 GetConsoleInputExeNameA(DWORD nBufferLength
, LPSTR lpBuffer
)
3630 if(nBufferLength
> 0)
3632 Buffer
= RtlAllocateHeap(RtlGetProcessHeap(), 0, nBufferLength
* sizeof(WCHAR
));
3635 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
3644 Ret
= GetConsoleInputExeNameW(nBufferLength
, Buffer
);
3645 if(nBufferLength
> 0)
3649 UNICODE_STRING BufferU
;
3650 ANSI_STRING BufferA
;
3652 RtlInitUnicodeString(&BufferU
, Buffer
);
3655 BufferA
.MaximumLength
= nBufferLength
;
3656 BufferA
.Buffer
= lpBuffer
;
3658 RtlUnicodeStringToAnsiString(&BufferA
, &BufferU
, FALSE
);
3661 RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer
);
3668 /*--------------------------------------------------------------
3669 * GetConsoleHistoryInfo
3674 GetConsoleHistoryInfo(PCONSOLE_HISTORY_INFO lpConsoleHistoryInfo
)
3676 DPRINT1("GetConsoleHistoryInfo(0x%p) UNIMPLEMENTED!\n", lpConsoleHistoryInfo
);
3677 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3682 /*--------------------------------------------------------------
3683 * SetConsoleHistoryInfo
3688 SetConsoleHistoryInfo(IN PCONSOLE_HISTORY_INFO lpConsoleHistoryInfo
)
3690 DPRINT1("SetConsoleHistoryInfo(0x%p) UNIMPLEMENTED!\n", lpConsoleHistoryInfo
);
3691 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3696 /*--------------------------------------------------------------
3697 * GetConsoleOriginalTitleW
3702 GetConsoleOriginalTitleW(OUT LPWSTR lpConsoleTitle
,
3705 DPRINT1("GetConsoleOriginalTitleW(0x%p, 0x%x) UNIMPLEMENTED!\n", lpConsoleTitle
, nSize
);
3706 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3711 /*--------------------------------------------------------------
3712 * GetConsoleOriginalTitleA
3717 GetConsoleOriginalTitleA(OUT LPSTR lpConsoleTitle
,
3720 DPRINT1("GetConsoleOriginalTitleA(0x%p, 0x%x) UNIMPLEMENTED!\n", lpConsoleTitle
, nSize
);
3721 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3726 /*--------------------------------------------------------------
3727 * GetConsoleScreenBufferInfoEx
3732 GetConsoleScreenBufferInfoEx(IN HANDLE hConsoleOutput
,
3733 OUT PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx
)
3735 DPRINT1("GetConsoleScreenBufferInfoEx(0x%p, 0x%p) UNIMPLEMENTED!\n", hConsoleOutput
, lpConsoleScreenBufferInfoEx
);
3736 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3741 /*--------------------------------------------------------------
3742 * SetConsoleScreenBufferInfoEx
3747 SetConsoleScreenBufferInfoEx(IN HANDLE hConsoleOutput
,
3748 IN PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx
)
3750 DPRINT1("SetConsoleScreenBufferInfoEx(0x%p, 0x%p) UNIMPLEMENTED!\n", hConsoleOutput
, lpConsoleScreenBufferInfoEx
);
3751 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3756 /*--------------------------------------------------------------
3757 * GetCurrentConsoleFontEx
3762 GetCurrentConsoleFontEx(IN HANDLE hConsoleOutput
,
3763 IN BOOL bMaximumWindow
,
3764 OUT PCONSOLE_FONT_INFOEX lpConsoleCurrentFontEx
)
3766 DPRINT1("GetCurrentConsoleFontEx(0x%p, 0x%x, 0x%p) UNIMPLEMENTED!\n", hConsoleOutput
, bMaximumWindow
, lpConsoleCurrentFontEx
);
3767 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);