1 /* $Id: console.c,v 1.56 2003/05/05 19:58:27 ea Exp $
3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS system libraries
5 * FILE: lib/kernel32/misc/console.c
6 * PURPOSE: Win32 server console functions
10 * 19990204 EA SetConsoleTitleA
14 /* INCLUDES ******************************************************************/
19 #include <kernel32/kernel32.h>
21 /* GLOBALS *******************************************************************/
23 static BOOL IgnoreCtrlEvents
= FALSE
;
24 static ULONG NrCtrlHandlers
= 0;
25 static PHANDLER_ROUTINE
* CtrlHandlers
= NULL
;
27 /* FUNCTIONS *****************************************************************/
30 AddConsoleAliasA (LPSTR Source
,
34 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
39 AddConsoleAliasW (LPWSTR Source
,
43 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
48 ConsoleMenuControl (HANDLE hConsole
,
55 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
60 DuplicateConsoleHandle (HANDLE hConsole
,
61 DWORD dwDesiredAccess
,
65 CSRSS_API_REQUEST Request
;
66 CSRSS_API_REPLY Reply
;
69 if (IsConsoleHandle (hConsole
) == FALSE
)
71 SetLastError (ERROR_INVALID_PARAMETER
);
72 return INVALID_HANDLE_VALUE
;
75 Request
.Type
= CSRSS_DUPLICATE_HANDLE
;
76 Request
.Data
.DuplicateHandleRequest
.Handle
= hConsole
;
77 Request
.Data
.DuplicateHandleRequest
.ProcessId
= GetCurrentProcessId();
78 Status
= CsrClientCallServer(&Request
,
80 sizeof(CSRSS_API_REQUEST
),
81 sizeof(CSRSS_API_REPLY
));
82 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
=Reply
.Status
))
84 SetLastErrorByStatus(Status
);
85 return INVALID_HANDLE_VALUE
;
87 return Reply
.Data
.DuplicateHandleReply
.Handle
;
91 ExpungeConsoleCommandHistoryW (DWORD Unknown0
)
96 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
102 ExpungeConsoleCommandHistoryA (DWORD Unknown0
)
107 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
112 GetConsoleAliasW (DWORD Unknown0
,
120 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
126 GetConsoleAliasA (DWORD Unknown0
,
134 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
139 GetConsoleAliasExesW (DWORD Unknown0
,
145 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
152 GetConsoleAliasExesA (DWORD Unknown0
,
158 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
165 GetConsoleAliasExesLengthA (VOID
)
170 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
175 GetConsoleAliasExesLengthW (VOID
)
180 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
185 GetConsoleAliasesW (DWORD Unknown0
,
192 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
197 GetConsoleAliasesA (DWORD Unknown0
,
204 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
209 GetConsoleAliasesLengthW (DWORD Unknown0
)
214 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
219 GetConsoleAliasesLengthA (DWORD Unknown0
)
224 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
229 GetConsoleCommandHistoryW (DWORD Unknown0
,
236 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
241 GetConsoleCommandHistoryA (DWORD Unknown0
,
248 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
253 GetConsoleCommandHistoryLengthW (DWORD Unknown0
)
258 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
263 GetConsoleCommandHistoryLengthA (DWORD Unknown0
)
268 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
273 GetConsoleDisplayMode (LPDWORD lpdwMode
)
275 * FUNCTION: Get the console display mode
277 * lpdwMode - Address of variable that receives the current value
279 * STATUS: Undocumented
282 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
287 GetConsoleFontInfo (DWORD Unknown0
,
295 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
300 GetConsoleFontSize(HANDLE hConsoleOutput
,
303 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
308 GetConsoleHardwareState (DWORD Unknown0
,
315 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
320 GetConsoleInputWaitHandle (VOID
)
325 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
330 GetCurrentConsoleFont(HANDLE hConsoleOutput
,
332 PCONSOLE_FONT_INFO lpConsoleCurrentFont
)
334 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
339 GetNumberOfConsoleFonts (VOID
)
344 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
345 return 1; /* FIXME: call csrss.exe */
349 InvalidateConsoleDIBits (DWORD Unknown0
,
355 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
360 OpenConsoleW (LPWSTR wsName
,
361 DWORD dwDesiredAccess
,
362 LPSECURITY_ATTRIBUTES lpSecurityAttributes OPTIONAL
,
363 DWORD dwCreationDistribution
)
368 CSRSS_API_REQUEST Request
;
369 CSRSS_API_REPLY Reply
;
370 PHANDLE phConsole
= NULL
;
371 NTSTATUS Status
= STATUS_SUCCESS
;
374 if(0 == _wcsicmp(wsName
, L
"CONIN$"))
376 Request
.Type
= CSRSS_GET_INPUT_HANDLE
;
377 phConsole
= & Reply
.Data
.GetInputHandleReply
.InputHandle
;
379 else if (0 == _wcsicmp(wsName
, L
"CONOUT$"))
381 Request
.Type
= CSRSS_GET_OUTPUT_HANDLE
;
382 phConsole
= & Reply
.Data
.GetOutputHandleReply
.OutputHandle
;
386 SetLastError(ERROR_INVALID_PARAMETER
);
387 return(INVALID_HANDLE_VALUE
);
389 if ((GENERIC_READ
|GENERIC_WRITE
) != dwDesiredAccess
)
391 SetLastError(ERROR_INVALID_PARAMETER
);
392 return(INVALID_HANDLE_VALUE
);
394 if (OPEN_EXISTING
!= dwCreationDistribution
)
396 SetLastError(ERROR_INVALID_PARAMETER
);
397 return(INVALID_HANDLE_VALUE
);
399 Status
= CsrClientCallServer(& Request
,
401 sizeof(CSRSS_API_REQUEST
),
402 sizeof(CSRSS_API_REPLY
));
403 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
405 SetLastErrorByStatus(Status
);
406 return INVALID_HANDLE_VALUE
;
412 SetConsoleCommandHistoryMode (DWORD dwMode
)
417 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
422 SetConsoleCursor (DWORD Unknown0
,
428 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
433 SetConsoleDisplayMode (HANDLE hOut
,
437 * FUNCTION: Set the console display mode.
439 * hOut - Standard output handle.
440 * dwNewMode - New mode.
441 * lpdwOldMode - Address of a variable that receives the old mode.
444 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
449 SetConsoleFont (DWORD Unknown0
,
455 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
460 SetConsoleHardwareState (DWORD Unknown0
,
467 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
472 SetConsoleKeyShortcuts (DWORD Unknown0
,
480 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
485 SetConsoleMaximumWindowSize (DWORD Unknown0
,
491 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
496 SetConsoleMenuClose (DWORD Unknown0
)
501 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
506 SetConsoleNumberOfCommandsA (DWORD Unknown0
,
512 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
517 SetConsoleNumberOfCommandsW (DWORD Unknown0
,
523 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
528 SetConsolePalette (DWORD Unknown0
,
535 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
540 SetLastConsoleEventActive (VOID
)
545 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
550 ShowConsoleCursor (DWORD Unknown0
,
556 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
562 * FUNCTION: Checks whether the given handle is a valid console handle.
564 * Handle - Handle to be checked
566 * TRUE: Handle is a valid console handle
567 * FALSE: Handle is not a valid console handle.
568 * STATUS: Officially undocumented
571 VerifyConsoleIoHandle(HANDLE Handle
)
573 CSRSS_API_REQUEST Request
;
574 CSRSS_API_REPLY Reply
;
577 Request
.Type
= CSRSS_VERIFY_HANDLE
;
578 Request
.Data
.VerifyHandleRequest
.Handle
= Handle
;
579 Status
= CsrClientCallServer(&Request
,
581 sizeof(CSRSS_API_REQUEST
),
582 sizeof(CSRSS_API_REPLY
));
583 if (!NT_SUCCESS(Status
))
585 SetLastErrorByStatus(Status
);
589 return (BOOL
)NT_SUCCESS(Reply
.Status
);
594 WriteConsoleInputVDMA (DWORD Unknown0
,
599 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
604 WriteConsoleInputVDMW (DWORD Unknown0
,
609 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
614 CloseConsoleHandle(HANDLE Handle
)
619 CSRSS_API_REQUEST Request
;
620 CSRSS_API_REPLY Reply
;
623 if (IsConsoleHandle (Handle
) == FALSE
)
625 SetLastError (ERROR_INVALID_PARAMETER
);
629 Request
.Type
= CSRSS_CLOSE_HANDLE
;
630 Request
.Data
.CloseHandleRequest
.Handle
= Handle
;
631 Status
= CsrClientCallServer(&Request
,
633 sizeof(CSRSS_API_REQUEST
),
634 sizeof(CSRSS_API_REPLY
));
635 if (!NT_SUCCESS(Status
))
637 SetLastErrorByStatus(Status
);
646 IsConsoleHandle(HANDLE Handle
)
648 if ((((ULONG
)Handle
) & 0x10000003) == 0x3)
656 GetStdHandle(DWORD nStdHandle
)
658 * FUNCTION: Get a handle for the standard input, standard output
659 * and a standard error device.
661 * nStdHandle - Specifies the device for which to return the handle.
662 * RETURNS: If the function succeeds, the return value is the handle
663 * of the specified device. Otherwise the value is INVALID_HANDLE_VALUE.
666 PRTL_USER_PROCESS_PARAMETERS Ppb
;
668 Ppb
= NtCurrentPeb()->ProcessParameters
;
671 case STD_INPUT_HANDLE
:
672 return Ppb
->hStdInput
;
674 case STD_OUTPUT_HANDLE
:
675 return Ppb
->hStdOutput
;
677 case STD_ERROR_HANDLE
:
678 return Ppb
->hStdError
;
681 SetLastError (ERROR_INVALID_PARAMETER
);
682 return INVALID_HANDLE_VALUE
;
685 WINBASEAPI BOOL WINAPI
686 SetStdHandle(DWORD nStdHandle
,
689 * FUNCTION: Set the handle for the standard input, standard output or
690 * the standard error device.
692 * nStdHandle - Specifies the handle to be set.
693 * hHandle - The handle to set.
694 * RETURNS: TRUE if the function succeeds, FALSE otherwise.
697 PRTL_USER_PROCESS_PARAMETERS Ppb
;
699 Ppb
= NtCurrentPeb()->ProcessParameters
;
701 /* More checking needed? */
702 if (hHandle
== INVALID_HANDLE_VALUE
)
704 SetLastError (ERROR_INVALID_HANDLE
);
708 SetLastError(ERROR_SUCCESS
); /* OK */
712 case STD_INPUT_HANDLE
:
713 Ppb
->hStdInput
= hHandle
;
716 case STD_OUTPUT_HANDLE
:
717 Ppb
->hStdOutput
= hHandle
;
720 case STD_ERROR_HANDLE
:
721 Ppb
->hStdError
= hHandle
;
725 SetLastError (ERROR_INVALID_PARAMETER
);
730 /*--------------------------------------------------------------
734 WriteConsoleA(HANDLE hConsoleOutput
,
735 CONST VOID
*lpBuffer
,
736 DWORD nNumberOfCharsToWrite
,
737 LPDWORD lpNumberOfCharsWritten
,
740 PCSRSS_API_REQUEST Request
;
741 CSRSS_API_REPLY Reply
;
746 Request
= RtlAllocateHeap(GetProcessHeap(),
748 sizeof(CSRSS_API_REQUEST
) +
749 CSRSS_MAX_WRITE_CONSOLE_REQUEST
);
752 SetLastError(ERROR_OUTOFMEMORY
);
756 Request
->Type
= CSRSS_WRITE_CONSOLE
;
757 Request
->Data
.WriteConsoleRequest
.ConsoleHandle
= hConsoleOutput
;
758 if (lpNumberOfCharsWritten
!= NULL
)
759 *lpNumberOfCharsWritten
= nNumberOfCharsToWrite
;
760 while (nNumberOfCharsToWrite
)
762 if (nNumberOfCharsToWrite
> CSRSS_MAX_WRITE_CONSOLE_REQUEST
)
764 Size
= CSRSS_MAX_WRITE_CONSOLE_REQUEST
;
768 Size
= nNumberOfCharsToWrite
;
770 Request
->Data
.WriteConsoleRequest
.NrCharactersToWrite
= Size
;
772 memcpy(Request
->Data
.WriteConsoleRequest
.Buffer
, lpBuffer
, Size
);
774 MessageSize
= CSRSS_REQUEST_HEADER_SIZE
+
775 sizeof(CSRSS_WRITE_CONSOLE_REQUEST
) + Size
;
776 Status
= CsrClientCallServer(Request
,
779 sizeof(CSRSS_API_REPLY
));
781 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
783 RtlFreeHeap(GetProcessHeap(), 0, Request
);
784 SetLastErrorByStatus(Status
);
787 nNumberOfCharsToWrite
-= Size
;
791 RtlFreeHeap(GetProcessHeap(), 0, Request
);
797 /*--------------------------------------------------------------
800 WINBOOL STDCALL
ReadConsoleA(HANDLE hConsoleInput
,
802 DWORD nNumberOfCharsToRead
,
803 LPDWORD lpNumberOfCharsRead
,
806 CSRSS_API_REQUEST Request
;
807 PCSRSS_API_REPLY Reply
;
811 Reply
= RtlAllocateHeap(GetProcessHeap(),
813 sizeof(CSRSS_API_REPLY
) + nNumberOfCharsToRead
);
816 SetLastError(ERROR_OUTOFMEMORY
);
820 Request
.Type
= CSRSS_READ_CONSOLE
;
821 Request
.Data
.ReadConsoleRequest
.ConsoleHandle
= hConsoleInput
;
822 Request
.Data
.ReadConsoleRequest
.NrCharactersToRead
= nNumberOfCharsToRead
> CSRSS_MAX_READ_CONSOLE_REQUEST
? CSRSS_MAX_READ_CONSOLE_REQUEST
: nNumberOfCharsToRead
;
823 Request
.Data
.ReadConsoleRequest
.nCharsCanBeDeleted
= 0;
824 Status
= CsrClientCallServer(&Request
,
826 sizeof(CSRSS_API_REQUEST
),
827 sizeof(CSRSS_API_REPLY
) +
828 Request
.Data
.ReadConsoleRequest
.NrCharactersToRead
);
829 if (!NT_SUCCESS(Status
) || !NT_SUCCESS( Status
= Reply
->Status
))
831 DbgPrint( "CSR returned error in ReadConsole\n" );
832 SetLastErrorByStatus ( Status
);
833 RtlFreeHeap( GetProcessHeap(), 0, Reply
);
836 if( Reply
->Status
== STATUS_NOTIFY_CLEANUP
)
837 Reply
->Status
= STATUS_PENDING
; // ignore backspace because we have no chars to backspace
838 /* There may not be any chars or lines to read yet, so wait */
839 while( Reply
->Status
== STATUS_PENDING
)
841 /* some chars may have been returned, but not a whole line yet, so recompute buffer and try again */
842 nNumberOfCharsToRead
-= Reply
->Data
.ReadConsoleReply
.NrCharactersRead
;
843 /* don't overflow caller's buffer, even if you still don't have a complete line */
844 if( !nNumberOfCharsToRead
)
846 Request
.Data
.ReadConsoleRequest
.NrCharactersToRead
= nNumberOfCharsToRead
> CSRSS_MAX_READ_CONSOLE_REQUEST
? CSRSS_MAX_READ_CONSOLE_REQUEST
: nNumberOfCharsToRead
;
847 /* copy any chars already read to buffer */
848 memcpy( lpBuffer
+ CharsRead
, Reply
->Data
.ReadConsoleReply
.Buffer
, Reply
->Data
.ReadConsoleReply
.NrCharactersRead
);
849 CharsRead
+= Reply
->Data
.ReadConsoleReply
.NrCharactersRead
;
850 /* wait for csrss to signal there is more data to read, but not if we got STATUS_NOTIFY_CLEANUP for backspace */
851 Status
= NtWaitForSingleObject( Reply
->Data
.ReadConsoleReply
.EventHandle
, FALSE
, 0 );
852 if( !NT_SUCCESS( Status
) )
854 DbgPrint( "Wait for console input failed!\n" );
855 RtlFreeHeap( GetProcessHeap(), 0, Reply
);
858 Request
.Data
.ReadConsoleRequest
.nCharsCanBeDeleted
= CharsRead
;
859 Status
= CsrClientCallServer( &Request
, Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) + Request
.Data
.ReadConsoleRequest
.NrCharactersToRead
);
860 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
->Status
) )
862 SetLastErrorByStatus ( Status
);
863 RtlFreeHeap( GetProcessHeap(), 0, Reply
);
866 if( Reply
->Status
== STATUS_NOTIFY_CLEANUP
)
872 nNumberOfCharsToRead
++;
874 Reply
->Status
= STATUS_PENDING
; // retry
877 /* copy data to buffer, count total returned, and return */
878 memcpy( lpBuffer
+ CharsRead
, Reply
->Data
.ReadConsoleReply
.Buffer
, Reply
->Data
.ReadConsoleReply
.NrCharactersRead
);
879 CharsRead
+= Reply
->Data
.ReadConsoleReply
.NrCharactersRead
;
880 if (lpNumberOfCharsRead
!= NULL
)
881 *lpNumberOfCharsRead
= CharsRead
;
882 RtlFreeHeap(GetProcessHeap(),
890 /*--------------------------------------------------------------
893 WINBOOL STDCALL
AllocConsole(VOID
)
895 CSRSS_API_REQUEST Request
;
896 CSRSS_API_REPLY Reply
;
900 Request
.Type
= CSRSS_ALLOC_CONSOLE
;
901 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
902 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
904 SetLastErrorByStatus ( Status
);
907 SetStdHandle( STD_INPUT_HANDLE
, Reply
.Data
.AllocConsoleReply
.InputHandle
);
908 SetStdHandle( STD_OUTPUT_HANDLE
, Reply
.Data
.AllocConsoleReply
.OutputHandle
);
909 hStdError
= DuplicateConsoleHandle(Reply
.Data
.AllocConsoleReply
.OutputHandle
,
912 DUPLICATE_SAME_ACCESS
);
913 SetStdHandle( STD_ERROR_HANDLE
, hStdError
);
918 /*--------------------------------------------------------------
921 WINBOOL STDCALL
FreeConsole(VOID
)
923 DbgPrint("FreeConsole() is unimplemented\n");
928 /*--------------------------------------------------------------
929 * GetConsoleScreenBufferInfo
933 GetConsoleScreenBufferInfo(
934 HANDLE hConsoleOutput
,
935 PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo
938 CSRSS_API_REQUEST Request
;
939 CSRSS_API_REPLY Reply
;
942 Request
.Type
= CSRSS_SCREEN_BUFFER_INFO
;
943 Request
.Data
.ScreenBufferInfoRequest
.ConsoleHandle
= hConsoleOutput
;
944 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
945 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
947 SetLastErrorByStatus ( Status
);
950 *lpConsoleScreenBufferInfo
= Reply
.Data
.ScreenBufferInfoReply
.Info
;
955 /*--------------------------------------------------------------
956 * SetConsoleCursorPosition
960 SetConsoleCursorPosition(
961 HANDLE hConsoleOutput
,
962 COORD dwCursorPosition
965 CSRSS_API_REQUEST Request
;
966 CSRSS_API_REPLY Reply
;
969 Request
.Type
= CSRSS_SET_CURSOR
;
970 Request
.Data
.SetCursorRequest
.ConsoleHandle
= hConsoleOutput
;
971 Request
.Data
.SetCursorRequest
.Position
= dwCursorPosition
;
972 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
973 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
975 SetLastErrorByStatus ( Status
);
982 /*--------------------------------------------------------------
983 * FillConsoleOutputCharacterA
986 FillConsoleOutputCharacterA(
987 HANDLE hConsoleOutput
,
991 LPDWORD lpNumberOfCharsWritten
994 CSRSS_API_REQUEST Request
;
995 CSRSS_API_REPLY Reply
;
998 Request
.Type
= CSRSS_FILL_OUTPUT
;
999 Request
.Data
.FillOutputRequest
.ConsoleHandle
= hConsoleOutput
;
1000 Request
.Data
.FillOutputRequest
.Char
= cCharacter
;
1001 Request
.Data
.FillOutputRequest
.Position
= dwWriteCoord
;
1002 Request
.Data
.FillOutputRequest
.Length
= nLength
;
1003 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
1004 if ( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1006 SetLastErrorByStatus(Status
);
1009 if (lpNumberOfCharsWritten
!= NULL
)
1010 *lpNumberOfCharsWritten
= nLength
;
1015 /*--------------------------------------------------------------
1016 * FillConsoleOutputCharacterW
1020 FillConsoleOutputCharacterW(
1021 HANDLE hConsoleOutput
,
1025 LPDWORD lpNumberOfCharsWritten
1033 /*--------------------------------------------------------------
1040 HANDLE hConsoleInput
,
1041 PINPUT_RECORD lpBuffer
,
1043 LPDWORD lpNumberOfEventsRead
1046 PCSRSS_API_REQUEST Request
;
1047 CSRSS_API_REPLY Reply
;
1050 PVOID BufferTargetBase
;
1053 if(lpBuffer
== NULL
)
1055 SetLastError(ERROR_INVALID_PARAMETER
);
1059 Size
= nLength
* sizeof(INPUT_RECORD
);
1061 Status
= CsrCaptureParameterBuffer((PVOID
)lpBuffer
, Size
, &BufferBase
, &BufferTargetBase
);
1062 if(!NT_SUCCESS(Status
))
1064 SetLastErrorByStatus(Status
);
1068 Request
= RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(CSRSS_API_REQUEST
));
1071 CsrReleaseParameterBuffer(BufferBase
);
1072 SetLastError(ERROR_OUTOFMEMORY
);
1076 Request
->Type
= CSRSS_PEEK_CONSOLE_INPUT
;
1077 Request
->Data
.PeekConsoleInputRequest
.ConsoleHandle
= hConsoleInput
;
1078 Request
->Data
.PeekConsoleInputRequest
.Length
= nLength
;
1079 Request
->Data
.PeekConsoleInputRequest
.InputRecord
= (INPUT_RECORD
*)BufferTargetBase
;
1081 Status
= CsrClientCallServer(Request
, &Reply
, sizeof(CSRSS_API_REQUEST
), sizeof(CSRSS_API_REPLY
));
1083 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1085 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1086 CsrReleaseParameterBuffer(BufferBase
);
1090 memcpy(lpBuffer
, BufferBase
, sizeof(INPUT_RECORD
) * Reply
.Data
.PeekConsoleInputReply
.Length
);
1092 if(lpNumberOfEventsRead
!= NULL
)
1093 *lpNumberOfEventsRead
= Reply
.Data
.PeekConsoleInputReply
.Length
;
1095 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1096 CsrReleaseParameterBuffer(BufferBase
);
1102 /*--------------------------------------------------------------
1109 HANDLE hConsoleInput
,
1110 PINPUT_RECORD lpBuffer
,
1112 LPDWORD lpNumberOfEventsRead
1120 /*--------------------------------------------------------------
1123 WINBASEAPI BOOL WINAPI
1124 ReadConsoleInputA(HANDLE hConsoleInput
,
1125 PINPUT_RECORD lpBuffer
,
1127 LPDWORD lpNumberOfEventsRead
)
1129 CSRSS_API_REQUEST Request
;
1130 CSRSS_API_REPLY Reply
;
1131 DWORD NumEventsRead
;
1134 Request
.Type
= CSRSS_READ_INPUT
;
1135 Request
.Data
.ReadInputRequest
.ConsoleHandle
= hConsoleInput
;
1136 Status
= CsrClientCallServer(&Request
, &Reply
, sizeof(CSRSS_API_REQUEST
),
1137 sizeof(CSRSS_API_REPLY
));
1138 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1140 SetLastErrorByStatus(Status
);
1144 while (Status
== STATUS_PENDING
)
1146 Status
= NtWaitForSingleObject(Reply
.Data
.ReadInputReply
.Event
, FALSE
,
1148 if(!NT_SUCCESS(Status
))
1150 SetLastErrorByStatus(Status
);
1154 Request
.Type
= CSRSS_READ_INPUT
;
1155 Request
.Data
.ReadInputRequest
.ConsoleHandle
= hConsoleInput
;
1156 Status
= CsrClientCallServer(&Request
, &Reply
, sizeof(CSRSS_API_REQUEST
),
1157 sizeof(CSRSS_API_REPLY
));
1158 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1160 SetLastErrorByStatus(Status
);
1166 *lpBuffer
= Reply
.Data
.ReadInputReply
.Input
;
1170 while ((NumEventsRead
< nLength
) && (Reply
.Data
.ReadInputReply
.MoreEvents
))
1172 Status
= CsrClientCallServer(&Request
, &Reply
, sizeof(CSRSS_API_REQUEST
),
1173 sizeof(CSRSS_API_REPLY
));
1174 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1176 SetLastErrorByStatus(Status
);
1180 if (Status
== STATUS_PENDING
)
1185 *lpBuffer
= Reply
.Data
.ReadInputReply
.Input
;
1190 *lpNumberOfEventsRead
= NumEventsRead
;
1196 /*--------------------------------------------------------------
1203 HANDLE hConsoleInput
,
1204 PINPUT_RECORD lpBuffer
,
1206 LPDWORD lpNumberOfEventsRead
1214 /*--------------------------------------------------------------
1215 * WriteConsoleInputA
1221 HANDLE hConsoleInput
,
1222 CONST INPUT_RECORD
*lpBuffer
,
1224 LPDWORD lpNumberOfEventsWritten
1227 PCSRSS_API_REQUEST Request
;
1228 CSRSS_API_REPLY Reply
;
1229 PVOID BufferBase
, BufferTargetBase
;
1233 if(lpBuffer
== NULL
)
1235 SetLastError(ERROR_INVALID_PARAMETER
);
1239 Size
= nLength
* sizeof(INPUT_RECORD
);
1241 Status
= CsrCaptureParameterBuffer((PVOID
)lpBuffer
, Size
, &BufferBase
, &BufferTargetBase
);
1242 if(!NT_SUCCESS(Status
))
1244 SetLastErrorByStatus(Status
);
1248 Request
= RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(CSRSS_API_REQUEST
));
1251 SetLastError(ERROR_OUTOFMEMORY
);
1252 CsrReleaseParameterBuffer(BufferBase
);
1256 Request
->Type
= CSRSS_WRITE_CONSOLE_INPUT
;
1257 Request
->Data
.WriteConsoleInputRequest
.ConsoleHandle
= hConsoleInput
;
1258 Request
->Data
.WriteConsoleInputRequest
.Length
= nLength
;
1259 Request
->Data
.WriteConsoleInputRequest
.InputRecord
= (PINPUT_RECORD
)BufferTargetBase
;
1261 Status
= CsrClientCallServer(Request
, &Reply
, sizeof(CSRSS_API_REQUEST
), sizeof(CSRSS_API_REPLY
));
1262 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1264 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1265 CsrReleaseParameterBuffer(BufferBase
);
1269 if(lpNumberOfEventsWritten
!= NULL
)
1270 *lpNumberOfEventsWritten
= Reply
.Data
.WriteConsoleInputReply
.Length
;
1272 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1273 CsrReleaseParameterBuffer(BufferBase
);
1279 /*--------------------------------------------------------------
1280 * WriteConsoleInputW
1286 HANDLE hConsoleInput
,
1287 CONST INPUT_RECORD
*lpBuffer
,
1289 LPDWORD lpNumberOfEventsWritten
1297 /*--------------------------------------------------------------
1298 * ReadConsoleOutputA
1304 HANDLE hConsoleOutput
,
1305 PCHAR_INFO lpBuffer
,
1307 COORD dwBufferCoord
,
1308 PSMALL_RECT lpReadRegion
1311 PCSRSS_API_REQUEST Request
;
1312 CSRSS_API_REPLY Reply
;
1314 PVOID BufferTargetBase
;
1316 DWORD Size
, SizeX
, SizeY
;
1318 if(lpBuffer
== NULL
)
1320 SetLastError(ERROR_INVALID_PARAMETER
);
1324 Size
= dwBufferSize
.X
* dwBufferSize
.Y
* sizeof(CHAR_INFO
);
1326 Status
= CsrCaptureParameterBuffer((PVOID
)lpBuffer
, Size
, &BufferBase
, &BufferTargetBase
);
1327 if(!NT_SUCCESS(Status
))
1329 SetLastErrorByStatus(Status
);
1333 Request
= RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(CSRSS_API_REQUEST
));
1336 SetLastError(ERROR_OUTOFMEMORY
);
1337 CsrReleaseParameterBuffer(BufferBase
);
1341 Request
->Type
= CSRSS_READ_CONSOLE_OUTPUT
;
1342 Request
->Data
.ReadConsoleOutputRequest
.ConsoleHandle
= hConsoleOutput
;
1343 Request
->Data
.ReadConsoleOutputRequest
.BufferSize
= dwBufferSize
;
1344 Request
->Data
.ReadConsoleOutputRequest
.BufferCoord
= dwBufferCoord
;
1345 Request
->Data
.ReadConsoleOutputRequest
.ReadRegion
= *lpReadRegion
;
1346 Request
->Data
.ReadConsoleOutputRequest
.CharInfo
= (PCHAR_INFO
)BufferTargetBase
;
1348 Status
= CsrClientCallServer(Request
, &Reply
, sizeof(CSRSS_API_REQUEST
), sizeof(CSRSS_API_REPLY
));
1349 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1351 SetLastErrorByStatus(Status
);
1352 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1353 CsrReleaseParameterBuffer(BufferBase
);
1357 SizeX
= Reply
.Data
.ReadConsoleOutputReply
.ReadRegion
.Right
- Reply
.Data
.ReadConsoleOutputReply
.ReadRegion
.Left
+ 1;
1358 SizeY
= Reply
.Data
.ReadConsoleOutputReply
.ReadRegion
.Bottom
- Reply
.Data
.ReadConsoleOutputReply
.ReadRegion
.Top
+ 1;
1360 memcpy(lpBuffer
, BufferBase
, sizeof(CHAR_INFO
) * SizeX
* SizeY
);
1361 *lpReadRegion
= Reply
.Data
.ReadConsoleOutputReply
.ReadRegion
;
1363 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1364 CsrReleaseParameterBuffer(BufferBase
);
1370 /*--------------------------------------------------------------
1371 * ReadConsoleOutputW
1377 HANDLE hConsoleOutput
,
1378 PCHAR_INFO lpBuffer
,
1380 COORD dwBufferCoord
,
1381 PSMALL_RECT lpReadRegion
1388 /*--------------------------------------------------------------
1389 * WriteConsoleOutputA
1391 WINBASEAPI BOOL WINAPI
1392 WriteConsoleOutputA(HANDLE hConsoleOutput
,
1393 CONST CHAR_INFO
*lpBuffer
,
1395 COORD dwBufferCoord
,
1396 PSMALL_RECT lpWriteRegion
)
1398 PCSRSS_API_REQUEST Request
;
1399 CSRSS_API_REPLY Reply
;
1405 PVOID BufferTargetBase
;
1407 Size
= dwBufferSize
.Y
* dwBufferSize
.X
* sizeof(CHAR_INFO
);
1409 Status
= CsrCaptureParameterBuffer((PVOID
)lpBuffer
,
1413 if (!NT_SUCCESS(Status
))
1415 SetLastErrorByStatus(Status
);
1419 Request
= RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY
,
1420 sizeof(CSRSS_API_REQUEST
));
1421 if (Request
== NULL
)
1423 CsrReleaseParameterBuffer(BufferBase
);
1424 SetLastError(ERROR_OUTOFMEMORY
);
1427 Request
->Type
= CSRSS_WRITE_CONSOLE_OUTPUT
;
1428 Request
->Data
.WriteConsoleOutputRequest
.ConsoleHandle
= hConsoleOutput
;
1429 Request
->Data
.WriteConsoleOutputRequest
.BufferSize
= dwBufferSize
;
1430 Request
->Data
.WriteConsoleOutputRequest
.BufferCoord
= dwBufferCoord
;
1431 Request
->Data
.WriteConsoleOutputRequest
.WriteRegion
= *lpWriteRegion
;
1432 Request
->Data
.WriteConsoleOutputRequest
.CharInfo
=
1433 (CHAR_INFO
*)BufferTargetBase
;
1435 Status
= CsrClientCallServer(Request
, &Reply
,
1436 sizeof(CSRSS_API_REQUEST
),
1437 sizeof(CSRSS_API_REPLY
));
1438 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1440 CsrReleaseParameterBuffer(BufferBase
);
1441 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1442 SetLastErrorByStatus(Status
);
1446 *lpWriteRegion
= Reply
.Data
.WriteConsoleOutputReply
.WriteRegion
;
1447 RtlFreeHeap(GetProcessHeap(), 0, Request
);
1448 CsrReleaseParameterBuffer(BufferBase
);
1453 /*--------------------------------------------------------------
1454 * WriteConsoleOutputW
1459 WriteConsoleOutputW(
1460 HANDLE hConsoleOutput
,
1461 CONST CHAR_INFO
*lpBuffer
,
1463 COORD dwBufferCoord
,
1464 PSMALL_RECT lpWriteRegion
1472 /*--------------------------------------------------------------
1473 * ReadConsoleOutputCharacterA
1478 ReadConsoleOutputCharacterA(
1479 HANDLE hConsoleOutput
,
1483 LPDWORD lpNumberOfCharsRead
1486 CSRSS_API_REQUEST Request
;
1487 PCSRSS_API_REPLY Reply
;
1491 Reply
= RtlAllocateHeap(GetProcessHeap(),
1493 sizeof(CSRSS_API_REPLY
) + CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR
);
1496 SetLastError(ERROR_OUTOFMEMORY
);
1500 if (lpNumberOfCharsRead
!= NULL
)
1501 *lpNumberOfCharsRead
= nLength
;
1503 Request
.Type
= CSRSS_READ_CONSOLE_OUTPUT_CHAR
;
1504 Request
.Data
.ReadConsoleOutputCharRequest
.ConsoleHandle
= hConsoleOutput
;
1505 Request
.Data
.ReadConsoleOutputCharRequest
.ReadCoord
= dwReadCoord
;
1507 while (nLength
!= 0)
1509 if (nLength
> CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR
)
1510 Size
= CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR
;
1514 Request
.Data
.ReadConsoleOutputCharRequest
.NumCharsToRead
= Size
;
1516 Status
= CsrClientCallServer(&Request
,
1518 sizeof(CSRSS_API_REQUEST
),
1519 sizeof(CSRSS_API_REPLY
) + Size
);
1520 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Reply
->Status
))
1522 RtlFreeHeap(GetProcessHeap(), 0, Reply
);
1523 SetLastErrorByStatus(Status
);
1527 memcpy(lpCharacter
, &Reply
->Data
.ReadConsoleOutputCharReply
.String
[0], Size
);
1528 lpCharacter
+= Size
;
1530 Request
.Data
.ReadConsoleOutputCharRequest
.ReadCoord
= Reply
->Data
.ReadConsoleOutputCharReply
.EndCoord
;
1533 RtlFreeHeap(GetProcessHeap(), 0, Reply
);
1539 /*--------------------------------------------------------------
1540 * ReadConsoleOutputCharacterW
1545 ReadConsoleOutputCharacterW(
1546 HANDLE hConsoleOutput
,
1550 LPDWORD lpNumberOfCharsRead
1558 /*--------------------------------------------------------------
1559 * ReadConsoleOutputAttribute
1564 ReadConsoleOutputAttribute(
1565 HANDLE hConsoleOutput
,
1569 LPDWORD lpNumberOfAttrsRead
1572 CSRSS_API_REQUEST Request
;
1573 PCSRSS_API_REPLY Reply
;
1577 Reply
= RtlAllocateHeap(GetProcessHeap(),
1579 sizeof(CSRSS_API_REPLY
) + CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB
);
1582 SetLastError(ERROR_OUTOFMEMORY
);
1586 if (lpNumberOfAttrsRead
!= NULL
)
1587 *lpNumberOfAttrsRead
= nLength
;
1589 Request
.Type
= CSRSS_READ_CONSOLE_OUTPUT_ATTRIB
;
1590 Request
.Data
.ReadConsoleOutputAttribRequest
.ConsoleHandle
= hConsoleOutput
;
1591 Request
.Data
.ReadConsoleOutputAttribRequest
.ReadCoord
= dwReadCoord
;
1593 while (nLength
!= 0)
1595 if (nLength
> CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB
)
1596 Size
= CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB
;
1600 Request
.Data
.ReadConsoleOutputAttribRequest
.NumAttrsToRead
= Size
;
1602 Status
= CsrClientCallServer(&Request
,
1604 sizeof(CSRSS_API_REQUEST
),
1605 sizeof(CSRSS_API_REPLY
) + Size
);
1606 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Reply
->Status
))
1608 RtlFreeHeap(GetProcessHeap(), 0, Reply
);
1609 SetLastErrorByStatus(Status
);
1613 // Convert CHARs to WORDs
1614 for(i
= 0; i
< Size
; ++i
)
1615 *lpAttribute
++ = Reply
->Data
.ReadConsoleOutputAttribReply
.String
[i
];
1618 Request
.Data
.ReadConsoleOutputAttribRequest
.ReadCoord
= Reply
->Data
.ReadConsoleOutputAttribReply
.EndCoord
;
1621 RtlFreeHeap(GetProcessHeap(), 0, Reply
);
1627 /*--------------------------------------------------------------
1628 * WriteConsoleOutputCharacterA
1630 WINBASEAPI BOOL WINAPI
1631 WriteConsoleOutputCharacterA(HANDLE hConsoleOutput
,
1635 LPDWORD lpNumberOfCharsWritten
)
1637 PCSRSS_API_REQUEST Request
;
1638 CSRSS_API_REPLY Reply
;
1642 Request
= RtlAllocateHeap(GetProcessHeap(),
1644 sizeof(CSRSS_API_REQUEST
) + CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR
);
1647 SetLastError( ERROR_OUTOFMEMORY
);
1650 Request
->Type
= CSRSS_WRITE_CONSOLE_OUTPUT_CHAR
;
1651 Request
->Data
.WriteConsoleOutputCharRequest
.ConsoleHandle
= hConsoleOutput
;
1652 Request
->Data
.WriteConsoleOutputCharRequest
.Coord
= dwWriteCoord
;
1653 if( lpNumberOfCharsWritten
)
1654 *lpNumberOfCharsWritten
= nLength
;
1657 Size
= nLength
> CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR
? CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR
: nLength
;
1658 Request
->Data
.WriteConsoleOutputCharRequest
.Length
= Size
;
1659 memcpy( &Request
->Data
.WriteConsoleOutputCharRequest
.String
[0],
1662 Status
= CsrClientCallServer( Request
, &Reply
, sizeof( CSRSS_API_REQUEST
) + Size
, sizeof( CSRSS_API_REPLY
) );
1663 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1665 RtlFreeHeap( GetProcessHeap(), 0, Request
);
1666 SetLastErrorByStatus ( Status
);
1670 lpCharacter
+= Size
;
1671 Request
->Data
.WriteConsoleOutputCharRequest
.Coord
= Reply
.Data
.WriteConsoleOutputCharReply
.EndCoord
;
1674 RtlFreeHeap( GetProcessHeap(), 0, Request
);
1679 /*--------------------------------------------------------------
1680 * WriteConsoleOutputCharacterW
1685 WriteConsoleOutputCharacterW(
1686 HANDLE hConsoleOutput
,
1687 LPCWSTR lpCharacter
,
1690 LPDWORD lpNumberOfCharsWritten
1699 /*--------------------------------------------------------------
1700 * WriteConsoleOutputAttribute
1705 WriteConsoleOutputAttribute(
1706 HANDLE hConsoleOutput
,
1707 CONST WORD
*lpAttribute
,
1710 LPDWORD lpNumberOfAttrsWritten
1713 PCSRSS_API_REQUEST Request
;
1714 CSRSS_API_REPLY Reply
;
1719 Request
= RtlAllocateHeap(GetProcessHeap(),
1721 sizeof(CSRSS_API_REQUEST
) + CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB
);
1724 SetLastError( ERROR_OUTOFMEMORY
);
1727 Request
->Type
= CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB
;
1728 Request
->Data
.WriteConsoleOutputAttribRequest
.ConsoleHandle
= hConsoleOutput
;
1729 Request
->Data
.WriteConsoleOutputAttribRequest
.Coord
= dwWriteCoord
;
1730 if( lpNumberOfAttrsWritten
)
1731 *lpNumberOfAttrsWritten
= nLength
;
1734 Size
= nLength
> CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB
? CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB
: nLength
;
1735 Request
->Data
.WriteConsoleOutputAttribRequest
.Length
= Size
;
1736 for( c
= 0; c
< ( Size
* 2 ); c
++ )
1737 Request
->Data
.WriteConsoleOutputAttribRequest
.String
[c
] = (char)lpAttribute
[c
];
1738 Status
= CsrClientCallServer( Request
, &Reply
, sizeof( CSRSS_API_REQUEST
) + (Size
* 2), sizeof( CSRSS_API_REPLY
) );
1739 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1741 RtlFreeHeap( GetProcessHeap(), 0, Request
);
1742 SetLastErrorByStatus ( Status
);
1746 lpAttribute
+= Size
;
1747 Request
->Data
.WriteConsoleOutputAttribRequest
.Coord
= Reply
.Data
.WriteConsoleOutputAttribReply
.EndCoord
;
1750 RtlFreeHeap( GetProcessHeap(), 0, Request
);
1755 /*--------------------------------------------------------------
1756 * FillConsoleOutputAttribute
1761 FillConsoleOutputAttribute(
1762 HANDLE hConsoleOutput
,
1766 LPDWORD lpNumberOfAttrsWritten
1769 CSRSS_API_REQUEST Request
;
1770 CSRSS_API_REPLY Reply
;
1773 Request
.Type
= CSRSS_FILL_OUTPUT_ATTRIB
;
1774 Request
.Data
.FillOutputAttribRequest
.ConsoleHandle
= hConsoleOutput
;
1775 Request
.Data
.FillOutputAttribRequest
.Attribute
= wAttribute
;
1776 Request
.Data
.FillOutputAttribRequest
.Coord
= dwWriteCoord
;
1777 Request
.Data
.FillOutputAttribRequest
.Length
= nLength
;
1778 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
1779 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1781 SetLastErrorByStatus ( Status
);
1784 if( lpNumberOfAttrsWritten
)
1785 *lpNumberOfAttrsWritten
= nLength
;
1790 /*--------------------------------------------------------------
1797 HANDLE hConsoleHandle
,
1801 CSRSS_API_REQUEST Request
;
1802 CSRSS_API_REPLY Reply
;
1805 Request
.Type
= CSRSS_GET_MODE
;
1806 Request
.Data
.GetConsoleModeRequest
.ConsoleHandle
= hConsoleHandle
;
1807 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
1808 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1810 SetLastErrorByStatus ( Status
);
1813 *lpMode
= Reply
.Data
.GetConsoleModeReply
.ConsoleMode
;
1818 /*--------------------------------------------------------------
1819 * GetNumberOfConsoleInputEvents
1824 GetNumberOfConsoleInputEvents(
1825 HANDLE hConsoleInput
,
1826 LPDWORD lpNumberOfEvents
1829 CSRSS_API_REQUEST Request
;
1830 CSRSS_API_REPLY Reply
;
1833 if(lpNumberOfEvents
== NULL
)
1835 SetLastError(ERROR_INVALID_PARAMETER
);
1839 Request
.Type
= CSRSS_GET_NUM_INPUT_EVENTS
;
1840 Request
.Data
.GetNumInputEventsRequest
.ConsoleHandle
= hConsoleInput
;
1841 Status
= CsrClientCallServer(&Request
, &Reply
, sizeof(CSRSS_API_REQUEST
), sizeof(CSRSS_API_REPLY
));
1842 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Reply
.Status
))
1844 SetLastErrorByStatus(Status
);
1848 *lpNumberOfEvents
= Reply
.Data
.GetNumInputEventsReply
.NumInputEvents
;
1854 /*--------------------------------------------------------------
1855 * GetLargestConsoleWindowSize
1860 GetLargestConsoleWindowSize(
1861 HANDLE hConsoleOutput
1865 COORD Coord
= {80,25};
1873 /*--------------------------------------------------------------
1874 * GetConsoleCursorInfo
1879 GetConsoleCursorInfo(
1880 HANDLE hConsoleOutput
,
1881 PCONSOLE_CURSOR_INFO lpConsoleCursorInfo
1884 CSRSS_API_REQUEST Request
;
1885 CSRSS_API_REPLY Reply
;
1888 Request
.Type
= CSRSS_GET_CURSOR_INFO
;
1889 Request
.Data
.GetCursorInfoRequest
.ConsoleHandle
= hConsoleOutput
;
1890 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
1892 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1894 SetLastErrorByStatus ( Status
);
1897 *lpConsoleCursorInfo
= Reply
.Data
.GetCursorInfoReply
.Info
;
1902 /*--------------------------------------------------------------
1903 * GetNumberOfConsoleMouseButtons
1908 GetNumberOfConsoleMouseButtons(
1909 LPDWORD lpNumberOfMouseButtons
1917 /*--------------------------------------------------------------
1924 HANDLE hConsoleHandle
,
1928 CSRSS_API_REQUEST Request
;
1929 CSRSS_API_REPLY Reply
;
1932 Request
.Type
= CSRSS_SET_MODE
;
1933 Request
.Data
.SetConsoleModeRequest
.ConsoleHandle
= hConsoleHandle
;
1934 Request
.Data
.SetConsoleModeRequest
.Mode
= dwMode
;
1935 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
1936 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1938 SetLastErrorByStatus ( Status
);
1945 /*--------------------------------------------------------------
1946 * SetConsoleActiveScreenBuffer
1951 SetConsoleActiveScreenBuffer(
1952 HANDLE hConsoleOutput
1955 CSRSS_API_REQUEST Request
;
1956 CSRSS_API_REPLY Reply
;
1959 Request
.Type
= CSRSS_SET_SCREEN_BUFFER
;
1960 Request
.Data
.SetActiveScreenBufferRequest
.OutputHandle
= hConsoleOutput
;
1961 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
1962 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1964 SetLastErrorByStatus ( Status
);
1971 /*--------------------------------------------------------------
1972 * FlushConsoleInputBuffer
1977 FlushConsoleInputBuffer(
1978 HANDLE hConsoleInput
1981 CSRSS_API_REQUEST Request
;
1982 CSRSS_API_REPLY Reply
;
1985 Request
.Type
= CSRSS_FLUSH_INPUT_BUFFER
;
1986 Request
.Data
.FlushInputBufferRequest
.ConsoleInput
= hConsoleInput
;
1987 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
1988 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
1990 SetLastErrorByStatus ( Status
);
1997 /*--------------------------------------------------------------
1998 * SetConsoleScreenBufferSize
2003 SetConsoleScreenBufferSize(
2004 HANDLE hConsoleOutput
,
2012 /*--------------------------------------------------------------
2013 * SetConsoleCursorInfo
2018 SetConsoleCursorInfo(
2019 HANDLE hConsoleOutput
,
2020 CONST CONSOLE_CURSOR_INFO
*lpConsoleCursorInfo
2023 CSRSS_API_REQUEST Request
;
2024 CSRSS_API_REPLY Reply
;
2027 Request
.Type
= CSRSS_SET_CURSOR_INFO
;
2028 Request
.Data
.SetCursorInfoRequest
.ConsoleHandle
= hConsoleOutput
;
2029 Request
.Data
.SetCursorInfoRequest
.Info
= *lpConsoleCursorInfo
;
2030 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
2032 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2034 SetLastErrorByStatus ( Status
);
2041 /*--------------------------------------------------------------
2042 * ScrollConsoleScreenBufferA
2047 ScrollConsoleScreenBufferA(
2048 HANDLE hConsoleOutput
,
2049 CONST SMALL_RECT
*lpScrollRectangle
,
2050 CONST SMALL_RECT
*lpClipRectangle
,
2051 COORD dwDestinationOrigin
,
2052 CONST CHAR_INFO
*lpFill
2055 CSRSS_API_REQUEST Request
;
2056 CSRSS_API_REPLY Reply
;
2059 Request
.Type
= CSRSS_SCROLL_CONSOLE_SCREEN_BUFFER
;
2060 Request
.Data
.ScrollConsoleScreenBufferRequest
.ConsoleHandle
= hConsoleOutput
;
2061 Request
.Data
.ScrollConsoleScreenBufferRequest
.ScrollRectangle
= *lpScrollRectangle
;
2063 if (lpClipRectangle
!= NULL
)
2065 Request
.Data
.ScrollConsoleScreenBufferRequest
.UseClipRectangle
= TRUE
;
2066 Request
.Data
.ScrollConsoleScreenBufferRequest
.ClipRectangle
= *lpClipRectangle
;
2070 Request
.Data
.ScrollConsoleScreenBufferRequest
.UseClipRectangle
= FALSE
;
2073 Request
.Data
.ScrollConsoleScreenBufferRequest
.DestinationOrigin
= dwDestinationOrigin
;
2074 Request
.Data
.ScrollConsoleScreenBufferRequest
.Fill
= *lpFill
;
2075 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
2077 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2079 SetLastErrorByStatus ( Status
);
2086 /*--------------------------------------------------------------
2087 * ScrollConsoleScreenBufferW
2092 ScrollConsoleScreenBufferW(
2093 HANDLE hConsoleOutput
,
2094 CONST SMALL_RECT
*lpScrollRectangle
,
2095 CONST SMALL_RECT
*lpClipRectangle
,
2096 COORD dwDestinationOrigin
,
2097 CONST CHAR_INFO
*lpFill
2105 /*--------------------------------------------------------------
2106 * SetConsoleWindowInfo
2111 SetConsoleWindowInfo(
2112 HANDLE hConsoleOutput
,
2114 CONST SMALL_RECT
*lpConsoleWindow
2122 /*--------------------------------------------------------------
2123 * SetConsoleTextAttribute
2128 SetConsoleTextAttribute(
2129 HANDLE hConsoleOutput
,
2133 CSRSS_API_REQUEST Request
;
2134 CSRSS_API_REPLY Reply
;
2137 Request
.Type
= CSRSS_SET_ATTRIB
;
2138 Request
.Data
.SetAttribRequest
.ConsoleHandle
= hConsoleOutput
;
2139 Request
.Data
.SetAttribRequest
.Attrib
= wAttributes
;
2140 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
2141 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2143 SetLastErrorByStatus ( Status
);
2150 AddConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine
)
2152 if (HandlerRoutine
== NULL
)
2154 IgnoreCtrlEvents
= TRUE
;
2161 RtlReAllocateHeap(RtlGetProcessHeap(),
2163 (PVOID
)CtrlHandlers
,
2164 NrCtrlHandlers
* sizeof(PHANDLER_ROUTINE
));
2165 if (CtrlHandlers
== NULL
)
2167 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2170 CtrlHandlers
[NrCtrlHandlers
- 1] = HandlerRoutine
;
2176 RemoveConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine
)
2180 if (HandlerRoutine
== NULL
)
2182 IgnoreCtrlEvents
= FALSE
;
2187 for (i
= 0; i
< NrCtrlHandlers
; i
++)
2189 if (CtrlHandlers
[i
] == HandlerRoutine
)
2191 CtrlHandlers
[i
] = CtrlHandlers
[NrCtrlHandlers
- 1];
2194 RtlReAllocateHeap(RtlGetProcessHeap(),
2196 (PVOID
)CtrlHandlers
,
2197 NrCtrlHandlers
* sizeof(PHANDLER_ROUTINE
));
2205 WINBASEAPI BOOL WINAPI
2206 SetConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine
,
2211 RtlEnterCriticalSection(&DllLock
);
2214 Ret
= AddConsoleCtrlHandler(HandlerRoutine
);
2218 Ret
= RemoveConsoleCtrlHandler(HandlerRoutine
);
2220 RtlLeaveCriticalSection(&DllLock
);
2225 /*--------------------------------------------------------------
2226 * GenerateConsoleCtrlEvent
2228 WINBASEAPI BOOL WINAPI
2229 GenerateConsoleCtrlEvent(
2231 DWORD dwProcessGroupId
2239 /*--------------------------------------------------------------
2247 LPWSTR lpConsoleTitle
,
2251 CSRSS_API_REQUEST Request
;
2252 PCSRSS_API_REPLY Reply
;
2256 hConsole
= CreateFileW(L
"CONIN$", GENERIC_READ
, 0, NULL
, OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
2257 if (hConsole
== INVALID_HANDLE_VALUE
)
2262 Reply
= RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(CSRSS_API_REPLY
) + CSRSS_MAX_TITLE_LENGTH
* sizeof(WCHAR
));
2265 CloseHandle(hConsole
);
2266 SetLastError(ERROR_OUTOFMEMORY
);
2270 Request
.Type
= CSRSS_GET_TITLE
;
2271 Request
.Data
.GetTitleRequest
.ConsoleHandle
= hConsole
;
2273 Status
= CsrClientCallServer(&Request
, Reply
, sizeof(CSRSS_API_REQUEST
), sizeof(CSRSS_API_REPLY
) + CSRSS_MAX_TITLE_LENGTH
* sizeof(WCHAR
));
2274 CloseHandle(hConsole
);
2275 if(!NT_SUCCESS(Status
) || !(NT_SUCCESS(Status
= Reply
->Status
)))
2277 SetLastErrorByStatus(Status
);
2278 RtlFreeHeap(GetProcessHeap(), 0, Reply
);
2282 if(nSize
* sizeof(WCHAR
) < Reply
->Data
.GetTitleReply
.Length
)
2284 wcsncpy(lpConsoleTitle
, Reply
->Data
.GetTitleReply
.Title
, nSize
- 1);
2285 lpConsoleTitle
[nSize
--] = L
'\0';
2289 nSize
= Reply
->Data
.GetTitleReply
.Length
/ sizeof (WCHAR
);
2290 wcscpy(lpConsoleTitle
, Reply
->Data
.GetTitleReply
.Title
);
2291 lpConsoleTitle
[nSize
] = L
'\0';
2294 RtlFreeHeap(GetProcessHeap(), 0, Reply
);
2299 /*--------------------------------------------------------------
2308 LPSTR lpConsoleTitle
,
2312 wchar_t WideTitle
[CSRSS_MAX_TITLE_LENGTH
];
2313 DWORD nWideTitle
= sizeof WideTitle
;
2316 if (!lpConsoleTitle
|| !nSize
) return 0;
2317 nWideTitle
= GetConsoleTitleW( (LPWSTR
) WideTitle
, nWideTitle
);
2318 if (!nWideTitle
) return 0;
2320 if ( (nWritten
= WideCharToMultiByte(
2321 CP_ACP
, // ANSI code page
2322 0, // performance and mapping flags
2323 (LPWSTR
) WideTitle
, // address of wide-character string
2324 nWideTitle
, // number of characters in string
2325 lpConsoleTitle
, // address of buffer for new string
2326 nSize
, // size of buffer
2331 lpConsoleTitle
[nWritten
] = '\0';
2339 /*--------------------------------------------------------------
2346 LPCWSTR lpConsoleTitle
2349 PCSRSS_API_REQUEST Request
;
2350 CSRSS_API_REPLY Reply
;
2355 hConsole
= CreateFileW(L
"CONIN$", GENERIC_WRITE
, 0, NULL
, OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
2356 if (hConsole
== INVALID_HANDLE_VALUE
)
2361 Request
= RtlAllocateHeap(GetProcessHeap(),
2363 sizeof(CSRSS_API_REQUEST
) + CSRSS_MAX_SET_TITLE_REQUEST
);
2364 if (Request
== NULL
)
2366 CloseHandle(hConsole
);
2367 SetLastError(ERROR_OUTOFMEMORY
);
2371 Request
->Type
= CSRSS_SET_TITLE
;
2372 Request
->Data
.SetTitleRequest
.Console
= hConsole
;
2374 for( c
= 0; lpConsoleTitle
[c
] && c
< CSRSS_MAX_TITLE_LENGTH
; c
++ )
2375 Request
->Data
.SetTitleRequest
.Title
[c
] = lpConsoleTitle
[c
];
2377 Request
->Data
.SetTitleRequest
.Title
[c
] = 0;
2378 Request
->Data
.SetTitleRequest
.Length
= c
;
2379 Status
= CsrClientCallServer(Request
,
2381 sizeof(CSRSS_API_REQUEST
) +
2383 sizeof(CSRSS_API_REPLY
));
2384 CloseHandle(hConsole
);
2385 if (!NT_SUCCESS(Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2387 RtlFreeHeap( GetProcessHeap(), 0, Request
);
2388 SetLastErrorByStatus (Status
);
2391 RtlFreeHeap( GetProcessHeap(), 0, Request
);
2396 /*--------------------------------------------------------------
2405 LPCSTR lpConsoleTitle
2408 PCSRSS_API_REQUEST Request
;
2409 CSRSS_API_REPLY Reply
;
2414 hConsole
= CreateFileW(L
"CONIN$", GENERIC_WRITE
, 0, NULL
, OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
2415 if (hConsole
== INVALID_HANDLE_VALUE
)
2420 Request
= RtlAllocateHeap(GetProcessHeap(),
2422 sizeof(CSRSS_API_REQUEST
) + CSRSS_MAX_SET_TITLE_REQUEST
);
2423 if (Request
== NULL
)
2425 CloseHandle(hConsole
);
2426 SetLastError(ERROR_OUTOFMEMORY
);
2430 Request
->Type
= CSRSS_SET_TITLE
;
2431 Request
->Data
.SetTitleRequest
.Console
= hConsole
;
2433 for( c
= 0; lpConsoleTitle
[c
] && c
< CSRSS_MAX_TITLE_LENGTH
; c
++ )
2434 Request
->Data
.SetTitleRequest
.Title
[c
] = lpConsoleTitle
[c
];
2436 Request
->Data
.SetTitleRequest
.Title
[c
] = 0;
2437 Request
->Data
.SetTitleRequest
.Length
= c
;
2438 Status
= CsrClientCallServer(Request
,
2440 sizeof(CSRSS_API_REQUEST
) +
2442 sizeof(CSRSS_API_REPLY
));
2443 CloseHandle(hConsole
);
2444 if (!NT_SUCCESS(Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2446 RtlFreeHeap( GetProcessHeap(), 0, Request
);
2447 SetLastErrorByStatus (Status
);
2450 RtlFreeHeap( GetProcessHeap(), 0, Request
);
2455 /*--------------------------------------------------------------
2462 HANDLE hConsoleInput
,
2464 DWORD nNumberOfCharsToRead
,
2465 LPDWORD lpNumberOfCharsRead
,
2474 /*--------------------------------------------------------------
2481 HANDLE hConsoleOutput
,
2482 CONST VOID
*lpBuffer
,
2483 DWORD nNumberOfCharsToWrite
,
2484 LPDWORD lpNumberOfCharsWritten
,
2489 PCSRSS_API_REQUEST Request
;
2490 CSRSS_API_REPLY Reply
;
2493 Request
= RtlAllocateHeap(GetProcessHeap(),
2495 sizeof(CSRSS_API_REQUEST
) + nNumberOfCharsToWrite
* sizeof(WCHAR
));
2496 if (Request
== NULL
)
2498 SetLastError(ERROR_OUTOFMEMORY
);
2502 Request
->Type
= CSRSS_WRITE_CONSOLE
;
2503 Request
->Data
.WriteConsoleRequest
.ConsoleHandle
= hConsoleOutput
;
2504 Request
->Data
.WriteConsoleRequest
.NrCharactersToWrite
=
2505 nNumberOfCharsToWrite
;
2506 // DbgPrint("nNumberOfCharsToWrite %d\n", nNumberOfCharsToWrite);
2507 // DbgPrint("Buffer %s\n", Request->Data.WriteConsoleRequest.Buffer);
2508 memcpy(Request
->Data
.WriteConsoleRequest
.Buffer
,
2510 nNumberOfCharsToWrite
* sizeof(WCHAR
));
2512 Status
= CsrClientCallServer(Request
,
2514 sizeof(CSRSS_API_REQUEST
) + nNumberOfCharsToWrite
,
2515 sizeof(CSRSS_API_REPLY
));
2517 RtlFreeHeap(GetProcessHeap(),
2521 if (!NT_SUCCESS(Status
))
2526 if (lpNumberOfCharsWritten
!= NULL
)
2528 *lpNumberOfCharsWritten
=
2529 Reply
.Data
.WriteConsoleReply
.NrCharactersWritten
;
2538 /*--------------------------------------------------------------
2539 * CreateConsoleScreenBuffer
2544 CreateConsoleScreenBuffer(
2545 DWORD dwDesiredAccess
,
2547 CONST SECURITY_ATTRIBUTES
*lpSecurityAttributes
,
2549 LPVOID lpScreenBufferData
2552 // FIXME: don't ignore access, share mode, and security
2553 CSRSS_API_REQUEST Request
;
2554 CSRSS_API_REPLY Reply
;
2557 Request
.Type
= CSRSS_CREATE_SCREEN_BUFFER
;
2558 Status
= CsrClientCallServer( &Request
, &Reply
, sizeof( CSRSS_API_REQUEST
), sizeof( CSRSS_API_REPLY
) );
2559 if( !NT_SUCCESS( Status
) || !NT_SUCCESS( Status
= Reply
.Status
) )
2561 SetLastErrorByStatus ( Status
);
2564 return Reply
.Data
.CreateScreenBufferReply
.OutputHandle
;
2568 /*--------------------------------------------------------------
2574 GetConsoleCP( VOID
)
2577 return CP_OEMCP
; /* FIXME */
2581 /*--------------------------------------------------------------
2596 /*--------------------------------------------------------------
2597 * GetConsoleOutputCP
2602 GetConsoleOutputCP( VOID
)
2605 return 0; /* FIXME */
2609 /*--------------------------------------------------------------
2610 * SetConsoleOutputCP
2624 /*--------------------------------------------------------------
2625 * GetConsoleProcessList
2628 GetConsoleProcessList(LPDWORD lpdwProcessList
,
2629 DWORD dwProcessCount
)
2631 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2637 /*--------------------------------------------------------------
2638 * GetConsoleSelectionInfo
2641 GetConsoleSelectionInfo(PCONSOLE_SELECTION_INFO lpConsoleSelectionInfo
)
2643 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
2649 /*--------------------------------------------------------------
2653 AttachConsole(DWORD dwProcessId
)
2655 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);