1 /* $Id: console.c,v 1.78 2004/08/24 17:21:11 navaraf Exp $
3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS system libraries
5 * FILE: lib/kernel32/misc/console.c
6 * PURPOSE: Win32 server console functions
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 #define _NOACHS(__X) (sizeof(__X) / sizeof((__X)[0]))
23 extern BOOL WINAPI
DefaultConsoleCtrlHandler(DWORD Event
);
24 extern __declspec(noreturn
) VOID CALLBACK
ConsoleControlDispatcher(DWORD CodeAndFlag
);
25 extern CRITICAL_SECTION ConsoleLock
;
26 extern BOOL WINAPI
IsDebuggerPresent(VOID
);
29 /* GLOBALS *******************************************************************/
31 static BOOL IgnoreCtrlEvents
= FALSE
;
33 static PHANDLER_ROUTINE
* CtrlHandlers
= NULL
;
34 static ULONG NrCtrlHandlers
= 0;
36 /* Default Console Control Handler *******************************************/
38 BOOL WINAPI
DefaultConsoleCtrlHandler(DWORD Event
)
43 DPRINT("Ctrl-C Event\n");
47 case CTRL_BREAK_EVENT
:
48 DPRINT("Ctrl-Break Event\n");
52 case CTRL_SHUTDOWN_EVENT
:
53 DPRINT("Ctrl Shutdown Event\n");
56 case CTRL_CLOSE_EVENT
:
57 DPRINT("Ctrl Close Event\n");
60 case CTRL_LOGOFF_EVENT
:
61 DPRINT("Ctrl Logoff Event\n");
64 // ExitProcess((UINT)&ExitCode);
69 __declspec(noreturn
) VOID CALLBACK
ConsoleControlDispatcher(DWORD CodeAndFlag
)
72 DWORD nCode
= CodeAndFlag
& MAXLONG
;
75 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST
);
80 case CTRL_BREAK_EVENT
:
82 if(IsDebuggerPresent())
84 EXCEPTION_RECORD erException
;
85 erException
.ExceptionCode
=
86 (nCode
== CTRL_C_EVENT
? DBG_CONTROL_C
: DBG_CONTROL_BREAK
);
87 erException
.ExceptionFlags
= 0;
88 erException
.ExceptionRecord
= NULL
;
89 erException
.ExceptionAddress
= &DefaultConsoleCtrlHandler
;
90 erException
.NumberParameters
= 0;
91 RtlRaiseException(&erException
);
93 RtlEnterCriticalSection(&ConsoleLock
);
95 if(!(nCode
== CTRL_C_EVENT
&&
96 NtCurrentPeb()->ProcessParameters
->ProcessGroup
& 1))
98 for(i
= NrCtrlHandlers
; i
> 0; -- i
)
99 if(CtrlHandlers
[i
- 1](nCode
)) break;
101 RtlLeaveCriticalSection(&ConsoleLock
);
104 case CTRL_CLOSE_EVENT
:
105 case CTRL_LOGOFF_EVENT
:
106 case CTRL_SHUTDOWN_EVENT
:
109 default: ExitThread(0);
112 RtlEnterCriticalSection(&ConsoleLock
);
114 if(!(nCode
== CTRL_C_EVENT
&&
115 NtCurrentPeb()->ProcessParameters
->ProcessGroup
& 1))
120 if (i
== 1 && (CodeAndFlag
& MINLONG
) &&
121 (nCode
== CTRL_LOGOFF_EVENT
|| nCode
== CTRL_SHUTDOWN_EVENT
))
124 if(CtrlHandlers
[i
- 1](nCode
))
128 case CTRL_CLOSE_EVENT
:
129 case CTRL_LOGOFF_EVENT
:
130 case CTRL_SHUTDOWN_EVENT
:
131 nExitCode
= CodeAndFlag
;
138 RtlLeaveCriticalSection(&ConsoleLock
);
139 ExitThread(nExitCode
);
143 /* FUNCTIONS *****************************************************************/
149 AddConsoleAliasA (LPSTR Source
,
153 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
162 AddConsoleAliasW (LPWSTR Source
,
166 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
175 ConsoleMenuControl (HANDLE hConsole
,
182 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
191 DuplicateConsoleHandle (HANDLE hConsole
,
192 DWORD dwDesiredAccess
,
196 CSRSS_API_REQUEST Request
;
197 CSRSS_API_REPLY Reply
;
200 if (IsConsoleHandle (hConsole
) == FALSE
)
202 SetLastError (ERROR_INVALID_PARAMETER
);
203 return INVALID_HANDLE_VALUE
;
206 Request
.Type
= CSRSS_DUPLICATE_HANDLE
;
207 Request
.Data
.DuplicateHandleRequest
.Handle
= hConsole
;
208 Request
.Data
.DuplicateHandleRequest
.ProcessId
= GetCurrentProcessId();
209 Status
= CsrClientCallServer(&Request
,
211 sizeof(CSRSS_API_REQUEST
),
212 sizeof(CSRSS_API_REPLY
));
213 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
=Reply
.Status
))
215 SetLastErrorByStatus(Status
);
216 return INVALID_HANDLE_VALUE
;
218 return Reply
.Data
.DuplicateHandleReply
.Handle
;
226 ExpungeConsoleCommandHistoryW (DWORD Unknown0
)
231 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
240 ExpungeConsoleCommandHistoryA (DWORD Unknown0
)
245 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
254 GetConsoleAliasW (DWORD Unknown0
,
262 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
271 GetConsoleAliasA (DWORD Unknown0
,
279 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
288 GetConsoleAliasExesW (DWORD Unknown0
,
294 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
303 GetConsoleAliasExesA (DWORD Unknown0
,
309 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
318 GetConsoleAliasExesLengthA (VOID
)
323 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
332 GetConsoleAliasExesLengthW (VOID
)
337 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
346 GetConsoleAliasesW (DWORD Unknown0
,
353 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
362 GetConsoleAliasesA (DWORD Unknown0
,
369 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
378 GetConsoleAliasesLengthW (DWORD Unknown0
)
383 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
392 GetConsoleAliasesLengthA (DWORD Unknown0
)
397 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
406 GetConsoleCommandHistoryW (DWORD Unknown0
,
413 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
422 GetConsoleCommandHistoryA (DWORD Unknown0
,
429 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
438 GetConsoleCommandHistoryLengthW (DWORD Unknown0
)
443 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
452 GetConsoleCommandHistoryLengthA (DWORD Unknown0
)
457 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
465 GetConsoleDisplayMode (LPDWORD lpdwMode
)
467 * FUNCTION: Get the console display mode
469 * lpdwMode - Address of variable that receives the current value
471 * STATUS: Undocumented
474 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
483 GetConsoleFontInfo (DWORD Unknown0
,
491 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
500 GetConsoleFontSize(HANDLE hConsoleOutput
,
503 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
512 GetConsoleHardwareState (HANDLE hConsole
,
519 CSRSS_API_REQUEST Request
;
520 CSRSS_API_REPLY Reply
;
523 Request
.Type
= CSRSS_SETGET_CONSOLE_HW_STATE
;
524 Request
.Data
.ConsoleHardwareStateRequest
.ConsoleHandle
= hConsole
;
525 Request
.Data
.ConsoleHardwareStateRequest
.SetGet
= CONSOLE_HARDWARE_STATE_GET
;
527 Status
= CsrClientCallServer(& Request
,
529 sizeof(CSRSS_API_REQUEST
),
530 sizeof(CSRSS_API_REPLY
));
531 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
533 SetLastErrorByStatus(Status
);
536 *State
= Reply
.Data
.ConsoleHardwareStateReply
.State
;
545 GetConsoleInputWaitHandle (VOID
)
550 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
559 GetCurrentConsoleFont(HANDLE hConsoleOutput
,
561 PCONSOLE_FONT_INFO lpConsoleCurrentFont
)
563 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
572 GetNumberOfConsoleFonts (VOID
)
577 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
578 return 1; /* FIXME: call csrss.exe */
586 InvalidateConsoleDIBits (DWORD Unknown0
,
592 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
601 OpenConsoleW (LPWSTR wsName
,
602 DWORD dwDesiredAccess
,
604 DWORD dwCreationDistribution
)
609 CSRSS_API_REQUEST Request
;
610 CSRSS_API_REPLY Reply
;
611 PHANDLE phConsole
= NULL
;
612 NTSTATUS Status
= STATUS_SUCCESS
;
615 if(0 == _wcsicmp(wsName
, L
"CONIN$"))
617 Request
.Type
= CSRSS_GET_INPUT_HANDLE
;
618 phConsole
= & Reply
.Data
.GetInputHandleReply
.InputHandle
;
620 else if (0 == _wcsicmp(wsName
, L
"CONOUT$"))
622 Request
.Type
= CSRSS_GET_OUTPUT_HANDLE
;
623 phConsole
= & Reply
.Data
.GetOutputHandleReply
.OutputHandle
;
627 SetLastError(ERROR_INVALID_PARAMETER
);
628 return(INVALID_HANDLE_VALUE
);
630 if ((GENERIC_READ
|GENERIC_WRITE
) != dwDesiredAccess
)
632 SetLastError(ERROR_INVALID_PARAMETER
);
633 return(INVALID_HANDLE_VALUE
);
635 if (OPEN_EXISTING
!= dwCreationDistribution
)
637 SetLastError(ERROR_INVALID_PARAMETER
);
638 return(INVALID_HANDLE_VALUE
);
640 Status
= CsrClientCallServer(& Request
,
642 sizeof(CSRSS_API_REQUEST
),
643 sizeof(CSRSS_API_REPLY
));
644 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
646 SetLastErrorByStatus(Status
);
647 return INVALID_HANDLE_VALUE
;
657 SetConsoleCommandHistoryMode (DWORD dwMode
)
662 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
671 SetConsoleCursor (DWORD Unknown0
,
677 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
686 SetConsoleDisplayMode (HANDLE hOut
,
690 * FUNCTION: Set the console display mode.
692 * hOut - Standard output handle.
693 * dwNewMode - New mode.
694 * lpdwOldMode - Address of a variable that receives the old mode.
697 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
706 SetConsoleFont (DWORD Unknown0
,
712 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
721 SetConsoleHardwareState (HANDLE hConsole
,
728 CSRSS_API_REQUEST Request
;
729 CSRSS_API_REPLY Reply
;
732 Request
.Type
= CSRSS_SETGET_CONSOLE_HW_STATE
;
733 Request
.Data
.ConsoleHardwareStateRequest
.ConsoleHandle
= hConsole
;
734 Request
.Data
.ConsoleHardwareStateRequest
.SetGet
= CONSOLE_HARDWARE_STATE_SET
;
735 Request
.Data
.ConsoleHardwareStateRequest
.State
= State
;
737 Status
= CsrClientCallServer(& Request
,
739 sizeof(CSRSS_API_REQUEST
),
740 sizeof(CSRSS_API_REPLY
));
741 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
743 SetLastErrorByStatus(Status
);
754 SetConsoleKeyShortcuts (DWORD Unknown0
,
762 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
771 SetConsoleMaximumWindowSize (DWORD Unknown0
,
777 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
786 SetConsoleMenuClose (DWORD Unknown0
)
791 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
800 SetConsoleNumberOfCommandsA (DWORD Unknown0
,
806 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
815 SetConsoleNumberOfCommandsW (DWORD Unknown0
,
821 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
830 SetConsolePalette (DWORD Unknown0
,
837 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
846 SetLastConsoleEventActive (VOID
)
851 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
860 ShowConsoleCursor (DWORD Unknown0
,
866 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
872 * FUNCTION: Checks whether the given handle is a valid console handle.
874 * Handle - Handle to be checked
876 * TRUE: Handle is a valid console handle
877 * FALSE: Handle is not a valid console handle.
878 * STATUS: Officially undocumented
883 VerifyConsoleIoHandle(HANDLE Handle
)
885 CSRSS_API_REQUEST Request
;
886 CSRSS_API_REPLY Reply
;
889 Request
.Type
= CSRSS_VERIFY_HANDLE
;
890 Request
.Data
.VerifyHandleRequest
.Handle
= Handle
;
891 Status
= CsrClientCallServer(&Request
,
893 sizeof(CSRSS_API_REQUEST
),
894 sizeof(CSRSS_API_REPLY
));
895 if (!NT_SUCCESS(Status
))
897 SetLastErrorByStatus(Status
);
901 return (BOOL
)NT_SUCCESS(Reply
.Status
);
909 WriteConsoleInputVDMA (DWORD Unknown0
,
914 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
923 WriteConsoleInputVDMW (DWORD Unknown0
,
928 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
937 CloseConsoleHandle(HANDLE Handle
)
942 CSRSS_API_REQUEST Request
;
943 CSRSS_API_REPLY Reply
;
946 if (IsConsoleHandle (Handle
) == FALSE
)
948 SetLastError (ERROR_INVALID_PARAMETER
);
952 Request
.Type
= CSRSS_CLOSE_HANDLE
;
953 Request
.Data
.CloseHandleRequest
.Handle
= Handle
;
954 Status
= CsrClientCallServer(&Request
,
956 sizeof(CSRSS_API_REQUEST
),
957 sizeof(CSRSS_API_REPLY
));
958 if (!NT_SUCCESS(Status
))
960 SetLastErrorByStatus(Status
);
972 IsConsoleHandle(HANDLE Handle
)
974 if ((((ULONG
)Handle
) & 0x10000003) == 0x3)
986 GetStdHandle(DWORD nStdHandle
)
988 * FUNCTION: Get a handle for the standard input, standard output
989 * and a standard error device.
991 * nStdHandle - Specifies the device for which to return the handle.
992 * RETURNS: If the function succeeds, the return value is the handle
993 * of the specified device. Otherwise the value is INVALID_HANDLE_VALUE.
996 PRTL_USER_PROCESS_PARAMETERS Ppb
;
998 Ppb
= NtCurrentPeb()->ProcessParameters
;
1001 case STD_INPUT_HANDLE
:
1002 return Ppb
->hStdInput
;
1004 case STD_OUTPUT_HANDLE
:
1005 return Ppb
->hStdOutput
;
1007 case STD_ERROR_HANDLE
:
1008 return Ppb
->hStdError
;
1011 SetLastError (ERROR_INVALID_PARAMETER
);
1012 return INVALID_HANDLE_VALUE
;
1020 SetStdHandle(DWORD nStdHandle
,
1023 * FUNCTION: Set the handle for the standard input, standard output or
1024 * the standard error device.
1026 * nStdHandle - Specifies the handle to be set.
1027 * hHandle - The handle to set.
1028 * RETURNS: TRUE if the function succeeds, FALSE otherwise.
1031 PRTL_USER_PROCESS_PARAMETERS Ppb
;
1033 /* no need to check if hHandle == INVALID_HANDLE_VALUE */
1035 Ppb
= NtCurrentPeb()->ProcessParameters
;
1039 case STD_INPUT_HANDLE
:
1040 Ppb
->hStdInput
= hHandle
;
1043 case STD_OUTPUT_HANDLE
:
1044 Ppb
->hStdOutput
= hHandle
;
1047 case STD_ERROR_HANDLE
:
1048 Ppb
->hStdError
= hHandle
;
1052 /* windows for whatever reason sets the last error to ERROR_INVALID_HANDLE here */
1053 SetLastError (ERROR_INVALID_HANDLE
);
1058 /*--------------------------------------------------------------
1064 WriteConsoleA(HANDLE hConsoleOutput
,
1065 CONST VOID
*lpBuffer
,
1066 DWORD nNumberOfCharsToWrite
,
1067 LPDWORD lpNumberOfCharsWritten
,
1070 PCSRSS_API_REQUEST Request
;
1071 CSRSS_API_REPLY Reply
;
1076 Request
= RtlAllocateHeap(GetProcessHeap(), 0,
1077 sizeof(CSRSS_API_REQUEST
) +
1078 min(nNumberOfCharsToWrite
,
1079 CSRSS_MAX_WRITE_CONSOLE_REQUEST
));
1080 if (Request
== NULL
)
1082 SetLastError(ERROR_OUTOFMEMORY
);
1086 Request
->Type
= CSRSS_WRITE_CONSOLE
;
1087 Request
->Data
.WriteConsoleRequest
.ConsoleHandle
= hConsoleOutput
;
1088 if (lpNumberOfCharsWritten
!= NULL
)
1089 *lpNumberOfCharsWritten
= nNumberOfCharsToWrite
;
1090 while (nNumberOfCharsToWrite
)
1092 if (nNumberOfCharsToWrite
> CSRSS_MAX_WRITE_CONSOLE_REQUEST
)
1094 Size
= CSRSS_MAX_WRITE_CONSOLE_REQUEST
;
1098 Size
= nNumberOfCharsToWrite
;
1100 Request
->Data
.WriteConsoleRequest
.NrCharactersToWrite
= Size
;
1102 memcpy(Request
->Data
.WriteConsoleRequest
.Buffer
, lpBuffer
, Size
);
1104 MessageSize
= CSRSS_REQUEST_HEADER_SIZE
+
1105 sizeof(CSRSS_WRITE_CONSOLE_REQUEST
) + Size
;
1106 Status
= CsrClientCallServer(Request
,
1109 sizeof(CSRSS_API_REPLY
));
1111 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1113 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1114 SetLastErrorByStatus(Status
);
1117 nNumberOfCharsToWrite
-= Size
;
1121 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1127 /*--------------------------------------------------------------
1132 BOOL STDCALL
ReadConsoleA(HANDLE hConsoleInput
,
1134 DWORD nNumberOfCharsToRead
,
1135 LPDWORD lpNumberOfCharsRead
,
1138 CSRSS_API_REQUEST Request
;
1139 PCSRSS_API_REPLY Reply
;
1141 ULONG CharsRead
= 0;
1143 Reply
= RtlAllocateHeap(GetProcessHeap(), 0,
1144 sizeof(CSRSS_API_REPLY
) + nNumberOfCharsToRead
);
1147 SetLastError(ERROR_OUTOFMEMORY
);
1151 Request
.Type
= CSRSS_READ_CONSOLE
;
1152 Request
.Data
.ReadConsoleRequest
.ConsoleHandle
= hConsoleInput
;
1153 Request
.Data
.ReadConsoleRequest
.NrCharactersToRead
= nNumberOfCharsToRead
> CSRSS_MAX_READ_CONSOLE_REQUEST
? CSRSS_MAX_READ_CONSOLE_REQUEST
: nNumberOfCharsToRead
;
1154 Request
.Data
.ReadConsoleRequest
.nCharsCanBeDeleted
= 0;
1155 Status
= CsrClientCallServer(&Request
,
1157 sizeof(CSRSS_API_REQUEST
),
1158 sizeof(CSRSS_API_REPLY
) +
1159 Request
.Data
.ReadConsoleRequest
.NrCharactersToRead
);
1160 if (!NT_SUCCESS(Status
) || !NT_SUCCESS( Status
= Reply
->Status
))
1162 DbgPrint( "CSR returned error in ReadConsole\n" );
1163 SetLastErrorByStatus ( Status
);
1164 RtlFreeHeap( GetProcessHeap(), 0, Reply
);
1167 if( Reply
->Status
== STATUS_NOTIFY_CLEANUP
)
1168 Reply
->Status
= STATUS_PENDING
; // ignore backspace because we have no chars to backspace
1169 /* There may not be any chars or lines to read yet, so wait */
1170 while( Reply
->Status
== STATUS_PENDING
)
1172 /* some chars may have been returned, but not a whole line yet, so recompute buffer and try again */
1173 nNumberOfCharsToRead
-= Reply
->Data
.ReadConsoleReply
.NrCharactersRead
;
1174 /* don't overflow caller's buffer, even if you still don't have a complete line */
1175 if( !nNumberOfCharsToRead
)
1177 Request
.Data
.ReadConsoleRequest
.NrCharactersToRead
= nNumberOfCharsToRead
> CSRSS_MAX_READ_CONSOLE_REQUEST
? CSRSS_MAX_READ_CONSOLE_REQUEST
: nNumberOfCharsToRead
;
1178 /* copy any chars already read to buffer */
1179 memcpy( lpBuffer
+ CharsRead
, Reply
->Data
.ReadConsoleReply
.Buffer
, Reply
->Data
.ReadConsoleReply
.NrCharactersRead
);
1180 CharsRead
+= Reply
->Data
.ReadConsoleReply
.NrCharactersRead
;
1181 /* wait for csrss to signal there is more data to read, but not if we got STATUS_NOTIFY_CLEANUP for backspace */
1182 Status
= NtWaitForSingleObject( Reply
->Data
.ReadConsoleReply
.EventHandle
, FALSE
, 0 );
1183 if( !NT_SUCCESS( Status
) )
1185 DbgPrint( "Wait for console input failed!\n" );
1186 RtlFreeHeap( GetProcessHeap(), 0, Reply
);
1189 Request
.Data
.ReadConsoleRequest
.nCharsCanBeDeleted
= CharsRead
;
1190 Status
= CsrClientCallServer( &Request
, Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) + Request
.Data
.ReadConsoleRequest
.NrCharactersToRead
);
1191 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
->Status
) )
1193 SetLastErrorByStatus ( Status
);
1194 RtlFreeHeap( GetProcessHeap(), 0, Reply
);
1197 if( Reply
->Status
== STATUS_NOTIFY_CLEANUP
)
1203 nNumberOfCharsToRead
++;
1205 Reply
->Status
= STATUS_PENDING
; // retry
1208 /* copy data to buffer, count total returned, and return */
1209 memcpy( lpBuffer
+ CharsRead
, Reply
->Data
.ReadConsoleReply
.Buffer
, Reply
->Data
.ReadConsoleReply
.NrCharactersRead
);
1210 CharsRead
+= Reply
->Data
.ReadConsoleReply
.NrCharactersRead
;
1211 if (lpNumberOfCharsRead
!= NULL
)
1212 *lpNumberOfCharsRead
= CharsRead
;
1213 RtlFreeHeap(GetProcessHeap(),
1221 /*--------------------------------------------------------------
1226 BOOL STDCALL
AllocConsole(VOID
)
1228 CSRSS_API_REQUEST Request
;
1229 CSRSS_API_REPLY Reply
;
1233 if(NtCurrentPeb()->ProcessParameters
->hConsole
)
1235 DPRINT("AllocConsole: Allocate duplicate console to the same Process\n");
1236 SetLastErrorByStatus (STATUS_OBJECT_NAME_EXISTS
);
1240 Request
.Data
.AllocConsoleRequest
.CtrlDispatcher
= (PCONTROLDISPATCHER
) &ConsoleControlDispatcher
;
1242 Request
.Type
= CSRSS_ALLOC_CONSOLE
;
1243 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
1244 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1246 SetLastErrorByStatus ( Status
);
1249 NtCurrentPeb()->ProcessParameters
->hConsole
= Reply
.Data
.AllocConsoleReply
.Console
;
1250 SetStdHandle( STD_INPUT_HANDLE
, Reply
.Data
.AllocConsoleReply
.InputHandle
);
1251 SetStdHandle( STD_OUTPUT_HANDLE
, Reply
.Data
.AllocConsoleReply
.OutputHandle
);
1252 hStdError
= DuplicateConsoleHandle(Reply
.Data
.AllocConsoleReply
.OutputHandle
,
1255 DUPLICATE_SAME_ACCESS
);
1256 SetStdHandle( STD_ERROR_HANDLE
, hStdError
);
1261 /*--------------------------------------------------------------
1266 BOOL STDCALL
FreeConsole(VOID
)
1268 // AG: I'm not sure if this is correct (what happens to std handles?)
1269 // but I just tried to reverse what AllocConsole() does...
1271 CSRSS_API_REQUEST Request
;
1272 CSRSS_API_REPLY Reply
;
1275 Request
.Type
= CSRSS_FREE_CONSOLE
;
1276 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
1277 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1279 SetLastErrorByStatus ( Status
);
1287 /*--------------------------------------------------------------
1288 * GetConsoleScreenBufferInfo
1294 GetConsoleScreenBufferInfo(
1295 HANDLE hConsoleOutput
,
1296 PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo
1299 CSRSS_API_REQUEST Request
;
1300 CSRSS_API_REPLY Reply
;
1303 Request
.Type
= CSRSS_SCREEN_BUFFER_INFO
;
1304 Request
.Data
.ScreenBufferInfoRequest
.ConsoleHandle
= hConsoleOutput
;
1305 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
1306 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1308 SetLastErrorByStatus ( Status
);
1311 *lpConsoleScreenBufferInfo
= Reply
.Data
.ScreenBufferInfoReply
.Info
;
1316 /*--------------------------------------------------------------
1317 * SetConsoleCursorPosition
1323 SetConsoleCursorPosition(
1324 HANDLE hConsoleOutput
,
1325 COORD dwCursorPosition
1328 CSRSS_API_REQUEST Request
;
1329 CSRSS_API_REPLY Reply
;
1332 Request
.Type
= CSRSS_SET_CURSOR
;
1333 Request
.Data
.SetCursorRequest
.ConsoleHandle
= hConsoleOutput
;
1334 Request
.Data
.SetCursorRequest
.Position
= dwCursorPosition
;
1335 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
1336 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1338 SetLastErrorByStatus ( Status
);
1345 /*--------------------------------------------------------------
1346 * FillConsoleOutputCharacterA
1351 FillConsoleOutputCharacterA(
1352 HANDLE hConsoleOutput
,
1356 LPDWORD lpNumberOfCharsWritten
1359 CSRSS_API_REQUEST Request
;
1360 CSRSS_API_REPLY Reply
;
1363 Request
.Type
= CSRSS_FILL_OUTPUT
;
1364 Request
.Data
.FillOutputRequest
.ConsoleHandle
= hConsoleOutput
;
1365 Request
.Data
.FillOutputRequest
.Char
= cCharacter
;
1366 Request
.Data
.FillOutputRequest
.Position
= dwWriteCoord
;
1367 Request
.Data
.FillOutputRequest
.Length
= nLength
;
1368 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
1369 if ( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1371 SetLastErrorByStatus(Status
);
1374 if (lpNumberOfCharsWritten
!= NULL
)
1375 *lpNumberOfCharsWritten
= nLength
;
1380 /*--------------------------------------------------------------
1381 * FillConsoleOutputCharacterW
1387 FillConsoleOutputCharacterW(
1388 HANDLE hConsoleOutput
,
1392 LPDWORD lpNumberOfCharsWritten
1396 DbgPrint("%s unimplemented\n", __FUNCTION__
);
1401 /*--------------------------------------------------------------
1402 * IntPeekConsoleInput
1408 IntPeekConsoleInput(
1409 HANDLE hConsoleInput
,
1410 PINPUT_RECORD lpBuffer
,
1412 LPDWORD lpNumberOfEventsRead
,
1416 PCSRSS_API_REQUEST Request
;
1417 CSRSS_API_REPLY Reply
;
1420 PVOID BufferTargetBase
;
1423 if(lpBuffer
== NULL
)
1425 SetLastError(ERROR_INVALID_PARAMETER
);
1429 Size
= nLength
* sizeof(INPUT_RECORD
);
1431 Status
= CsrCaptureParameterBuffer((PVOID
)lpBuffer
, Size
, &BufferBase
, &BufferTargetBase
);
1432 if(!NT_SUCCESS(Status
))
1434 SetLastErrorByStatus(Status
);
1438 Request
= RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(CSRSS_API_REQUEST
));
1441 CsrReleaseParameterBuffer(BufferBase
);
1442 SetLastError(ERROR_OUTOFMEMORY
);
1446 Request
->Type
= CSRSS_PEEK_CONSOLE_INPUT
;
1447 Request
->Data
.PeekConsoleInputRequest
.ConsoleHandle
= hConsoleInput
;
1448 Request
->Data
.PeekConsoleInputRequest
.Unicode
= bUnicode
;
1449 Request
->Data
.PeekConsoleInputRequest
.Length
= nLength
;
1450 Request
->Data
.PeekConsoleInputRequest
.InputRecord
= (INPUT_RECORD
*)BufferTargetBase
;
1452 Status
= CsrClientCallServer(Request
, &Reply
, sizeof(CSRSS_API_REQUEST
), sizeof(CSRSS_API_REPLY
));
1454 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1456 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1457 CsrReleaseParameterBuffer(BufferBase
);
1461 memcpy(lpBuffer
, BufferBase
, sizeof(INPUT_RECORD
) * Reply
.Data
.PeekConsoleInputReply
.Length
);
1463 if(lpNumberOfEventsRead
!= NULL
)
1464 *lpNumberOfEventsRead
= Reply
.Data
.PeekConsoleInputReply
.Length
;
1466 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1467 CsrReleaseParameterBuffer(BufferBase
);
1472 /*--------------------------------------------------------------
1480 HANDLE hConsoleInput
,
1481 PINPUT_RECORD lpBuffer
,
1483 LPDWORD lpNumberOfEventsRead
1486 return IntPeekConsoleInput(hConsoleInput
, lpBuffer
, nLength
,
1487 lpNumberOfEventsRead
, FALSE
);
1491 /*--------------------------------------------------------------
1499 HANDLE hConsoleInput
,
1500 PINPUT_RECORD lpBuffer
,
1502 LPDWORD lpNumberOfEventsRead
1505 return IntPeekConsoleInput(hConsoleInput
, lpBuffer
, nLength
,
1506 lpNumberOfEventsRead
, TRUE
);
1510 /*--------------------------------------------------------------
1511 * IntReadConsoleInput
1516 IntReadConsoleInput(HANDLE hConsoleInput
,
1517 PINPUT_RECORD lpBuffer
,
1519 LPDWORD lpNumberOfEventsRead
,
1522 CSRSS_API_REQUEST Request
;
1523 CSRSS_API_REPLY Reply
;
1524 DWORD NumEventsRead
;
1527 Request
.Type
= CSRSS_READ_INPUT
;
1528 Request
.Data
.ReadInputRequest
.ConsoleHandle
= hConsoleInput
;
1529 Status
= CsrClientCallServer(&Request
, &Reply
, sizeof(CSRSS_API_REQUEST
),
1530 sizeof(CSRSS_API_REPLY
));
1531 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1533 SetLastErrorByStatus(Status
);
1537 while (Status
== STATUS_PENDING
)
1539 Status
= NtWaitForSingleObject(Reply
.Data
.ReadInputReply
.Event
, FALSE
,
1541 if(!NT_SUCCESS(Status
))
1543 SetLastErrorByStatus(Status
);
1547 Request
.Type
= CSRSS_READ_INPUT
;
1548 Request
.Data
.ReadInputRequest
.ConsoleHandle
= hConsoleInput
;
1549 Request
.Data
.ReadInputRequest
.Unicode
= bUnicode
;
1550 Status
= CsrClientCallServer(&Request
, &Reply
, sizeof(CSRSS_API_REQUEST
),
1551 sizeof(CSRSS_API_REPLY
));
1552 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1554 SetLastErrorByStatus(Status
);
1560 *lpBuffer
= Reply
.Data
.ReadInputReply
.Input
;
1563 while ((NumEventsRead
< nLength
) && (Reply
.Data
.ReadInputReply
.MoreEvents
))
1565 Status
= CsrClientCallServer(&Request
, &Reply
, sizeof(CSRSS_API_REQUEST
),
1566 sizeof(CSRSS_API_REPLY
));
1567 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1569 SetLastErrorByStatus(Status
);
1573 if (Status
== STATUS_PENDING
)
1578 *lpBuffer
= Reply
.Data
.ReadInputReply
.Input
;
1583 *lpNumberOfEventsRead
= NumEventsRead
;
1589 /*--------------------------------------------------------------
1595 ReadConsoleInputA(HANDLE hConsoleInput
,
1596 PINPUT_RECORD lpBuffer
,
1598 LPDWORD lpNumberOfEventsRead
)
1600 return IntReadConsoleInput(hConsoleInput
, lpBuffer
, nLength
,
1601 lpNumberOfEventsRead
, FALSE
);
1605 /*--------------------------------------------------------------
1613 HANDLE hConsoleInput
,
1614 PINPUT_RECORD lpBuffer
,
1616 LPDWORD lpNumberOfEventsRead
1619 return IntReadConsoleInput(hConsoleInput
, lpBuffer
, nLength
,
1620 lpNumberOfEventsRead
, TRUE
);
1624 /*--------------------------------------------------------------
1625 * WriteConsoleInputA
1632 HANDLE hConsoleInput
,
1633 CONST INPUT_RECORD
*lpBuffer
,
1635 LPDWORD lpNumberOfEventsWritten
1638 PCSRSS_API_REQUEST Request
;
1639 CSRSS_API_REPLY Reply
;
1640 PVOID BufferBase
, BufferTargetBase
;
1644 if(lpBuffer
== NULL
)
1646 SetLastError(ERROR_INVALID_PARAMETER
);
1650 Size
= nLength
* sizeof(INPUT_RECORD
);
1652 Status
= CsrCaptureParameterBuffer((PVOID
)lpBuffer
, Size
, &BufferBase
, &BufferTargetBase
);
1653 if(!NT_SUCCESS(Status
))
1655 SetLastErrorByStatus(Status
);
1659 Request
= RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(CSRSS_API_REQUEST
));
1662 SetLastError(ERROR_OUTOFMEMORY
);
1663 CsrReleaseParameterBuffer(BufferBase
);
1667 Request
->Type
= CSRSS_WRITE_CONSOLE_INPUT
;
1668 Request
->Data
.WriteConsoleInputRequest
.ConsoleHandle
= hConsoleInput
;
1669 Request
->Data
.WriteConsoleInputRequest
.Length
= nLength
;
1670 Request
->Data
.WriteConsoleInputRequest
.InputRecord
= (PINPUT_RECORD
)BufferTargetBase
;
1672 Status
= CsrClientCallServer(Request
, &Reply
, sizeof(CSRSS_API_REQUEST
), sizeof(CSRSS_API_REPLY
));
1673 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1675 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1676 CsrReleaseParameterBuffer(BufferBase
);
1680 if(lpNumberOfEventsWritten
!= NULL
)
1681 *lpNumberOfEventsWritten
= Reply
.Data
.WriteConsoleInputReply
.Length
;
1683 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1684 CsrReleaseParameterBuffer(BufferBase
);
1690 /*--------------------------------------------------------------
1691 * WriteConsoleInputW
1698 HANDLE hConsoleInput
,
1699 CONST INPUT_RECORD
*lpBuffer
,
1701 LPDWORD lpNumberOfEventsWritten
1705 DbgPrint("%s unimplemented\n", __FUNCTION__
);
1710 /*--------------------------------------------------------------
1711 * IntReadConsoleOutput
1717 IntReadConsoleOutput(
1718 HANDLE hConsoleOutput
,
1719 PCHAR_INFO lpBuffer
,
1721 COORD dwBufferCoord
,
1722 PSMALL_RECT lpReadRegion
,
1726 PCSRSS_API_REQUEST Request
;
1727 CSRSS_API_REPLY Reply
;
1729 PVOID BufferTargetBase
;
1731 DWORD Size
, SizeX
, SizeY
;
1733 if(lpBuffer
== NULL
)
1735 SetLastError(ERROR_INVALID_PARAMETER
);
1739 Size
= dwBufferSize
.X
* dwBufferSize
.Y
* sizeof(CHAR_INFO
);
1741 Status
= CsrCaptureParameterBuffer((PVOID
)lpBuffer
, Size
, &BufferBase
, &BufferTargetBase
);
1742 if(!NT_SUCCESS(Status
))
1744 SetLastErrorByStatus(Status
);
1748 Request
= RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(CSRSS_API_REQUEST
));
1751 SetLastError(ERROR_OUTOFMEMORY
);
1752 CsrReleaseParameterBuffer(BufferBase
);
1756 Request
->Type
= CSRSS_READ_CONSOLE_OUTPUT
;
1757 Request
->Data
.ReadConsoleOutputRequest
.ConsoleHandle
= hConsoleOutput
;
1758 Request
->Data
.ReadConsoleOutputRequest
.Unicode
= bUnicode
;
1759 Request
->Data
.ReadConsoleOutputRequest
.BufferSize
= dwBufferSize
;
1760 Request
->Data
.ReadConsoleOutputRequest
.BufferCoord
= dwBufferCoord
;
1761 Request
->Data
.ReadConsoleOutputRequest
.ReadRegion
= *lpReadRegion
;
1762 Request
->Data
.ReadConsoleOutputRequest
.CharInfo
= (PCHAR_INFO
)BufferTargetBase
;
1764 Status
= CsrClientCallServer(Request
, &Reply
, sizeof(CSRSS_API_REQUEST
), sizeof(CSRSS_API_REPLY
));
1765 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1767 SetLastErrorByStatus(Status
);
1768 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1769 CsrReleaseParameterBuffer(BufferBase
);
1773 SizeX
= Reply
.Data
.ReadConsoleOutputReply
.ReadRegion
.Right
- Reply
.Data
.ReadConsoleOutputReply
.ReadRegion
.Left
+ 1;
1774 SizeY
= Reply
.Data
.ReadConsoleOutputReply
.ReadRegion
.Bottom
- Reply
.Data
.ReadConsoleOutputReply
.ReadRegion
.Top
+ 1;
1776 memcpy(lpBuffer
, BufferBase
, sizeof(CHAR_INFO
) * SizeX
* SizeY
);
1777 *lpReadRegion
= Reply
.Data
.ReadConsoleOutputReply
.ReadRegion
;
1779 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1780 CsrReleaseParameterBuffer(BufferBase
);
1785 /*--------------------------------------------------------------
1786 * ReadConsoleOutputA
1793 HANDLE hConsoleOutput
,
1794 PCHAR_INFO lpBuffer
,
1796 COORD dwBufferCoord
,
1797 PSMALL_RECT lpReadRegion
1800 return IntReadConsoleOutput(hConsoleOutput
, lpBuffer
, dwBufferSize
,
1801 dwBufferCoord
, lpReadRegion
, FALSE
);
1805 /*--------------------------------------------------------------
1806 * ReadConsoleOutputW
1813 HANDLE hConsoleOutput
,
1814 PCHAR_INFO lpBuffer
,
1816 COORD dwBufferCoord
,
1817 PSMALL_RECT lpReadRegion
1820 return IntReadConsoleOutput(hConsoleOutput
, lpBuffer
, dwBufferSize
,
1821 dwBufferCoord
, lpReadRegion
, TRUE
);
1825 /*--------------------------------------------------------------
1826 * IntWriteConsoleOutput
1831 IntWriteConsoleOutput(HANDLE hConsoleOutput
,
1832 CONST CHAR_INFO
*lpBuffer
,
1834 COORD dwBufferCoord
,
1835 PSMALL_RECT lpWriteRegion
,
1838 PCSRSS_API_REQUEST Request
;
1839 CSRSS_API_REPLY Reply
;
1843 PVOID BufferTargetBase
;
1845 Size
= dwBufferSize
.Y
* dwBufferSize
.X
* sizeof(CHAR_INFO
);
1847 Status
= CsrCaptureParameterBuffer((PVOID
)lpBuffer
,
1851 if (!NT_SUCCESS(Status
))
1853 SetLastErrorByStatus(Status
);
1857 Request
= RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY
,
1858 sizeof(CSRSS_API_REQUEST
));
1859 if (Request
== NULL
)
1861 CsrReleaseParameterBuffer(BufferBase
);
1862 SetLastError(ERROR_OUTOFMEMORY
);
1865 Request
->Type
= CSRSS_WRITE_CONSOLE_OUTPUT
;
1866 Request
->Data
.WriteConsoleOutputRequest
.ConsoleHandle
= hConsoleOutput
;
1867 Request
->Data
.WriteConsoleOutputRequest
.Unicode
= bUnicode
;
1868 Request
->Data
.WriteConsoleOutputRequest
.BufferSize
= dwBufferSize
;
1869 Request
->Data
.WriteConsoleOutputRequest
.BufferCoord
= dwBufferCoord
;
1870 Request
->Data
.WriteConsoleOutputRequest
.WriteRegion
= *lpWriteRegion
;
1871 Request
->Data
.WriteConsoleOutputRequest
.CharInfo
=
1872 (CHAR_INFO
*)BufferTargetBase
;
1874 Status
= CsrClientCallServer(Request
, &Reply
,
1875 sizeof(CSRSS_API_REQUEST
),
1876 sizeof(CSRSS_API_REPLY
));
1877 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1879 CsrReleaseParameterBuffer(BufferBase
);
1880 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1881 SetLastErrorByStatus(Status
);
1885 *lpWriteRegion
= Reply
.Data
.WriteConsoleOutputReply
.WriteRegion
;
1886 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1887 CsrReleaseParameterBuffer(BufferBase
);
1891 /*--------------------------------------------------------------
1892 * WriteConsoleOutputA
1897 WriteConsoleOutputA(HANDLE hConsoleOutput
,
1898 CONST CHAR_INFO
*lpBuffer
,
1900 COORD dwBufferCoord
,
1901 PSMALL_RECT lpWriteRegion
)
1903 return IntWriteConsoleOutput(hConsoleOutput
, lpBuffer
, dwBufferSize
,
1904 dwBufferCoord
, lpWriteRegion
, FALSE
);
1908 /*--------------------------------------------------------------
1909 * WriteConsoleOutputW
1915 WriteConsoleOutputW(
1916 HANDLE hConsoleOutput
,
1917 CONST CHAR_INFO
*lpBuffer
,
1919 COORD dwBufferCoord
,
1920 PSMALL_RECT lpWriteRegion
1923 return IntWriteConsoleOutput(hConsoleOutput
, lpBuffer
, dwBufferSize
,
1924 dwBufferCoord
, lpWriteRegion
, TRUE
);
1928 /*--------------------------------------------------------------
1929 * ReadConsoleOutputCharacterA
1935 ReadConsoleOutputCharacterA(
1936 HANDLE hConsoleOutput
,
1940 LPDWORD lpNumberOfCharsRead
1943 CSRSS_API_REQUEST Request
;
1944 PCSRSS_API_REPLY Reply
;
1948 Reply
= RtlAllocateHeap(GetProcessHeap(), 0,
1949 sizeof(CSRSS_API_REPLY
) +
1950 min(nLength
, CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR
));
1953 SetLastError(ERROR_OUTOFMEMORY
);
1957 if (lpNumberOfCharsRead
!= NULL
)
1958 *lpNumberOfCharsRead
= nLength
;
1960 Request
.Type
= CSRSS_READ_CONSOLE_OUTPUT_CHAR
;
1961 Request
.Data
.ReadConsoleOutputCharRequest
.ConsoleHandle
= hConsoleOutput
;
1962 Request
.Data
.ReadConsoleOutputCharRequest
.ReadCoord
= dwReadCoord
;
1964 while (nLength
!= 0)
1966 if (nLength
> CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR
)
1967 Size
= CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR
;
1971 Request
.Data
.ReadConsoleOutputCharRequest
.NumCharsToRead
= Size
;
1973 Status
= CsrClientCallServer(&Request
,
1975 sizeof(CSRSS_API_REQUEST
),
1976 sizeof(CSRSS_API_REPLY
) + Size
);
1977 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Reply
->Status
))
1979 RtlFreeHeap(GetProcessHeap(), 0, Reply
);
1980 SetLastErrorByStatus(Status
);
1984 memcpy(lpCharacter
, &Reply
->Data
.ReadConsoleOutputCharReply
.String
[0], Size
);
1985 lpCharacter
+= Size
;
1987 Request
.Data
.ReadConsoleOutputCharRequest
.ReadCoord
= Reply
->Data
.ReadConsoleOutputCharReply
.EndCoord
;
1990 RtlFreeHeap(GetProcessHeap(), 0, Reply
);
1996 /*--------------------------------------------------------------
1997 * ReadConsoleOutputCharacterW
2003 ReadConsoleOutputCharacterW(
2004 HANDLE hConsoleOutput
,
2008 LPDWORD lpNumberOfCharsRead
2012 DbgPrint("%s unimplemented\n", __FUNCTION__
);
2017 /*--------------------------------------------------------------
2018 * ReadConsoleOutputAttribute
2024 ReadConsoleOutputAttribute(
2025 HANDLE hConsoleOutput
,
2029 LPDWORD lpNumberOfAttrsRead
2032 CSRSS_API_REQUEST Request
;
2033 PCSRSS_API_REPLY Reply
;
2037 Reply
= RtlAllocateHeap(GetProcessHeap(), 0,
2038 sizeof(CSRSS_API_REPLY
) +
2039 min(nLength
, CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB
));
2042 SetLastError(ERROR_OUTOFMEMORY
);
2046 if (lpNumberOfAttrsRead
!= NULL
)
2047 *lpNumberOfAttrsRead
= nLength
;
2049 Request
.Type
= CSRSS_READ_CONSOLE_OUTPUT_ATTRIB
;
2050 Request
.Data
.ReadConsoleOutputAttribRequest
.ConsoleHandle
= hConsoleOutput
;
2051 Request
.Data
.ReadConsoleOutputAttribRequest
.ReadCoord
= dwReadCoord
;
2053 while (nLength
!= 0)
2055 if (nLength
> CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB
)
2056 Size
= CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB
;
2060 Request
.Data
.ReadConsoleOutputAttribRequest
.NumAttrsToRead
= Size
;
2062 Status
= CsrClientCallServer(&Request
,
2064 sizeof(CSRSS_API_REQUEST
),
2065 sizeof(CSRSS_API_REPLY
) + Size
);
2066 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Reply
->Status
))
2068 RtlFreeHeap(GetProcessHeap(), 0, Reply
);
2069 SetLastErrorByStatus(Status
);
2073 // Convert CHARs to WORDs
2074 for(i
= 0; i
< Size
; ++i
)
2075 *lpAttribute
++ = Reply
->Data
.ReadConsoleOutputAttribReply
.String
[i
];
2078 Request
.Data
.ReadConsoleOutputAttribRequest
.ReadCoord
= Reply
->Data
.ReadConsoleOutputAttribReply
.EndCoord
;
2081 RtlFreeHeap(GetProcessHeap(), 0, Reply
);
2087 /*--------------------------------------------------------------
2088 * WriteConsoleOutputCharacterA
2093 WriteConsoleOutputCharacterA(HANDLE hConsoleOutput
,
2097 LPDWORD lpNumberOfCharsWritten
)
2099 PCSRSS_API_REQUEST Request
;
2100 CSRSS_API_REPLY Reply
;
2104 Request
= RtlAllocateHeap(GetProcessHeap(), 0,
2105 sizeof(CSRSS_API_REQUEST
) +
2106 min(nLength
, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR
));
2109 SetLastError( ERROR_OUTOFMEMORY
);
2112 Request
->Type
= CSRSS_WRITE_CONSOLE_OUTPUT_CHAR
;
2113 Request
->Data
.WriteConsoleOutputCharRequest
.ConsoleHandle
= hConsoleOutput
;
2114 Request
->Data
.WriteConsoleOutputCharRequest
.Coord
= dwWriteCoord
;
2115 if( lpNumberOfCharsWritten
)
2116 *lpNumberOfCharsWritten
= nLength
;
2119 Size
= nLength
> CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR
? CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR
: nLength
;
2120 Request
->Data
.WriteConsoleOutputCharRequest
.Length
= Size
;
2121 memcpy( &Request
->Data
.WriteConsoleOutputCharRequest
.String
[0],
2124 Status
= CsrClientCallServer( Request
, &Reply
, sizeof( CSRSS_API_REQUEST
) + Size
, sizeof( CSRSS_API_REPLY
) );
2125 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2127 RtlFreeHeap( GetProcessHeap(), 0, Request
);
2128 SetLastErrorByStatus ( Status
);
2132 lpCharacter
+= Size
;
2133 Request
->Data
.WriteConsoleOutputCharRequest
.Coord
= Reply
.Data
.WriteConsoleOutputCharReply
.EndCoord
;
2136 RtlFreeHeap( GetProcessHeap(), 0, Request
);
2141 /*--------------------------------------------------------------
2142 * WriteConsoleOutputCharacterW
2147 WriteConsoleOutputCharacterW(HANDLE hConsoleOutput
,
2148 LPCWSTR lpCharacter
,
2151 LPDWORD lpNumberOfCharsWritten
)
2153 PCSRSS_API_REQUEST Request
;
2154 CSRSS_API_REPLY Reply
;
2158 Request
= RtlAllocateHeap(GetProcessHeap(), 0,
2159 sizeof(CSRSS_API_REQUEST
) +
2160 min(nLength
, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR
));
2163 SetLastError( ERROR_OUTOFMEMORY
);
2166 Request
->Type
= CSRSS_WRITE_CONSOLE_OUTPUT_CHAR
;
2167 Request
->Data
.WriteConsoleOutputCharRequest
.ConsoleHandle
= hConsoleOutput
;
2168 Request
->Data
.WriteConsoleOutputCharRequest
.Coord
= dwWriteCoord
;
2169 if( lpNumberOfCharsWritten
)
2170 *lpNumberOfCharsWritten
= nLength
;
2173 Size
= nLength
> CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR
? CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR
: nLength
;
2174 Request
->Data
.WriteConsoleOutputCharRequest
.Length
= Size
;
2175 Status
= RtlUnicodeToOemN (&Request
->Data
.WriteConsoleOutputCharRequest
.String
[0],
2178 (PWCHAR
)lpCharacter
,
2179 Size
* sizeof(WCHAR
));
2180 if (!NT_SUCCESS(Status
))
2182 RtlFreeHeap (GetProcessHeap(), 0, Request
);
2183 SetLastErrorByStatus (Status
);
2187 Status
= CsrClientCallServer( Request
, &Reply
, sizeof( CSRSS_API_REQUEST
) + Size
, sizeof( CSRSS_API_REPLY
) );
2188 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2190 RtlFreeHeap( GetProcessHeap(), 0, Request
);
2191 SetLastErrorByStatus ( Status
);
2195 lpCharacter
+= Size
;
2196 Request
->Data
.WriteConsoleOutputCharRequest
.Coord
= Reply
.Data
.WriteConsoleOutputCharReply
.EndCoord
;
2199 RtlFreeHeap( GetProcessHeap(), 0, Request
);
2204 /*--------------------------------------------------------------
2205 * WriteConsoleOutputAttribute
2211 WriteConsoleOutputAttribute(
2212 HANDLE hConsoleOutput
,
2213 CONST WORD
*lpAttribute
,
2216 LPDWORD lpNumberOfAttrsWritten
2219 PCSRSS_API_REQUEST Request
;
2220 CSRSS_API_REPLY Reply
;
2225 Request
= RtlAllocateHeap(GetProcessHeap(), 0,
2226 sizeof(CSRSS_API_REQUEST
) +
2227 min(nLength
, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB
));
2230 SetLastError( ERROR_OUTOFMEMORY
);
2233 Request
->Type
= CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB
;
2234 Request
->Data
.WriteConsoleOutputAttribRequest
.ConsoleHandle
= hConsoleOutput
;
2235 Request
->Data
.WriteConsoleOutputAttribRequest
.Coord
= dwWriteCoord
;
2236 if( lpNumberOfAttrsWritten
)
2237 *lpNumberOfAttrsWritten
= nLength
;
2240 Size
= nLength
> CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB
? CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB
: nLength
;
2241 Request
->Data
.WriteConsoleOutputAttribRequest
.Length
= Size
;
2242 for( c
= 0; c
< ( Size
* 2 ); c
++ )
2243 Request
->Data
.WriteConsoleOutputAttribRequest
.String
[c
] = (char)lpAttribute
[c
];
2244 Status
= CsrClientCallServer( Request
, &Reply
, sizeof( CSRSS_API_REQUEST
) + (Size
* 2), sizeof( CSRSS_API_REPLY
) );
2245 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2247 RtlFreeHeap( GetProcessHeap(), 0, Request
);
2248 SetLastErrorByStatus ( Status
);
2252 lpAttribute
+= Size
;
2253 Request
->Data
.WriteConsoleOutputAttribRequest
.Coord
= Reply
.Data
.WriteConsoleOutputAttribReply
.EndCoord
;
2256 RtlFreeHeap( GetProcessHeap(), 0, Request
);
2261 /*--------------------------------------------------------------
2262 * FillConsoleOutputAttribute
2268 FillConsoleOutputAttribute(
2269 HANDLE hConsoleOutput
,
2273 LPDWORD lpNumberOfAttrsWritten
2276 CSRSS_API_REQUEST Request
;
2277 CSRSS_API_REPLY Reply
;
2280 Request
.Type
= CSRSS_FILL_OUTPUT_ATTRIB
;
2281 Request
.Data
.FillOutputAttribRequest
.ConsoleHandle
= hConsoleOutput
;
2282 Request
.Data
.FillOutputAttribRequest
.Attribute
= wAttribute
;
2283 Request
.Data
.FillOutputAttribRequest
.Coord
= dwWriteCoord
;
2284 Request
.Data
.FillOutputAttribRequest
.Length
= nLength
;
2285 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
2286 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2288 SetLastErrorByStatus ( Status
);
2291 if( lpNumberOfAttrsWritten
)
2292 *lpNumberOfAttrsWritten
= nLength
;
2297 /*--------------------------------------------------------------
2305 HANDLE hConsoleHandle
,
2309 CSRSS_API_REQUEST Request
;
2310 CSRSS_API_REPLY Reply
;
2313 Request
.Type
= CSRSS_GET_CONSOLE_MODE
;
2314 Request
.Data
.GetConsoleModeRequest
.ConsoleHandle
= hConsoleHandle
;
2315 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
2316 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2318 SetLastErrorByStatus ( Status
);
2321 *lpMode
= Reply
.Data
.GetConsoleModeReply
.ConsoleMode
;
2326 /*--------------------------------------------------------------
2327 * GetNumberOfConsoleInputEvents
2333 GetNumberOfConsoleInputEvents(
2334 HANDLE hConsoleInput
,
2335 LPDWORD lpNumberOfEvents
2338 CSRSS_API_REQUEST Request
;
2339 CSRSS_API_REPLY Reply
;
2342 if(lpNumberOfEvents
== NULL
)
2344 SetLastError(ERROR_INVALID_PARAMETER
);
2348 Request
.Type
= CSRSS_GET_NUM_INPUT_EVENTS
;
2349 Request
.Data
.GetNumInputEventsRequest
.ConsoleHandle
= hConsoleInput
;
2350 Status
= CsrClientCallServer(&Request
, &Reply
, sizeof(CSRSS_API_REQUEST
), sizeof(CSRSS_API_REPLY
));
2351 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
2353 SetLastErrorByStatus(Status
);
2357 *lpNumberOfEvents
= Reply
.Data
.GetNumInputEventsReply
.NumInputEvents
;
2363 /*--------------------------------------------------------------
2364 * GetLargestConsoleWindowSize
2370 GetLargestConsoleWindowSize(
2371 HANDLE hConsoleOutput
2375 COORD Coord
= {80,25};
2383 /*--------------------------------------------------------------
2384 * GetConsoleCursorInfo
2390 GetConsoleCursorInfo(
2391 HANDLE hConsoleOutput
,
2392 PCONSOLE_CURSOR_INFO lpConsoleCursorInfo
2395 CSRSS_API_REQUEST Request
;
2396 CSRSS_API_REPLY Reply
;
2399 Request
.Type
= CSRSS_GET_CURSOR_INFO
;
2400 Request
.Data
.GetCursorInfoRequest
.ConsoleHandle
= hConsoleOutput
;
2401 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
2403 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2405 SetLastErrorByStatus ( Status
);
2408 *lpConsoleCursorInfo
= Reply
.Data
.GetCursorInfoReply
.Info
;
2413 /*--------------------------------------------------------------
2414 * GetNumberOfConsoleMouseButtons
2420 GetNumberOfConsoleMouseButtons(
2421 LPDWORD lpNumberOfMouseButtons
2429 /*--------------------------------------------------------------
2437 HANDLE hConsoleHandle
,
2441 CSRSS_API_REQUEST Request
;
2442 CSRSS_API_REPLY Reply
;
2445 Request
.Type
= CSRSS_SET_CONSOLE_MODE
;
2446 Request
.Data
.SetConsoleModeRequest
.ConsoleHandle
= hConsoleHandle
;
2447 Request
.Data
.SetConsoleModeRequest
.Mode
= dwMode
;
2448 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
2449 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2451 SetLastErrorByStatus ( Status
);
2458 /*--------------------------------------------------------------
2459 * SetConsoleActiveScreenBuffer
2465 SetConsoleActiveScreenBuffer(
2466 HANDLE hConsoleOutput
2469 CSRSS_API_REQUEST Request
;
2470 CSRSS_API_REPLY Reply
;
2473 Request
.Type
= CSRSS_SET_SCREEN_BUFFER
;
2474 Request
.Data
.SetScreenBufferRequest
.OutputHandle
= hConsoleOutput
;
2475 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
2476 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2478 SetLastErrorByStatus ( Status
);
2485 /*--------------------------------------------------------------
2486 * FlushConsoleInputBuffer
2492 FlushConsoleInputBuffer(
2493 HANDLE hConsoleInput
2496 CSRSS_API_REQUEST Request
;
2497 CSRSS_API_REPLY Reply
;
2500 Request
.Type
= CSRSS_FLUSH_INPUT_BUFFER
;
2501 Request
.Data
.FlushInputBufferRequest
.ConsoleInput
= hConsoleInput
;
2502 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
2503 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2505 SetLastErrorByStatus ( Status
);
2512 /*--------------------------------------------------------------
2513 * SetConsoleScreenBufferSize
2519 SetConsoleScreenBufferSize(
2520 HANDLE hConsoleOutput
,
2525 DbgPrint("%s unimplemented\n", __FUNCTION__
);
2529 /*--------------------------------------------------------------
2530 * SetConsoleCursorInfo
2536 SetConsoleCursorInfo(
2537 HANDLE hConsoleOutput
,
2538 CONST CONSOLE_CURSOR_INFO
*lpConsoleCursorInfo
2541 CSRSS_API_REQUEST Request
;
2542 CSRSS_API_REPLY Reply
;
2545 Request
.Type
= CSRSS_SET_CURSOR_INFO
;
2546 Request
.Data
.SetCursorInfoRequest
.ConsoleHandle
= hConsoleOutput
;
2547 Request
.Data
.SetCursorInfoRequest
.Info
= *lpConsoleCursorInfo
;
2548 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
2550 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2552 SetLastErrorByStatus ( Status
);
2559 /*--------------------------------------------------------------
2560 * ScrollConsoleScreenBufferA
2566 ScrollConsoleScreenBufferA(
2567 HANDLE hConsoleOutput
,
2568 CONST SMALL_RECT
*lpScrollRectangle
,
2569 CONST SMALL_RECT
*lpClipRectangle
,
2570 COORD dwDestinationOrigin
,
2571 CONST CHAR_INFO
*lpFill
2574 CSRSS_API_REQUEST Request
;
2575 CSRSS_API_REPLY Reply
;
2578 Request
.Type
= CSRSS_SCROLL_CONSOLE_SCREEN_BUFFER
;
2579 Request
.Data
.ScrollConsoleScreenBufferRequest
.ConsoleHandle
= hConsoleOutput
;
2580 Request
.Data
.ScrollConsoleScreenBufferRequest
.ScrollRectangle
= *lpScrollRectangle
;
2582 if (lpClipRectangle
!= NULL
)
2584 Request
.Data
.ScrollConsoleScreenBufferRequest
.UseClipRectangle
= TRUE
;
2585 Request
.Data
.ScrollConsoleScreenBufferRequest
.ClipRectangle
= *lpClipRectangle
;
2589 Request
.Data
.ScrollConsoleScreenBufferRequest
.UseClipRectangle
= FALSE
;
2592 Request
.Data
.ScrollConsoleScreenBufferRequest
.DestinationOrigin
= dwDestinationOrigin
;
2593 Request
.Data
.ScrollConsoleScreenBufferRequest
.Fill
= *lpFill
;
2594 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
2596 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2598 SetLastErrorByStatus ( Status
);
2605 /*--------------------------------------------------------------
2606 * ScrollConsoleScreenBufferW
2612 ScrollConsoleScreenBufferW(
2613 HANDLE hConsoleOutput
,
2614 CONST SMALL_RECT
*lpScrollRectangle
,
2615 CONST SMALL_RECT
*lpClipRectangle
,
2616 COORD dwDestinationOrigin
,
2617 CONST CHAR_INFO
*lpFill
2621 DbgPrint("%s unimplemented\n", __FUNCTION__
);
2626 /*--------------------------------------------------------------
2627 * SetConsoleWindowInfo
2633 SetConsoleWindowInfo(
2634 HANDLE hConsoleOutput
,
2636 CONST SMALL_RECT
*lpConsoleWindow
2640 DbgPrint("%s unimplemented\n", __FUNCTION__
);
2645 /*--------------------------------------------------------------
2646 * SetConsoleTextAttribute
2652 SetConsoleTextAttribute(
2653 HANDLE hConsoleOutput
,
2657 CSRSS_API_REQUEST Request
;
2658 CSRSS_API_REPLY Reply
;
2661 Request
.Type
= CSRSS_SET_ATTRIB
;
2662 Request
.Data
.SetAttribRequest
.ConsoleHandle
= hConsoleOutput
;
2663 Request
.Data
.SetAttribRequest
.Attrib
= wAttributes
;
2664 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
2665 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2667 SetLastErrorByStatus ( Status
);
2675 AddConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine
)
2677 if (HandlerRoutine
== NULL
)
2679 IgnoreCtrlEvents
= TRUE
;
2686 RtlReAllocateHeap(RtlGetProcessHeap(),
2688 (PVOID
)CtrlHandlers
,
2689 NrCtrlHandlers
* sizeof(PHANDLER_ROUTINE
));
2690 if (CtrlHandlers
== NULL
)
2693 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2696 CtrlHandlers
[NrCtrlHandlers
- 1] = HandlerRoutine
;
2703 RemoveConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine
)
2707 if (HandlerRoutine
== NULL
)
2709 IgnoreCtrlEvents
= FALSE
;
2714 for (i
= 0; i
< NrCtrlHandlers
; i
++)
2716 if ( ((void*)(CtrlHandlers
[i
])) == (void*)HandlerRoutine
)
2719 memmove(CtrlHandlers
+ i
, CtrlHandlers
+ i
+ 1,
2720 (NrCtrlHandlers
- i
) * sizeof(PHANDLER_ROUTINE
));
2722 RtlReAllocateHeap(RtlGetProcessHeap(),
2724 (PVOID
)CtrlHandlers
,
2725 NrCtrlHandlers
* sizeof(PHANDLER_ROUTINE
));
2738 SetConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine
,
2743 RtlEnterCriticalSection(&DllLock
);
2746 Ret
= AddConsoleCtrlHandler(HandlerRoutine
);
2750 Ret
= RemoveConsoleCtrlHandler(HandlerRoutine
);
2752 RtlLeaveCriticalSection(&DllLock
);
2757 /*--------------------------------------------------------------
2758 * GenerateConsoleCtrlEvent
2763 GenerateConsoleCtrlEvent(
2765 DWORD dwProcessGroupId
2773 /*--------------------------------------------------------------
2781 LPWSTR lpConsoleTitle
,
2785 CSRSS_API_REQUEST Request
;
2786 PCSRSS_API_REPLY Reply
;
2790 hConsole
= CreateFileW(L
"CONIN$", GENERIC_READ
, 0, NULL
, OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
2791 if (hConsole
== INVALID_HANDLE_VALUE
)
2796 Reply
= RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(CSRSS_API_REPLY
) + CSRSS_MAX_TITLE_LENGTH
* sizeof(WCHAR
));
2799 CloseHandle(hConsole
);
2800 SetLastError(ERROR_OUTOFMEMORY
);
2804 Request
.Type
= CSRSS_GET_TITLE
;
2805 Request
.Data
.GetTitleRequest
.ConsoleHandle
= hConsole
;
2807 Status
= CsrClientCallServer(&Request
, Reply
, sizeof(CSRSS_API_REQUEST
), sizeof(CSRSS_API_REPLY
) + CSRSS_MAX_TITLE_LENGTH
* sizeof(WCHAR
));
2808 CloseHandle(hConsole
);
2809 if(!NT_SUCCESS(Status
) || !(NT_SUCCESS(Status
= Reply
->Status
)))
2811 SetLastErrorByStatus(Status
);
2812 RtlFreeHeap(GetProcessHeap(), 0, Reply
);
2816 if(nSize
* sizeof(WCHAR
) < Reply
->Data
.GetTitleReply
.Length
)
2818 wcsncpy(lpConsoleTitle
, Reply
->Data
.GetTitleReply
.Title
, nSize
- 1);
2819 lpConsoleTitle
[nSize
--] = L
'\0';
2823 nSize
= Reply
->Data
.GetTitleReply
.Length
/ sizeof (WCHAR
);
2824 wcscpy(lpConsoleTitle
, Reply
->Data
.GetTitleReply
.Title
);
2825 lpConsoleTitle
[nSize
] = L
'\0';
2828 RtlFreeHeap(GetProcessHeap(), 0, Reply
);
2833 /*--------------------------------------------------------------
2843 LPSTR lpConsoleTitle
,
2847 wchar_t WideTitle
[CSRSS_MAX_TITLE_LENGTH
];
2848 DWORD nWideTitle
= sizeof WideTitle
;
2851 if (!lpConsoleTitle
|| !nSize
) return 0;
2852 nWideTitle
= GetConsoleTitleW( (LPWSTR
) WideTitle
, nWideTitle
);
2853 if (!nWideTitle
) return 0;
2855 if ( (nWritten
= WideCharToMultiByte(
2856 CP_ACP
, // ANSI code page
2857 0, // performance and mapping flags
2858 (LPWSTR
) WideTitle
, // address of wide-character string
2859 nWideTitle
, // number of characters in string
2860 lpConsoleTitle
, // address of buffer for new string
2861 nSize
, // size of buffer
2866 lpConsoleTitle
[nWritten
] = '\0';
2874 /*--------------------------------------------------------------
2882 LPCWSTR lpConsoleTitle
2885 PCSRSS_API_REQUEST Request
;
2886 CSRSS_API_REPLY Reply
;
2891 hConsole
= CreateFileW(L
"CONIN$", GENERIC_WRITE
, 0, NULL
, OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
2892 if (hConsole
== INVALID_HANDLE_VALUE
)
2897 Request
= RtlAllocateHeap(GetProcessHeap(),
2899 sizeof(CSRSS_API_REQUEST
) + CSRSS_MAX_SET_TITLE_REQUEST
);
2900 if (Request
== NULL
)
2902 CloseHandle(hConsole
);
2903 SetLastError(ERROR_OUTOFMEMORY
);
2907 Request
->Type
= CSRSS_SET_TITLE
;
2908 Request
->Data
.SetTitleRequest
.Console
= hConsole
;
2910 for( c
= 0; lpConsoleTitle
[c
] && c
< CSRSS_MAX_TITLE_LENGTH
; c
++ )
2911 Request
->Data
.SetTitleRequest
.Title
[c
] = lpConsoleTitle
[c
];
2913 Request
->Data
.SetTitleRequest
.Title
[c
] = 0;
2914 Request
->Data
.SetTitleRequest
.Length
= c
;
2915 Status
= CsrClientCallServer(Request
,
2917 sizeof(CSRSS_API_REQUEST
) +
2919 sizeof(CSRSS_API_REPLY
));
2920 CloseHandle(hConsole
);
2921 if (!NT_SUCCESS(Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2923 RtlFreeHeap( GetProcessHeap(), 0, Request
);
2924 SetLastErrorByStatus (Status
);
2927 RtlFreeHeap( GetProcessHeap(), 0, Request
);
2932 /*--------------------------------------------------------------
2942 LPCSTR lpConsoleTitle
2945 PCSRSS_API_REQUEST Request
;
2946 CSRSS_API_REPLY Reply
;
2951 hConsole
= CreateFileW(L
"CONIN$", GENERIC_WRITE
, 0, NULL
, OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
2952 if (hConsole
== INVALID_HANDLE_VALUE
)
2957 Request
= RtlAllocateHeap(GetProcessHeap(),
2959 sizeof(CSRSS_API_REQUEST
) + CSRSS_MAX_SET_TITLE_REQUEST
);
2960 if (Request
== NULL
)
2962 CloseHandle(hConsole
);
2963 SetLastError(ERROR_OUTOFMEMORY
);
2967 Request
->Type
= CSRSS_SET_TITLE
;
2968 Request
->Data
.SetTitleRequest
.Console
= hConsole
;
2970 for( c
= 0; lpConsoleTitle
[c
] && c
< CSRSS_MAX_TITLE_LENGTH
; c
++ )
2971 Request
->Data
.SetTitleRequest
.Title
[c
] = lpConsoleTitle
[c
];
2973 Request
->Data
.SetTitleRequest
.Title
[c
] = 0;
2974 Request
->Data
.SetTitleRequest
.Length
= c
;
2975 Status
= CsrClientCallServer(Request
,
2977 sizeof(CSRSS_API_REQUEST
) +
2979 sizeof(CSRSS_API_REPLY
));
2980 CloseHandle(hConsole
);
2981 if (!NT_SUCCESS(Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2983 RtlFreeHeap( GetProcessHeap(), 0, Request
);
2984 SetLastErrorByStatus (Status
);
2987 RtlFreeHeap( GetProcessHeap(), 0, Request
);
2992 /*--------------------------------------------------------------
3000 HANDLE hConsoleInput
,
3002 DWORD nNumberOfCharsToRead
,
3003 LPDWORD lpNumberOfCharsRead
,
3008 DbgPrint("%s unimplemented\n", __FUNCTION__
);
3013 /*--------------------------------------------------------------
3021 HANDLE hConsoleOutput
,
3022 CONST VOID
*lpBuffer
,
3023 DWORD nNumberOfCharsToWrite
,
3024 LPDWORD lpNumberOfCharsWritten
,
3028 DbgPrint("%s unimplemented\n", __FUNCTION__
);
3030 PCSRSS_API_REQUEST Request
;
3031 CSRSS_API_REPLY Reply
;
3034 Request
= RtlAllocateHeap(GetProcessHeap(),
3036 sizeof(CSRSS_API_REQUEST
) + nNumberOfCharsToWrite
* sizeof(WCHAR
));
3037 if (Request
== NULL
)
3039 SetLastError(ERROR_OUTOFMEMORY
);
3043 Request
->Type
= CSRSS_WRITE_CONSOLE
;
3044 Request
->Data
.WriteConsoleRequest
.ConsoleHandle
= hConsoleOutput
;
3045 Request
->Data
.WriteConsoleRequest
.NrCharactersToWrite
=
3046 nNumberOfCharsToWrite
;
3047 // DbgPrint("nNumberOfCharsToWrite %d\n", nNumberOfCharsToWrite);
3048 // DbgPrint("Buffer %s\n", Request->Data.WriteConsoleRequest.Buffer);
3049 memcpy(Request
->Data
.WriteConsoleRequest
.Buffer
,
3051 nNumberOfCharsToWrite
* sizeof(WCHAR
));
3053 Status
= CsrClientCallServer(Request
,
3055 sizeof(CSRSS_API_REQUEST
) + nNumberOfCharsToWrite
,
3056 sizeof(CSRSS_API_REPLY
));
3058 RtlFreeHeap(GetProcessHeap(),
3062 if (!NT_SUCCESS(Status
))
3067 if (lpNumberOfCharsWritten
!= NULL
)
3069 *lpNumberOfCharsWritten
=
3070 Reply
.Data
.WriteConsoleReply
.NrCharactersWritten
;
3079 /*--------------------------------------------------------------
3080 * CreateConsoleScreenBuffer
3086 CreateConsoleScreenBuffer(
3087 DWORD dwDesiredAccess
,
3089 CONST SECURITY_ATTRIBUTES
*lpSecurityAttributes
,
3091 LPVOID lpScreenBufferData
3094 // FIXME: don't ignore access, share mode, and security
3095 CSRSS_API_REQUEST Request
;
3096 CSRSS_API_REPLY Reply
;
3099 Request
.Type
= CSRSS_CREATE_SCREEN_BUFFER
;
3100 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
3101 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
3103 SetLastErrorByStatus ( Status
);
3106 return Reply
.Data
.CreateScreenBufferReply
.OutputHandle
;
3110 /*--------------------------------------------------------------
3117 GetConsoleCP( VOID
)
3119 CSRSS_API_REQUEST Request
;
3120 CSRSS_API_REPLY Reply
;
3123 Request
.Type
= CSRSS_GET_CONSOLE_CP
;
3124 Status
= CsrClientCallServer(&Request
, &Reply
, sizeof(CSRSS_API_REQUEST
),
3125 sizeof(CSRSS_API_REPLY
));
3126 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
3128 SetLastErrorByStatus (Status
);
3131 return Reply
.Data
.GetConsoleCodePage
.CodePage
;
3135 /*--------------------------------------------------------------
3146 CSRSS_API_REQUEST Request
;
3147 CSRSS_API_REPLY Reply
;
3150 Request
.Type
= CSRSS_SET_CONSOLE_CP
;
3151 Request
.Data
.SetConsoleCodePage
.CodePage
= wCodePageID
;
3152 Status
= CsrClientCallServer(&Request
, &Reply
, sizeof(CSRSS_API_REQUEST
),
3153 sizeof(CSRSS_API_REPLY
));
3154 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
3156 SetLastErrorByStatus (Status
);
3158 return NT_SUCCESS(Status
);
3162 /*--------------------------------------------------------------
3163 * GetConsoleOutputCP
3169 GetConsoleOutputCP( VOID
)
3171 CSRSS_API_REQUEST Request
;
3172 CSRSS_API_REPLY Reply
;
3175 Request
.Type
= CSRSS_GET_CONSOLE_OUTPUT_CP
;
3176 Status
= CsrClientCallServer(&Request
, &Reply
, sizeof(CSRSS_API_REQUEST
),
3177 sizeof(CSRSS_API_REPLY
));
3178 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
3180 SetLastErrorByStatus (Status
);
3183 return Reply
.Data
.GetConsoleOutputCodePage
.CodePage
;
3187 /*--------------------------------------------------------------
3188 * SetConsoleOutputCP
3198 CSRSS_API_REQUEST Request
;
3199 CSRSS_API_REPLY Reply
;
3202 Request
.Type
= CSRSS_SET_CONSOLE_OUTPUT_CP
;
3203 Request
.Data
.SetConsoleOutputCodePage
.CodePage
= wCodePageID
;
3204 Status
= CsrClientCallServer(&Request
, &Reply
, sizeof(CSRSS_API_REQUEST
),
3205 sizeof(CSRSS_API_REPLY
));
3206 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
3208 SetLastErrorByStatus (Status
);
3210 return NT_SUCCESS(Status
);
3214 /*--------------------------------------------------------------
3215 * GetConsoleProcessList
3220 GetConsoleProcessList(LPDWORD lpdwProcessList
,
3221 DWORD dwProcessCount
)
3223 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3229 /*--------------------------------------------------------------
3230 * GetConsoleSelectionInfo
3235 GetConsoleSelectionInfo(PCONSOLE_SELECTION_INFO lpConsoleSelectionInfo
)
3237 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3243 /*--------------------------------------------------------------
3249 AttachConsole(DWORD dwProcessId
)
3251 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3255 /*--------------------------------------------------------------
3261 GetConsoleWindow (VOID
)
3263 CSRSS_API_REQUEST Request
;
3264 CSRSS_API_REPLY Reply
;
3267 Request
.Type
= CSRSS_GET_CONSOLE_WINDOW
;
3268 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
3269 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
3271 SetLastErrorByStatus (Status
);
3274 return Reply
.Data
.GetConsoleWindowReply
.WindowHandle
;
3278 /*--------------------------------------------------------------
3283 BOOL STDCALL
SetConsoleIcon(HICON hicon
)
3285 CSRSS_API_REQUEST Request
;
3286 CSRSS_API_REPLY Reply
;
3289 Request
.Type
= CSRSS_SET_CONSOLE_ICON
;
3290 Request
.Data
.SetConsoleIconRequest
.WindowIcon
= hicon
;
3291 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
3292 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
3294 SetLastErrorByStatus (Status
);
3297 return NT_SUCCESS(Status
);