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