3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS system libraries
5 * FILE: dll/win32/kernel32/misc/console.c
6 * PURPOSE: Win32 server console functions
7 * PROGRAMMER: James Tabor
8 * <jimtabor@adsl-64-217-116-74.dsl.hstntx.swbell.net>
11 * 19990204 EA SetConsoleTitleA
15 /* INCLUDES ******************************************************************/
22 extern RTL_CRITICAL_SECTION ConsoleLock
;
23 extern BOOL ConsoleInitialized
;
24 extern BOOL WINAPI
IsDebuggerPresent(VOID
);
26 /* GLOBALS *******************************************************************/
28 PHANDLER_ROUTINE InitialHandler
[1];
29 PHANDLER_ROUTINE
* CtrlHandlers
;
31 ULONG NrAllocatedHandlers
;
33 #define INPUTEXENAME_BUFLEN 256
34 static WCHAR InputExeName
[INPUTEXENAME_BUFLEN
] = L
"";
36 /* Default Console Control Handler *******************************************/
40 DefaultConsoleCtrlHandler(DWORD Event
)
42 DPRINT("Default handler called: %lx\n", Event
);
46 DPRINT("Ctrl-C Event\n");
49 case CTRL_BREAK_EVENT
:
50 DPRINT("Ctrl-Break Event\n");
53 case CTRL_SHUTDOWN_EVENT
:
54 DPRINT("Ctrl Shutdown Event\n");
57 case CTRL_CLOSE_EVENT
:
58 DPRINT("Ctrl Close Event\n");
61 case CTRL_LOGOFF_EVENT
:
62 DPRINT("Ctrl Logoff Event\n");
66 ExitProcess(CONTROL_C_EXIT
);
73 ConsoleControlDispatcher(DWORD CodeAndFlag
)
76 DWORD nCode
= CodeAndFlag
& MAXLONG
;
78 EXCEPTION_RECORD erException
;
80 DPRINT("Console Dispatcher Active: %lx %lx\n", CodeAndFlag
, nCode
);
81 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST
);
86 case CTRL_BREAK_EVENT
:
88 if (IsDebuggerPresent())
90 erException
.ExceptionCode
= (nCode
== CTRL_C_EVENT
?
91 DBG_CONTROL_C
: DBG_CONTROL_BREAK
);
92 erException
.ExceptionFlags
= 0;
93 erException
.ExceptionRecord
= NULL
;
94 erException
.ExceptionAddress
= DefaultConsoleCtrlHandler
;
95 erException
.NumberParameters
= 0;
99 RtlRaiseException(&erException
);
101 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER
)
103 RtlEnterCriticalSection(&ConsoleLock
);
105 if ((nCode
!= CTRL_C_EVENT
) ||
106 (NtCurrentPeb()->ProcessParameters
->ConsoleFlags
!= 1))
108 for (i
= NrCtrlHandlers
; i
> 0; i
--)
110 if (CtrlHandlers
[i
- 1](nCode
)) break;
114 RtlLeaveCriticalSection(&ConsoleLock
);
124 case CTRL_CLOSE_EVENT
:
125 case CTRL_LOGOFF_EVENT
:
126 case CTRL_SHUTDOWN_EVENT
:
136 ExitProcess(CONTROL_C_EXIT
);
145 ASSERT(ConsoleInitialized
);
147 RtlEnterCriticalSection(&ConsoleLock
);
149 if ((nCode
!= CTRL_C_EVENT
) || (NtCurrentPeb()->ProcessParameters
->ConsoleFlags
!= 1))
151 for (i
= NrCtrlHandlers
; i
> 0; i
--)
154 (CodeAndFlag
& MINLONG
) &&
155 ((nCode
== CTRL_LOGOFF_EVENT
) || (nCode
== CTRL_SHUTDOWN_EVENT
)))
157 DPRINT("Skipping system/service apps\n");
161 if (CtrlHandlers
[i
- 1](nCode
))
165 case CTRL_CLOSE_EVENT
:
166 case CTRL_LOGOFF_EVENT
:
167 case CTRL_SHUTDOWN_EVENT
:
169 nExitCode
= CodeAndFlag
;
177 RtlLeaveCriticalSection(&ConsoleLock
);
178 ExitThread(nExitCode
);
181 /* Get the size needed to copy a string to a capture buffer, including alignment */
183 IntStringSize(LPCVOID String
,
186 ULONG Size
= (Unicode
? wcslen(String
) : strlen(String
)) * sizeof(WCHAR
);
187 return (Size
+ 3) & -4;
190 /* Copy a string to a capture buffer */
192 IntCaptureMessageString(PCSR_CAPTURE_BUFFER CaptureBuffer
,
195 PUNICODE_STRING RequestString
)
200 Size
= wcslen(String
) * sizeof(WCHAR
);
201 CsrCaptureMessageBuffer(CaptureBuffer
, (PVOID
)String
, Size
, (PVOID
*)&RequestString
->Buffer
);
205 Size
= strlen(String
);
206 CsrAllocateMessagePointer(CaptureBuffer
, Size
* sizeof(WCHAR
), (PVOID
*)&RequestString
->Buffer
);
207 Size
= MultiByteToWideChar(CP_ACP
, 0, String
, Size
, RequestString
->Buffer
, Size
* sizeof(WCHAR
))
210 RequestString
->Length
= RequestString
->MaximumLength
= Size
;
213 /* FUNCTIONS *****************************************************************/
220 AddConsoleAliasA(LPCSTR lpSource
,
224 LPWSTR lpSourceW
= NULL
;
225 LPWSTR lpTargetW
= NULL
;
226 LPWSTR lpExeNameW
= NULL
;
230 BasepAnsiStringToHeapUnicodeString(lpSource
, (LPWSTR
*) &lpSourceW
);
232 BasepAnsiStringToHeapUnicodeString(lpTarget
, (LPWSTR
*) &lpTargetW
);
234 BasepAnsiStringToHeapUnicodeString(lpExeName
, (LPWSTR
*) &lpExeNameW
);
236 bRetVal
= AddConsoleAliasW(lpSourceW
, lpTargetW
, lpExeNameW
);
240 RtlFreeHeap(GetProcessHeap(), 0, (LPWSTR
*) lpSourceW
);
242 RtlFreeHeap(GetProcessHeap(), 0, (LPWSTR
*) lpTargetW
);
244 RtlFreeHeap(GetProcessHeap(), 0, (LPWSTR
*) lpExeNameW
);
255 AddConsoleAliasW(LPCWSTR lpSource
,
259 PCSR_API_MESSAGE Request
;
263 ULONG TargetLength
= 0;
269 DPRINT("AddConsoleAliasW enterd with lpSource %S lpTarget %S lpExeName %S\n", lpSource
, lpTarget
, lpExeName
);
271 ExeLength
= wcslen(lpExeName
) + 1;
272 SourceLength
= wcslen(lpSource
)+ 1;
274 TargetLength
= wcslen(lpTarget
) + 1;
276 Size
= (ExeLength
+ SourceLength
+ TargetLength
) * sizeof(WCHAR
);
277 RequestLength
= sizeof(CSR_API_MESSAGE
) + Size
;
279 Request
= RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY
, RequestLength
);
280 Ptr
= (WCHAR
*)(((ULONG_PTR
)Request
) + sizeof(CSR_API_MESSAGE
));
282 wcscpy(Ptr
, lpSource
);
283 Request
->Data
.AddConsoleAlias
.SourceLength
= SourceLength
;
284 Ptr
= (WCHAR
*)(((ULONG_PTR
)Request
) + sizeof(CSR_API_MESSAGE
) + SourceLength
* sizeof(WCHAR
));
286 wcscpy(Ptr
, lpExeName
);
287 Request
->Data
.AddConsoleAlias
.ExeLength
= ExeLength
;
288 Ptr
= (WCHAR
*)(((ULONG_PTR
)Request
) + sizeof(CSR_API_MESSAGE
) + (ExeLength
+ SourceLength
)* sizeof(WCHAR
));
290 if (lpTarget
) /* target can be optional */
291 wcscpy(Ptr
, lpTarget
);
293 Request
->Data
.AddConsoleAlias
.TargetLength
= TargetLength
;
295 CsrRequest
= MAKE_CSR_API(ADD_CONSOLE_ALIAS
, CSR_CONSOLE
);
296 Status
= CsrClientCallServer(Request
,
301 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
->Status
))
303 SetLastErrorByStatus(Status
);
304 RtlFreeHeap(GetProcessHeap(), 0, Request
);
308 RtlFreeHeap(GetProcessHeap(), 0, Request
);
314 * @unimplemented (Undocumented)
318 ConsoleMenuControl(HANDLE hConsole
,
322 DPRINT1("ConsoleMenuControl(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", hConsole
, Unknown1
, Unknown2
);
323 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
333 DuplicateConsoleHandle(HANDLE hConsole
,
334 DWORD dwDesiredAccess
,
338 CSR_API_MESSAGE Request
;
342 if (dwOptions
& ~(DUPLICATE_CLOSE_SOURCE
| DUPLICATE_SAME_ACCESS
)
343 || (!(dwOptions
& DUPLICATE_SAME_ACCESS
)
344 && dwDesiredAccess
& ~(GENERIC_READ
| GENERIC_WRITE
)))
346 SetLastError (ERROR_INVALID_PARAMETER
);
347 return INVALID_HANDLE_VALUE
;
350 CsrRequest
= MAKE_CSR_API(DUPLICATE_HANDLE
, CSR_NATIVE
);
351 Request
.Data
.DuplicateHandleRequest
.Handle
= hConsole
;
352 Request
.Data
.DuplicateHandleRequest
.Access
= dwDesiredAccess
;
353 Request
.Data
.DuplicateHandleRequest
.Inheritable
= bInheritHandle
;
354 Request
.Data
.DuplicateHandleRequest
.Options
= dwOptions
;
356 Status
= CsrClientCallServer(&Request
,
359 sizeof(CSR_API_MESSAGE
));
360 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
=Request
.Status
))
362 SetLastErrorByStatus(Status
);
363 return INVALID_HANDLE_VALUE
;
366 return Request
.Data
.DuplicateHandleRequest
.Handle
;
371 IntExpungeConsoleCommandHistory(LPCVOID lpExeName
, BOOL bUnicode
)
373 CSR_API_MESSAGE Request
;
374 PCSR_CAPTURE_BUFFER CaptureBuffer
;
375 ULONG CsrRequest
= MAKE_CSR_API(EXPUNGE_COMMAND_HISTORY
, CSR_CONSOLE
);
378 if (lpExeName
== NULL
|| !(bUnicode
? *(PWCHAR
)lpExeName
: *(PCHAR
)lpExeName
))
380 SetLastError(ERROR_INVALID_PARAMETER
);
384 CaptureBuffer
= CsrAllocateCaptureBuffer(1, IntStringSize(lpExeName
, bUnicode
));
387 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
390 IntCaptureMessageString(CaptureBuffer
, lpExeName
, bUnicode
,
391 &Request
.Data
.ExpungeCommandHistory
.ExeName
);
392 Status
= CsrClientCallServer(&Request
, CaptureBuffer
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
393 CsrFreeCaptureBuffer(CaptureBuffer
);
394 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
396 SetLastErrorByStatus(Status
);
403 * @implemented (Undocumented)
407 ExpungeConsoleCommandHistoryW(LPCWSTR lpExeName
)
409 return IntExpungeConsoleCommandHistory(lpExeName
, TRUE
);
413 * @implemented (Undocumented)
417 ExpungeConsoleCommandHistoryA(LPCSTR lpExeName
)
419 return IntExpungeConsoleCommandHistory(lpExeName
, FALSE
);
428 GetConsoleAliasW(LPWSTR lpSource
,
429 LPWSTR lpTargetBuffer
,
430 DWORD TargetBufferLength
,
433 PCSR_API_MESSAGE Request
;
434 PCSR_CAPTURE_BUFFER CaptureBuffer
;
443 DPRINT("GetConsoleAliasW entered lpSource %S lpExeName %S\n", lpSource
, lpExeName
);
445 if (lpTargetBuffer
== NULL
)
447 SetLastError(ERROR_INVALID_PARAMETER
);
451 CsrRequest
= MAKE_CSR_API(GET_CONSOLE_ALIAS
, CSR_CONSOLE
);
453 ExeLength
= wcslen(lpExeName
) + 1;
454 SourceLength
= wcslen(lpSource
) + 1;
456 Size
= (ExeLength
+ SourceLength
) * sizeof(WCHAR
);
458 RequestLength
= Size
+ sizeof(CSR_API_MESSAGE
);
459 Request
= RtlAllocateHeap(GetProcessHeap(), 0, RequestLength
);
462 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
466 CaptureBuffer
= CsrAllocateCaptureBuffer(1, TargetBufferLength
);
469 RtlFreeHeap(GetProcessHeap(), 0, Request
);
470 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
474 Request
->Data
.GetConsoleAlias
.TargetBuffer
= NULL
;
476 CsrCaptureMessageBuffer(CaptureBuffer
,
479 (PVOID
*)&Request
->Data
.GetConsoleAlias
.TargetBuffer
);
481 Request
->Data
.GetConsoleAlias
.TargetBufferLength
= TargetBufferLength
;
483 Ptr
= (LPWSTR
)((ULONG_PTR
)Request
+ sizeof(CSR_API_MESSAGE
));
484 wcscpy(Ptr
, lpSource
);
486 wcscpy(Ptr
, lpExeName
);
488 Request
->Data
.GetConsoleAlias
.ExeLength
= ExeLength
;
489 Request
->Data
.GetConsoleAlias
.SourceLength
= SourceLength
;
491 Status
= CsrClientCallServer(Request
,
494 sizeof(CSR_API_MESSAGE
) + Size
);
496 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
->Status
))
498 RtlFreeHeap(GetProcessHeap(), 0, Request
);
499 CsrFreeCaptureBuffer(CaptureBuffer
);
500 SetLastErrorByStatus(Status
);
504 wcscpy(lpTargetBuffer
, Request
->Data
.GetConsoleAlias
.TargetBuffer
);
505 RtlFreeHeap(GetProcessHeap(), 0, Request
);
506 CsrFreeCaptureBuffer(CaptureBuffer
);
508 return Request
->Data
.GetConsoleAlias
.BytesWritten
;
517 GetConsoleAliasA(LPSTR lpSource
,
518 LPSTR lpTargetBuffer
,
519 DWORD TargetBufferLength
,
524 LPWSTR lpwTargetBuffer
;
529 DPRINT("GetConsoleAliasA entered\n");
531 if (lpTargetBuffer
== NULL
)
533 SetLastError(ERROR_INVALID_PARAMETER
);
537 dwSourceSize
= (strlen(lpSource
)+1) * sizeof(WCHAR
);
538 lpwSource
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, dwSourceSize
);
539 if (lpwSource
== NULL
)
541 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
544 MultiByteToWideChar(CP_ACP
, 0, lpSource
, -1, lpwSource
, dwSourceSize
);
546 dwExeNameSize
= (strlen(lpExeName
)+1) * sizeof(WCHAR
);
547 lpwExeName
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, dwExeNameSize
);
548 if (lpwExeName
== NULL
)
550 HeapFree(GetProcessHeap(), 0, lpwSource
);
551 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
554 MultiByteToWideChar(CP_ACP
, 0, lpExeName
, -1, lpwExeName
, dwExeNameSize
);
556 lpwTargetBuffer
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, TargetBufferLength
* sizeof(WCHAR
));
557 if (lpwTargetBuffer
== NULL
)
559 HeapFree(GetProcessHeap(), 0, lpwSource
);
560 HeapFree(GetProcessHeap(), 0, lpwExeName
);
561 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
565 dwResult
= GetConsoleAliasW(lpwSource
, lpwTargetBuffer
, TargetBufferLength
* sizeof(WCHAR
), lpwExeName
);
567 HeapFree(GetProcessHeap(), 0, lpwSource
);
568 HeapFree(GetProcessHeap(), 0, lpwExeName
);
571 dwResult
= WideCharToMultiByte(CP_ACP
, 0, lpwTargetBuffer
, dwResult
/ sizeof(WCHAR
), lpTargetBuffer
, TargetBufferLength
, NULL
, NULL
);
573 HeapFree(GetProcessHeap(), 0, lpwTargetBuffer
);
584 GetConsoleAliasExesW(LPWSTR lpExeNameBuffer
,
585 DWORD ExeNameBufferLength
)
587 CSR_API_MESSAGE Request
;
588 PCSR_CAPTURE_BUFFER CaptureBuffer
;
592 DPRINT("GetConsoleAliasExesW entered\n");
594 CaptureBuffer
= CsrAllocateCaptureBuffer(1, ExeNameBufferLength
);
597 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
601 CsrRequest
= MAKE_CSR_API(GET_CONSOLE_ALIASES_EXES
, CSR_CONSOLE
);
602 CsrAllocateMessagePointer(CaptureBuffer
,
604 (PVOID
*)&Request
.Data
.GetConsoleAliasesExes
.ExeNames
);
605 Request
.Data
.GetConsoleAliasesExes
.Length
= ExeNameBufferLength
;
607 Status
= CsrClientCallServer(&Request
,
610 sizeof(CSR_API_MESSAGE
));
612 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
614 SetLastErrorByStatus(Status
);
615 CsrFreeCaptureBuffer(CaptureBuffer
);
619 memcpy(lpExeNameBuffer
,
620 Request
.Data
.GetConsoleAliasesExes
.ExeNames
,
621 Request
.Data
.GetConsoleAliasesExes
.BytesWritten
);
623 CsrFreeCaptureBuffer(CaptureBuffer
);
624 return Request
.Data
.GetConsoleAliasesExes
.BytesWritten
;
633 GetConsoleAliasExesA(LPSTR lpExeNameBuffer
,
634 DWORD ExeNameBufferLength
)
636 LPWSTR lpwExeNameBuffer
;
639 DPRINT("GetConsoleAliasExesA entered\n");
641 lpwExeNameBuffer
= HeapAlloc(GetProcessHeap(), 0, ExeNameBufferLength
* sizeof(WCHAR
));
643 dwResult
= GetConsoleAliasExesW(lpwExeNameBuffer
, ExeNameBufferLength
* sizeof(WCHAR
));
646 dwResult
= WideCharToMultiByte(CP_ACP
, 0, lpwExeNameBuffer
, dwResult
/ sizeof(WCHAR
), lpExeNameBuffer
, ExeNameBufferLength
, NULL
, NULL
);
648 HeapFree(GetProcessHeap(), 0, lpwExeNameBuffer
);
657 GetConsoleAliasExesLengthW(VOID
)
659 CSR_API_MESSAGE Request
;
663 DPRINT("GetConsoleAliasExesLengthW entered\n");
665 CsrRequest
= MAKE_CSR_API(GET_CONSOLE_ALIASES_EXES_LENGTH
, CSR_CONSOLE
);
666 Request
.Data
.GetConsoleAliasesExesLength
.Length
= 0;
669 Status
= CsrClientCallServer(&Request
,
672 sizeof(CSR_API_MESSAGE
));
674 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
676 SetLastErrorByStatus(Status
);
680 return Request
.Data
.GetConsoleAliasesExesLength
.Length
;
688 GetConsoleAliasExesLengthA(VOID
)
692 DPRINT("GetConsoleAliasExesLengthA entered\n");
694 dwLength
= GetConsoleAliasExesLengthW();
697 dwLength
/= sizeof(WCHAR
);
708 GetConsoleAliasesW(LPWSTR AliasBuffer
,
709 DWORD AliasBufferLength
,
712 CSR_API_MESSAGE Request
;
717 DPRINT("GetConsoleAliasesW entered\n");
719 dwLength
= GetConsoleAliasesLengthW(ExeName
);
720 if (!dwLength
|| dwLength
> AliasBufferLength
)
723 CsrRequest
= MAKE_CSR_API(GET_ALL_CONSOLE_ALIASES
, CSR_CONSOLE
);
724 Request
.Data
.GetAllConsoleAlias
.AliasBuffer
= AliasBuffer
;
725 Request
.Data
.GetAllConsoleAlias
.AliasBufferLength
= AliasBufferLength
;
726 Request
.Data
.GetAllConsoleAlias
.lpExeName
= ExeName
;
728 Status
= CsrClientCallServer(&Request
,
731 sizeof(CSR_API_MESSAGE
));
733 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
735 SetLastErrorByStatus(Status
);
739 return Request
.Data
.GetAllConsoleAlias
.BytesWritten
/ sizeof(WCHAR
);
748 GetConsoleAliasesA(LPSTR AliasBuffer
,
749 DWORD AliasBufferLength
,
753 LPWSTR lpwExeName
= NULL
;
754 LPWSTR lpwAliasBuffer
;
756 DPRINT("GetConsoleAliasesA entered\n");
759 BasepAnsiStringToHeapUnicodeString(ExeName
, (LPWSTR
*) &lpwExeName
);
761 lpwAliasBuffer
= HeapAlloc(GetProcessHeap(), 0, AliasBufferLength
* sizeof(WCHAR
));
763 dwRetVal
= GetConsoleAliasesW(lpwAliasBuffer
, AliasBufferLength
, lpwExeName
);
766 RtlFreeHeap(GetProcessHeap(), 0, (LPWSTR
*) lpwExeName
);
769 dwRetVal
= WideCharToMultiByte(CP_ACP
, 0, lpwAliasBuffer
, dwRetVal
, AliasBuffer
, AliasBufferLength
, NULL
, NULL
);
771 HeapFree(GetProcessHeap(), 0, lpwAliasBuffer
);
781 GetConsoleAliasesLengthW(LPWSTR lpExeName
)
783 CSR_API_MESSAGE Request
;
787 DPRINT("GetConsoleAliasesLengthW entered\n");
789 CsrRequest
= MAKE_CSR_API(GET_ALL_CONSOLE_ALIASES_LENGTH
, CSR_CONSOLE
);
790 Request
.Data
.GetAllConsoleAliasesLength
.lpExeName
= lpExeName
;
791 Request
.Data
.GetAllConsoleAliasesLength
.Length
= 0;
793 Status
= CsrClientCallServer(&Request
,
796 sizeof(CSR_API_MESSAGE
));
798 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
800 SetLastErrorByStatus(Status
);
804 return Request
.Data
.GetAllConsoleAliasesLength
.Length
;
813 GetConsoleAliasesLengthA(LPSTR lpExeName
)
816 LPWSTR lpExeNameW
= NULL
;
819 BasepAnsiStringToHeapUnicodeString(lpExeName
, (LPWSTR
*) &lpExeNameW
);
821 dwRetVal
= GetConsoleAliasesLengthW(lpExeNameW
);
823 dwRetVal
/= sizeof(WCHAR
);
827 RtlFreeHeap(GetProcessHeap(), 0, (LPWSTR
*) lpExeNameW
);
834 IntGetConsoleCommandHistory(LPVOID lpHistory
, DWORD cbHistory
, LPCVOID lpExeName
, BOOL bUnicode
)
836 CSR_API_MESSAGE Request
;
837 PCSR_CAPTURE_BUFFER CaptureBuffer
;
838 ULONG CsrRequest
= MAKE_CSR_API(GET_COMMAND_HISTORY
, CSR_CONSOLE
);
840 DWORD HistoryLength
= cbHistory
* (bUnicode
? 1 : sizeof(WCHAR
));
842 if (lpExeName
== NULL
|| !(bUnicode
? *(PWCHAR
)lpExeName
: *(PCHAR
)lpExeName
))
844 SetLastError(ERROR_INVALID_PARAMETER
);
848 CaptureBuffer
= CsrAllocateCaptureBuffer(2, IntStringSize(lpExeName
, bUnicode
) +
852 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
855 IntCaptureMessageString(CaptureBuffer
, lpExeName
, bUnicode
,
856 &Request
.Data
.GetCommandHistory
.ExeName
);
857 Request
.Data
.GetCommandHistory
.Length
= HistoryLength
;
858 CsrAllocateMessagePointer(CaptureBuffer
, HistoryLength
,
859 (PVOID
*)&Request
.Data
.GetCommandHistory
.History
);
861 Status
= CsrClientCallServer(&Request
, CaptureBuffer
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
862 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
864 CsrFreeCaptureBuffer(CaptureBuffer
);
865 SetLastErrorByStatus(Status
);
872 Request
.Data
.GetCommandHistory
.History
,
873 Request
.Data
.GetCommandHistory
.Length
);
877 WideCharToMultiByte(CP_ACP
, 0,
878 Request
.Data
.GetCommandHistory
.History
,
879 Request
.Data
.GetCommandHistory
.Length
/ sizeof(WCHAR
),
884 CsrFreeCaptureBuffer(CaptureBuffer
);
885 return Request
.Data
.GetCommandHistory
.Length
;
889 * @implemented (Undocumented)
893 GetConsoleCommandHistoryW(LPWSTR lpHistory
,
897 return IntGetConsoleCommandHistory(lpHistory
, cbHistory
, lpExeName
, TRUE
);
901 * @implemented (Undocumented)
905 GetConsoleCommandHistoryA(LPSTR lpHistory
,
909 return IntGetConsoleCommandHistory(lpHistory
, cbHistory
, lpExeName
, FALSE
);
914 IntGetConsoleCommandHistoryLength(LPCVOID lpExeName
, BOOL bUnicode
)
916 CSR_API_MESSAGE Request
;
917 PCSR_CAPTURE_BUFFER CaptureBuffer
;
918 ULONG CsrRequest
= MAKE_CSR_API(GET_COMMAND_HISTORY_LENGTH
, CSR_CONSOLE
);
921 if (lpExeName
== NULL
|| !(bUnicode
? *(PWCHAR
)lpExeName
: *(PCHAR
)lpExeName
))
923 SetLastError(ERROR_INVALID_PARAMETER
);
927 CaptureBuffer
= CsrAllocateCaptureBuffer(1, IntStringSize(lpExeName
, bUnicode
));
930 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
933 IntCaptureMessageString(CaptureBuffer
, lpExeName
, bUnicode
,
934 &Request
.Data
.GetCommandHistoryLength
.ExeName
);
935 Status
= CsrClientCallServer(&Request
, CaptureBuffer
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
936 CsrFreeCaptureBuffer(CaptureBuffer
);
937 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
939 SetLastErrorByStatus(Status
);
942 return Request
.Data
.GetCommandHistoryLength
.Length
;
946 * @implemented (Undocumented)
950 GetConsoleCommandHistoryLengthW(LPCWSTR lpExeName
)
952 return IntGetConsoleCommandHistoryLength(lpExeName
, TRUE
);
956 * @implemented (Undocumented)
960 GetConsoleCommandHistoryLengthA(LPCSTR lpExeName
)
962 return IntGetConsoleCommandHistoryLength(lpExeName
, FALSE
) / sizeof(WCHAR
);
971 GetConsoleDisplayMode(LPDWORD lpdwMode
)
973 * FUNCTION: Get the console display mode
975 * lpdwMode - Address of variable that receives the current value
977 * STATUS: Undocumented
980 DPRINT1("GetConsoleDisplayMode(0x%x) UNIMPLEMENTED!\n", lpdwMode
);
981 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
987 * @unimplemented (Undocumented)
991 GetConsoleFontInfo(DWORD Unknown0
,
996 DPRINT1("GetConsoleFontInfo(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
, Unknown3
);
997 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1007 GetConsoleFontSize(HANDLE hConsoleOutput
,
1010 COORD Empty
= {0, 0};
1011 DPRINT1("GetConsoleFontSize(0x%x, 0x%x) UNIMPLEMENTED!\n", hConsoleOutput
, nFont
);
1012 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1018 * @implemented (Undocumented)
1022 GetConsoleHardwareState(HANDLE hConsole
,
1026 CSR_API_MESSAGE Request
;
1030 CsrRequest
= MAKE_CSR_API(SETGET_CONSOLE_HW_STATE
, CSR_CONSOLE
);
1031 Request
.Data
.ConsoleHardwareStateRequest
.ConsoleHandle
= hConsole
;
1032 Request
.Data
.ConsoleHardwareStateRequest
.SetGet
= CONSOLE_HARDWARE_STATE_GET
;
1034 Status
= CsrClientCallServer(&Request
,
1037 sizeof(CSR_API_MESSAGE
));
1038 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
1040 SetLastErrorByStatus(Status
);
1044 *State
= Request
.Data
.ConsoleHardwareStateRequest
.State
;
1050 * @implemented (Undocumented)
1054 GetConsoleInputWaitHandle(VOID
)
1056 CSR_API_MESSAGE Request
;
1060 CsrRequest
= MAKE_CSR_API(GET_INPUT_WAIT_HANDLE
, CSR_CONSOLE
);
1062 Status
= CsrClientCallServer(&Request
,
1065 sizeof(CSR_API_MESSAGE
));
1066 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
1068 SetLastErrorByStatus(Status
);
1072 return Request
.Data
.GetConsoleInputWaitHandle
.InputWaitHandle
;
1081 GetCurrentConsoleFont(HANDLE hConsoleOutput
,
1082 BOOL bMaximumWindow
,
1083 PCONSOLE_FONT_INFO lpConsoleCurrentFont
)
1085 DPRINT1("GetCurrentConsoleFont(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", hConsoleOutput
, bMaximumWindow
, lpConsoleCurrentFont
);
1086 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1092 * @unimplemented (Undocumented)
1096 GetNumberOfConsoleFonts(VOID
)
1098 DPRINT1("GetNumberOfConsoleFonts() UNIMPLEMENTED!\n");
1099 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1100 return 1; /* FIXME: call csrss.exe */
1105 * @unimplemented (Undocumented)
1109 InvalidateConsoleDIBits(DWORD Unknown0
,
1112 DPRINT1("InvalidateConsoleDIBits(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
);
1113 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1119 * @unimplemented (Undocumented)
1123 OpenConsoleW(LPCWSTR wsName
,
1124 DWORD dwDesiredAccess
,
1125 BOOL bInheritHandle
,
1128 CSR_API_MESSAGE Request
;
1130 NTSTATUS Status
= STATUS_SUCCESS
;
1132 if (wsName
&& 0 == _wcsicmp(wsName
, L
"CONIN$"))
1134 CsrRequest
= MAKE_CSR_API(GET_INPUT_HANDLE
, CSR_NATIVE
);
1136 else if (wsName
&& 0 == _wcsicmp(wsName
, L
"CONOUT$"))
1138 CsrRequest
= MAKE_CSR_API(GET_OUTPUT_HANDLE
, CSR_NATIVE
);
1142 SetLastError(ERROR_INVALID_PARAMETER
);
1143 return(INVALID_HANDLE_VALUE
);
1146 if (dwDesiredAccess
& ~(GENERIC_READ
|GENERIC_WRITE
))
1148 SetLastError(ERROR_INVALID_PARAMETER
);
1149 return(INVALID_HANDLE_VALUE
);
1152 if (dwShareMode
& ~(FILE_SHARE_READ
|FILE_SHARE_WRITE
))
1154 SetLastError(ERROR_INVALID_PARAMETER
);
1155 return(INVALID_HANDLE_VALUE
);
1158 /* Structures for GET_INPUT_HANDLE and GET_OUTPUT_HANDLE requests are identical */
1159 Request
.Data
.GetInputHandleRequest
.Access
= dwDesiredAccess
;
1160 Request
.Data
.GetInputHandleRequest
.Inheritable
= bInheritHandle
;
1161 Request
.Data
.GetInputHandleRequest
.ShareMode
= dwShareMode
;
1163 Status
= CsrClientCallServer(&Request
,
1166 sizeof(CSR_API_MESSAGE
));
1167 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
1169 SetLastErrorByStatus(Status
);
1170 return INVALID_HANDLE_VALUE
;
1173 return Request
.Data
.GetInputHandleRequest
.Handle
;
1178 * @unimplemented (Undocumented)
1182 SetConsoleCursor(DWORD Unknown0
,
1185 DPRINT1("SetConsoleCursor(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
);
1186 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1196 SetConsoleDisplayMode(HANDLE hOut
,
1200 * FUNCTION: Set the console display mode.
1202 * hOut - Standard output handle.
1203 * dwNewMode - New mode.
1204 * lpdwOldMode - Address of a variable that receives the old mode.
1207 DPRINT1("SetConsoleDisplayMode(0x%x, 0x%x, 0x%p) UNIMPLEMENTED!\n", hOut
, dwNewMode
, lpdwOldMode
);
1208 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1214 * @unimplemented (Undocumented)
1218 SetConsoleFont(DWORD Unknown0
,
1221 DPRINT1("SetConsoleFont(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
);
1222 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1228 * @implemented (Undocumented)
1232 SetConsoleHardwareState(HANDLE hConsole
,
1236 CSR_API_MESSAGE Request
;
1240 CsrRequest
= MAKE_CSR_API(SETGET_CONSOLE_HW_STATE
, CSR_CONSOLE
);
1241 Request
.Data
.ConsoleHardwareStateRequest
.ConsoleHandle
= hConsole
;
1242 Request
.Data
.ConsoleHardwareStateRequest
.SetGet
= CONSOLE_HARDWARE_STATE_SET
;
1243 Request
.Data
.ConsoleHardwareStateRequest
.State
= State
;
1245 Status
= CsrClientCallServer(&Request
,
1248 sizeof(CSR_API_MESSAGE
));
1249 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
1251 SetLastErrorByStatus(Status
);
1260 * @unimplemented (Undocumented)
1264 SetConsoleKeyShortcuts(DWORD Unknown0
,
1269 DPRINT1("SetConsoleKeyShortcuts(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
, Unknown3
);
1270 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1276 * @unimplemented (Undocumented)
1280 SetConsoleMaximumWindowSize(DWORD Unknown0
,
1283 DPRINT1("SetConsoleMaximumWindowSize(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
);
1284 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1290 * @unimplemented (Undocumented)
1294 SetConsoleMenuClose(DWORD Unknown0
)
1296 DPRINT1("SetConsoleMenuClose(0x%x) UNIMPLEMENTED!\n", Unknown0
);
1297 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1303 IntSetConsoleNumberOfCommands(DWORD dwNumCommands
,
1307 CSR_API_MESSAGE Request
;
1308 PCSR_CAPTURE_BUFFER CaptureBuffer
;
1309 ULONG CsrRequest
= MAKE_CSR_API(SET_HISTORY_NUMBER_COMMANDS
, CSR_CONSOLE
);
1312 if (lpExeName
== NULL
|| !(bUnicode
? *(PWCHAR
)lpExeName
: *(PCHAR
)lpExeName
))
1314 SetLastError(ERROR_INVALID_PARAMETER
);
1318 CaptureBuffer
= CsrAllocateCaptureBuffer(1, IntStringSize(lpExeName
, bUnicode
));
1321 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1324 IntCaptureMessageString(CaptureBuffer
, lpExeName
, bUnicode
,
1325 &Request
.Data
.SetHistoryNumberCommands
.ExeName
);
1326 Request
.Data
.SetHistoryNumberCommands
.NumCommands
= dwNumCommands
;
1327 Status
= CsrClientCallServer(&Request
, CaptureBuffer
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
1328 CsrFreeCaptureBuffer(CaptureBuffer
);
1329 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
1331 SetLastErrorByStatus(Status
);
1338 * @implemented (Undocumented)
1342 SetConsoleNumberOfCommandsA(DWORD dwNumCommands
,
1345 return IntSetConsoleNumberOfCommands(dwNumCommands
, lpExeName
, FALSE
);
1349 * @implemented (Undocumented)
1353 SetConsoleNumberOfCommandsW(DWORD dwNumCommands
,
1356 return IntSetConsoleNumberOfCommands(dwNumCommands
, lpExeName
, TRUE
);
1361 * @unimplemented (Undocumented)
1365 SetConsolePalette(DWORD Unknown0
,
1369 DPRINT1("SetConsolePalette(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
);
1370 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1376 * @unimplemented (Undocumented)
1380 SetLastConsoleEventActive(VOID
)
1382 DPRINT1("SetLastConsoleEventActive() UNIMPLEMENTED!\n");
1383 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1389 * @unimplemented (Undocumented)
1393 ShowConsoleCursor(DWORD Unknown0
,
1396 DPRINT1("ShowConsoleCursor(0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
);
1397 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1403 * FUNCTION: Checks whether the given handle is a valid console handle.
1405 * Handle - Handle to be checked
1407 * TRUE: Handle is a valid console handle
1408 * FALSE: Handle is not a valid console handle.
1409 * STATUS: Officially undocumented
1415 VerifyConsoleIoHandle(HANDLE Handle
)
1417 CSR_API_MESSAGE Request
;
1421 CsrRequest
= MAKE_CSR_API(VERIFY_HANDLE
, CSR_NATIVE
);
1422 Request
.Data
.VerifyHandleRequest
.Handle
= Handle
;
1424 Status
= CsrClientCallServer(&Request
,
1427 sizeof(CSR_API_MESSAGE
));
1428 if (!NT_SUCCESS(Status
))
1430 SetLastErrorByStatus(Status
);
1434 return (BOOL
)NT_SUCCESS(Request
.Status
);
1443 WriteConsoleInputVDMA(DWORD Unknown0
,
1448 DPRINT1("WriteConsoleInputVDMA(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
, Unknown3
);
1449 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1459 WriteConsoleInputVDMW(DWORD Unknown0
,
1464 DPRINT1("WriteConsoleInputVDMW(0x%x, 0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", Unknown0
, Unknown1
, Unknown2
, Unknown3
);
1465 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1471 * @implemented (Undocumented)
1475 CloseConsoleHandle(HANDLE Handle
)
1477 CSR_API_MESSAGE Request
;
1481 CsrRequest
= MAKE_CSR_API(CLOSE_HANDLE
, CSR_NATIVE
);
1482 Request
.Data
.CloseHandleRequest
.Handle
= Handle
;
1484 Status
= CsrClientCallServer(&Request
,
1487 sizeof(CSR_API_MESSAGE
));
1488 if (!NT_SUCCESS(Status
))
1490 SetLastErrorByStatus(Status
);
1502 GetStdHandle(DWORD nStdHandle
)
1504 * FUNCTION: Get a handle for the standard input, standard output
1505 * and a standard error device.
1507 * nStdHandle - Specifies the device for which to return the handle.
1508 * RETURNS: If the function succeeds, the return value is the handle
1509 * of the specified device. Otherwise the value is INVALID_HANDLE_VALUE.
1512 PRTL_USER_PROCESS_PARAMETERS Ppb
;
1514 Ppb
= NtCurrentPeb()->ProcessParameters
;
1517 case STD_INPUT_HANDLE
:
1518 return Ppb
->StandardInput
;
1520 case STD_OUTPUT_HANDLE
:
1521 return Ppb
->StandardOutput
;
1523 case STD_ERROR_HANDLE
:
1524 return Ppb
->StandardError
;
1527 SetLastError (ERROR_INVALID_PARAMETER
);
1528 return INVALID_HANDLE_VALUE
;
1537 SetStdHandle(DWORD nStdHandle
,
1540 * FUNCTION: Set the handle for the standard input, standard output or
1541 * the standard error device.
1543 * nStdHandle - Specifies the handle to be set.
1544 * hHandle - The handle to set.
1545 * RETURNS: TRUE if the function succeeds, FALSE otherwise.
1548 PRTL_USER_PROCESS_PARAMETERS Ppb
;
1550 /* no need to check if hHandle == INVALID_HANDLE_VALUE */
1552 Ppb
= NtCurrentPeb()->ProcessParameters
;
1556 case STD_INPUT_HANDLE
:
1557 Ppb
->StandardInput
= hHandle
;
1560 case STD_OUTPUT_HANDLE
:
1561 Ppb
->StandardOutput
= hHandle
;
1564 case STD_ERROR_HANDLE
:
1565 Ppb
->StandardError
= hHandle
;
1569 /* windows for whatever reason sets the last error to ERROR_INVALID_HANDLE here */
1570 SetLastError(ERROR_INVALID_HANDLE
);
1577 IntWriteConsole(HANDLE hConsoleOutput
,
1579 DWORD nNumberOfCharsToWrite
,
1580 LPDWORD lpNumberOfCharsWritten
,
1584 PCSR_API_MESSAGE Request
;
1588 ULONG SizeBytes
, CharSize
;
1591 CharSize
= (bUnicode
? sizeof(WCHAR
) : sizeof(CHAR
));
1592 Request
= RtlAllocateHeap(RtlGetProcessHeap(),
1594 max(sizeof(CSR_API_MESSAGE
),
1595 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE
) + min(nNumberOfCharsToWrite
,
1596 CSRSS_MAX_WRITE_CONSOLE
/ CharSize
) * CharSize
));
1597 if (Request
== NULL
)
1599 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1603 CsrRequest
= MAKE_CSR_API(WRITE_CONSOLE
, CSR_CONSOLE
);
1605 while (nNumberOfCharsToWrite
> 0)
1607 Request
->Data
.WriteConsoleRequest
.ConsoleHandle
= hConsoleOutput
;
1608 Request
->Data
.WriteConsoleRequest
.Unicode
= bUnicode
;
1610 nChars
= (USHORT
)min(nNumberOfCharsToWrite
, CSRSS_MAX_WRITE_CONSOLE
/ CharSize
);
1611 Request
->Data
.WriteConsoleRequest
.NrCharactersToWrite
= nChars
;
1613 SizeBytes
= nChars
* CharSize
;
1615 memcpy(Request
->Data
.WriteConsoleRequest
.Buffer
, lpBuffer
, SizeBytes
);
1617 Status
= CsrClientCallServer(Request
,
1620 max(sizeof(CSR_API_MESSAGE
),
1621 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE
) + SizeBytes
));
1623 if (Status
== STATUS_PENDING
)
1625 WaitForSingleObject(Request
->Data
.WriteConsoleRequest
.UnpauseEvent
, INFINITE
);
1626 CloseHandle(Request
->Data
.WriteConsoleRequest
.UnpauseEvent
);
1629 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
->Status
))
1631 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
1632 SetLastErrorByStatus(Status
);
1636 nNumberOfCharsToWrite
-= nChars
;
1637 lpBuffer
= (PVOID
)((ULONG_PTR
)lpBuffer
+ (ULONG_PTR
)SizeBytes
);
1638 Written
+= Request
->Data
.WriteConsoleRequest
.NrCharactersWritten
;
1641 if (lpNumberOfCharsWritten
!= NULL
)
1643 *lpNumberOfCharsWritten
= Written
;
1645 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
1651 /*--------------------------------------------------------------
1658 WriteConsoleA(HANDLE hConsoleOutput
,
1659 CONST VOID
*lpBuffer
,
1660 DWORD nNumberOfCharsToWrite
,
1661 LPDWORD lpNumberOfCharsWritten
,
1664 return IntWriteConsole(hConsoleOutput
,
1666 nNumberOfCharsToWrite
,
1667 lpNumberOfCharsWritten
,
1673 /*--------------------------------------------------------------
1680 WriteConsoleW(HANDLE hConsoleOutput
,
1681 CONST VOID
*lpBuffer
,
1682 DWORD nNumberOfCharsToWrite
,
1683 LPDWORD lpNumberOfCharsWritten
,
1686 return IntWriteConsole(hConsoleOutput
,
1688 nNumberOfCharsToWrite
,
1689 lpNumberOfCharsWritten
,
1697 IntReadConsole(HANDLE hConsoleInput
,
1699 DWORD nNumberOfCharsToRead
,
1700 LPDWORD lpNumberOfCharsRead
,
1701 PCONSOLE_READCONSOLE_CONTROL pInputControl
,
1704 CSR_API_MESSAGE Request
;
1705 PCSR_CAPTURE_BUFFER CaptureBuffer
;
1706 ULONG CsrRequest
= MAKE_CSR_API(READ_CONSOLE
, CSR_CONSOLE
);
1707 NTSTATUS Status
= STATUS_SUCCESS
;
1708 ULONG CharSize
= (bUnicode
? sizeof(WCHAR
) : sizeof(CHAR
));
1710 CaptureBuffer
= CsrAllocateCaptureBuffer(1, nNumberOfCharsToRead
* CharSize
);
1711 if (CaptureBuffer
== NULL
)
1713 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1717 CsrAllocateMessagePointer(CaptureBuffer
,
1718 nNumberOfCharsToRead
* CharSize
,
1719 &Request
.Data
.ReadConsoleRequest
.Buffer
);
1721 Request
.Data
.ReadConsoleRequest
.ConsoleHandle
= hConsoleInput
;
1722 Request
.Data
.ReadConsoleRequest
.Unicode
= bUnicode
;
1723 Request
.Data
.ReadConsoleRequest
.NrCharactersToRead
= (WORD
)nNumberOfCharsToRead
;
1724 Request
.Data
.ReadConsoleRequest
.NrCharactersRead
= 0;
1725 Request
.Data
.ReadConsoleRequest
.CtrlWakeupMask
= 0;
1726 if (pInputControl
&& pInputControl
->nLength
== sizeof(CONSOLE_READCONSOLE_CONTROL
))
1728 Request
.Data
.ReadConsoleRequest
.NrCharactersRead
= pInputControl
->nInitialChars
;
1729 memcpy(Request
.Data
.ReadConsoleRequest
.Buffer
,
1731 pInputControl
->nInitialChars
* sizeof(WCHAR
));
1732 Request
.Data
.ReadConsoleRequest
.CtrlWakeupMask
= pInputControl
->dwCtrlWakeupMask
;
1737 if (Status
== STATUS_PENDING
)
1739 Status
= NtWaitForSingleObject(Request
.Data
.ReadConsoleRequest
.EventHandle
,
1742 if (!NT_SUCCESS(Status
))
1744 DPRINT1("Wait for console input failed!\n");
1749 Status
= CsrClientCallServer(&Request
, CaptureBuffer
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
1750 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
1752 DPRINT1("CSR returned error in ReadConsole\n");
1753 CsrFreeCaptureBuffer(CaptureBuffer
);
1754 SetLastErrorByStatus(Status
);
1758 while (Status
== STATUS_PENDING
);
1761 Request
.Data
.ReadConsoleRequest
.Buffer
,
1762 Request
.Data
.ReadConsoleRequest
.NrCharactersRead
* CharSize
);
1764 if (lpNumberOfCharsRead
!= NULL
)
1765 *lpNumberOfCharsRead
= Request
.Data
.ReadConsoleRequest
.NrCharactersRead
;
1767 if (pInputControl
&& pInputControl
->nLength
== sizeof(CONSOLE_READCONSOLE_CONTROL
))
1768 pInputControl
->dwControlKeyState
= Request
.Data
.ReadConsoleRequest
.ControlKeyState
;
1770 CsrFreeCaptureBuffer(CaptureBuffer
);
1776 /*--------------------------------------------------------------
1783 ReadConsoleA(HANDLE hConsoleInput
,
1785 DWORD nNumberOfCharsToRead
,
1786 LPDWORD lpNumberOfCharsRead
,
1787 PCONSOLE_READCONSOLE_CONTROL pInputControl
)
1789 return IntReadConsole(hConsoleInput
,
1791 nNumberOfCharsToRead
,
1792 lpNumberOfCharsRead
,
1798 /*--------------------------------------------------------------
1805 ReadConsoleW(HANDLE hConsoleInput
,
1807 DWORD nNumberOfCharsToRead
,
1808 LPDWORD lpNumberOfCharsRead
,
1809 PCONSOLE_READCONSOLE_CONTROL pInputControl
)
1811 return IntReadConsole(hConsoleInput
,
1813 nNumberOfCharsToRead
,
1814 lpNumberOfCharsRead
,
1820 /*--------------------------------------------------------------
1829 CSR_API_MESSAGE Request
;
1834 if (NtCurrentPeb()->ProcessParameters
->ConsoleHandle
)
1836 DPRINT("AllocConsole: Allocate duplicate console to the same Process\n");
1837 SetLastErrorByStatus (STATUS_OBJECT_NAME_EXISTS
);
1841 Request
.Data
.AllocConsoleRequest
.CtrlDispatcher
= ConsoleControlDispatcher
;
1842 Request
.Data
.AllocConsoleRequest
.ConsoleNeeded
= TRUE
;
1843 Request
.Data
.AllocConsoleRequest
.Visible
= TRUE
;
1845 CsrRequest
= MAKE_CSR_API(ALLOC_CONSOLE
, CSR_CONSOLE
);
1847 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
1848 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
1850 SetLastErrorByStatus(Status
);
1854 NtCurrentPeb()->ProcessParameters
->ConsoleHandle
= Request
.Data
.AllocConsoleRequest
.Console
;
1856 SetStdHandle(STD_INPUT_HANDLE
, Request
.Data
.AllocConsoleRequest
.InputHandle
);
1857 SetStdHandle(STD_OUTPUT_HANDLE
, Request
.Data
.AllocConsoleRequest
.OutputHandle
);
1859 hStdError
= DuplicateConsoleHandle(Request
.Data
.AllocConsoleRequest
.OutputHandle
,
1862 DUPLICATE_SAME_ACCESS
);
1864 SetStdHandle(STD_ERROR_HANDLE
, hStdError
);
1869 /*--------------------------------------------------------------
1878 // AG: I'm not sure if this is correct (what happens to std handles?)
1879 // but I just tried to reverse what AllocConsole() does...
1881 CSR_API_MESSAGE Request
;
1885 CsrRequest
= MAKE_CSR_API(FREE_CONSOLE
, CSR_CONSOLE
);
1887 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
1888 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
1890 SetLastErrorByStatus(Status
);
1894 NtCurrentPeb()->ProcessParameters
->ConsoleHandle
= NULL
;
1899 /*--------------------------------------------------------------
1900 * GetConsoleScreenBufferInfo
1906 GetConsoleScreenBufferInfo(HANDLE hConsoleOutput
,
1907 PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo
)
1909 CSR_API_MESSAGE Request
;
1913 CsrRequest
= MAKE_CSR_API(SCREEN_BUFFER_INFO
, CSR_CONSOLE
);
1914 Request
.Data
.ScreenBufferInfoRequest
.ConsoleHandle
= hConsoleOutput
;
1916 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
1917 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
1919 SetLastErrorByStatus(Status
);
1922 *lpConsoleScreenBufferInfo
= Request
.Data
.ScreenBufferInfoRequest
.Info
;
1927 /*--------------------------------------------------------------
1928 * SetConsoleCursorPosition
1934 SetConsoleCursorPosition(HANDLE hConsoleOutput
,
1935 COORD dwCursorPosition
)
1937 CSR_API_MESSAGE Request
;
1941 CsrRequest
= MAKE_CSR_API(SET_CURSOR
, CSR_CONSOLE
);
1942 Request
.Data
.SetCursorRequest
.ConsoleHandle
= hConsoleOutput
;
1943 Request
.Data
.SetCursorRequest
.Position
= dwCursorPosition
;
1945 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
1946 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
1948 SetLastErrorByStatus(Status
);
1958 IntFillConsoleOutputCharacter(HANDLE hConsoleOutput
,
1962 LPDWORD lpNumberOfCharsWritten
,
1965 CSR_API_MESSAGE Request
;
1969 CsrRequest
= MAKE_CSR_API(FILL_OUTPUT
, CSR_CONSOLE
);
1970 Request
.Data
.FillOutputRequest
.ConsoleHandle
= hConsoleOutput
;
1971 Request
.Data
.FillOutputRequest
.Unicode
= bUnicode
;
1974 Request
.Data
.FillOutputRequest
.Char
.UnicodeChar
= *((WCHAR
*)cCharacter
);
1976 Request
.Data
.FillOutputRequest
.Char
.AsciiChar
= *((CHAR
*)cCharacter
);
1978 Request
.Data
.FillOutputRequest
.Position
= dwWriteCoord
;
1979 Request
.Data
.FillOutputRequest
.Length
= (WORD
)nLength
;
1981 Status
= CsrClientCallServer(&Request
,
1984 sizeof(CSR_API_MESSAGE
));
1986 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
1988 SetLastErrorByStatus(Status
);
1992 if(lpNumberOfCharsWritten
!= NULL
)
1994 *lpNumberOfCharsWritten
= Request
.Data
.FillOutputRequest
.NrCharactersWritten
;
2000 /*--------------------------------------------------------------
2001 * FillConsoleOutputCharacterA
2007 FillConsoleOutputCharacterA(HANDLE hConsoleOutput
,
2011 LPDWORD lpNumberOfCharsWritten
)
2013 return IntFillConsoleOutputCharacter(hConsoleOutput
,
2017 lpNumberOfCharsWritten
,
2022 /*--------------------------------------------------------------
2023 * FillConsoleOutputCharacterW
2029 FillConsoleOutputCharacterW(HANDLE hConsoleOutput
,
2033 LPDWORD lpNumberOfCharsWritten
)
2035 return IntFillConsoleOutputCharacter(hConsoleOutput
,
2039 lpNumberOfCharsWritten
,
2046 IntPeekConsoleInput(HANDLE hConsoleInput
,
2047 PINPUT_RECORD lpBuffer
,
2049 LPDWORD lpNumberOfEventsRead
,
2052 CSR_API_MESSAGE Request
;
2054 PCSR_CAPTURE_BUFFER CaptureBuffer
;
2058 if (lpBuffer
== NULL
)
2060 SetLastError(ERROR_INVALID_PARAMETER
);
2064 Size
= nLength
* sizeof(INPUT_RECORD
);
2066 /* Allocate a Capture Buffer */
2067 DPRINT("IntPeekConsoleInput: %lx %p\n", Size
, lpNumberOfEventsRead
);
2068 CaptureBuffer
= CsrAllocateCaptureBuffer(1, Size
);
2070 /* Allocate space in the Buffer */
2071 CsrCaptureMessageBuffer(CaptureBuffer
,
2074 (PVOID
*)&Request
.Data
.PeekConsoleInputRequest
.InputRecord
);
2076 /* Set up the data to send to the Console Server */
2077 CsrRequest
= MAKE_CSR_API(PEEK_CONSOLE_INPUT
, CSR_CONSOLE
);
2078 Request
.Data
.PeekConsoleInputRequest
.ConsoleHandle
= hConsoleInput
;
2079 Request
.Data
.PeekConsoleInputRequest
.Unicode
= bUnicode
;
2080 Request
.Data
.PeekConsoleInputRequest
.Length
= nLength
;
2082 /* Call the server */
2083 Status
= CsrClientCallServer(&Request
,
2086 sizeof(CSR_API_MESSAGE
));
2087 DPRINT("Server returned: %x\n", Request
.Status
);
2089 /* Check for success*/
2090 if (NT_SUCCESS(Request
.Status
))
2092 /* Return the number of events read */
2093 DPRINT("Events read: %lx\n", Request
.Data
.PeekConsoleInputRequest
.Length
);
2094 *lpNumberOfEventsRead
= Request
.Data
.PeekConsoleInputRequest
.Length
;
2096 /* Copy into the buffer */
2097 DPRINT("Copying to buffer\n");
2098 RtlCopyMemory(lpBuffer
,
2099 Request
.Data
.PeekConsoleInputRequest
.InputRecord
,
2100 sizeof(INPUT_RECORD
) * *lpNumberOfEventsRead
);
2105 *lpNumberOfEventsRead
= 0;
2106 SetLastErrorByStatus(Request
.Status
);
2109 /* Release the capture buffer */
2110 CsrFreeCaptureBuffer(CaptureBuffer
);
2112 /* Return TRUE or FALSE */
2113 return NT_SUCCESS(Request
.Status
);
2116 /*--------------------------------------------------------------
2123 PeekConsoleInputA(HANDLE hConsoleInput
,
2124 PINPUT_RECORD lpBuffer
,
2126 LPDWORD lpNumberOfEventsRead
)
2128 return IntPeekConsoleInput(hConsoleInput
,
2131 lpNumberOfEventsRead
,
2136 /*--------------------------------------------------------------
2143 PeekConsoleInputW(HANDLE hConsoleInput
,
2144 PINPUT_RECORD lpBuffer
,
2146 LPDWORD lpNumberOfEventsRead
)
2148 return IntPeekConsoleInput(hConsoleInput
,
2150 lpNumberOfEventsRead
,
2157 IntReadConsoleInput(HANDLE hConsoleInput
,
2158 PINPUT_RECORD lpBuffer
,
2160 LPDWORD lpNumberOfEventsRead
,
2163 CSR_API_MESSAGE Request
;
2168 CsrRequest
= MAKE_CSR_API(READ_INPUT
, CSR_CONSOLE
);
2173 Request
.Data
.ReadInputRequest
.ConsoleHandle
= hConsoleInput
;
2174 Request
.Data
.ReadInputRequest
.Unicode
= bUnicode
;
2176 Status
= CsrClientCallServer(&Request
,
2179 sizeof(CSR_API_MESSAGE
));
2180 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
2184 /* we couldn't read a single record, fail */
2185 SetLastErrorByStatus(Status
);
2190 /* FIXME - fail gracefully in case we already read at least one record? */
2194 else if (Status
== STATUS_PENDING
)
2198 Status
= NtWaitForSingleObject(Request
.Data
.ReadInputRequest
.Event
, FALSE
, 0);
2199 if (!NT_SUCCESS(Status
))
2201 SetLastErrorByStatus(Status
);
2207 /* nothing more to read (waiting for more input??), let's just bail */
2213 lpBuffer
[Read
++] = Request
.Data
.ReadInputRequest
.Input
;
2216 if (!Request
.Data
.ReadInputRequest
.MoreEvents
)
2218 /* nothing more to read, bail */
2224 if (lpNumberOfEventsRead
!= NULL
)
2226 *lpNumberOfEventsRead
= Read
;
2233 /*--------------------------------------------------------------
2240 ReadConsoleInputA(HANDLE hConsoleInput
,
2241 PINPUT_RECORD lpBuffer
,
2243 LPDWORD lpNumberOfEventsRead
)
2245 return IntReadConsoleInput(hConsoleInput
,
2248 lpNumberOfEventsRead
,
2253 /*--------------------------------------------------------------
2260 ReadConsoleInputW(HANDLE hConsoleInput
,
2261 PINPUT_RECORD lpBuffer
,
2263 LPDWORD lpNumberOfEventsRead
)
2265 return IntReadConsoleInput(hConsoleInput
,
2268 lpNumberOfEventsRead
,
2275 IntWriteConsoleInput(HANDLE hConsoleInput
,
2276 PINPUT_RECORD lpBuffer
,
2278 LPDWORD lpNumberOfEventsWritten
,
2281 CSR_API_MESSAGE Request
;
2283 PCSR_CAPTURE_BUFFER CaptureBuffer
;
2287 if (lpBuffer
== NULL
)
2289 SetLastError(ERROR_INVALID_PARAMETER
);
2293 Size
= nLength
* sizeof(INPUT_RECORD
);
2295 /* Allocate a Capture Buffer */
2296 DPRINT("IntWriteConsoleInput: %lx %p\n", Size
, lpNumberOfEventsWritten
);
2297 CaptureBuffer
= CsrAllocateCaptureBuffer(1, Size
);
2299 /* Allocate space in the Buffer */
2300 CsrCaptureMessageBuffer(CaptureBuffer
,
2303 (PVOID
*)&Request
.Data
.WriteConsoleInputRequest
.InputRecord
);
2305 /* Set up the data to send to the Console Server */
2306 CsrRequest
= MAKE_CSR_API(WRITE_CONSOLE_INPUT
, CSR_CONSOLE
);
2307 Request
.Data
.WriteConsoleInputRequest
.ConsoleHandle
= hConsoleInput
;
2308 Request
.Data
.WriteConsoleInputRequest
.Unicode
= bUnicode
;
2309 Request
.Data
.WriteConsoleInputRequest
.Length
= nLength
;
2311 /* Call the server */
2312 Status
= CsrClientCallServer(&Request
,
2315 sizeof(CSR_API_MESSAGE
));
2316 DPRINT("Server returned: %x\n", Request
.Status
);
2318 /* Check for success*/
2319 if (NT_SUCCESS(Request
.Status
))
2321 /* Return the number of events read */
2322 DPRINT("Events read: %lx\n", Request
.Data
.WriteConsoleInputRequest
.Length
);
2323 *lpNumberOfEventsWritten
= Request
.Data
.WriteConsoleInputRequest
.Length
;
2328 *lpNumberOfEventsWritten
= 0;
2329 SetLastErrorByStatus(Request
.Status
);
2332 /* Release the capture buffer */
2333 CsrFreeCaptureBuffer(CaptureBuffer
);
2335 /* Return TRUE or FALSE */
2336 return NT_SUCCESS(Request
.Status
);
2340 /*--------------------------------------------------------------
2341 * WriteConsoleInputA
2347 WriteConsoleInputA(HANDLE hConsoleInput
,
2348 CONST INPUT_RECORD
*lpBuffer
,
2350 LPDWORD lpNumberOfEventsWritten
)
2352 return IntWriteConsoleInput(hConsoleInput
,
2353 (PINPUT_RECORD
)lpBuffer
,
2355 lpNumberOfEventsWritten
,
2360 /*--------------------------------------------------------------
2361 * WriteConsoleInputW
2367 WriteConsoleInputW(HANDLE hConsoleInput
,
2368 CONST INPUT_RECORD
*lpBuffer
,
2370 LPDWORD lpNumberOfEventsWritten
)
2372 return IntWriteConsoleInput(hConsoleInput
,
2373 (PINPUT_RECORD
)lpBuffer
,
2375 lpNumberOfEventsWritten
,
2382 IntReadConsoleOutput(HANDLE hConsoleOutput
,
2383 PCHAR_INFO lpBuffer
,
2385 COORD dwBufferCoord
,
2386 PSMALL_RECT lpReadRegion
,
2389 CSR_API_MESSAGE Request
;
2391 PCSR_CAPTURE_BUFFER CaptureBuffer
;
2393 DWORD Size
, SizeX
, SizeY
;
2395 if (lpBuffer
== NULL
)
2397 SetLastError(ERROR_INVALID_PARAMETER
);
2401 Size
= dwBufferSize
.X
* dwBufferSize
.Y
* sizeof(CHAR_INFO
);
2403 /* Allocate a Capture Buffer */
2404 DPRINT("IntReadConsoleOutput: %lx %p\n", Size
, lpReadRegion
);
2405 CaptureBuffer
= CsrAllocateCaptureBuffer(1, Size
);
2407 /* Allocate space in the Buffer */
2408 CsrCaptureMessageBuffer(CaptureBuffer
,
2411 (PVOID
*)&Request
.Data
.ReadConsoleOutputRequest
.CharInfo
);
2413 /* Set up the data to send to the Console Server */
2414 CsrRequest
= MAKE_CSR_API(READ_CONSOLE_OUTPUT
, CSR_CONSOLE
);
2415 Request
.Data
.ReadConsoleOutputRequest
.ConsoleHandle
= hConsoleOutput
;
2416 Request
.Data
.ReadConsoleOutputRequest
.Unicode
= bUnicode
;
2417 Request
.Data
.ReadConsoleOutputRequest
.BufferSize
= dwBufferSize
;
2418 Request
.Data
.ReadConsoleOutputRequest
.BufferCoord
= dwBufferCoord
;
2419 Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
= *lpReadRegion
;
2421 /* Call the server */
2422 Status
= CsrClientCallServer(&Request
,
2425 sizeof(CSR_API_MESSAGE
));
2426 DPRINT("Server returned: %x\n", Request
.Status
);
2428 /* Check for success*/
2429 if (NT_SUCCESS(Request
.Status
))
2431 /* Copy into the buffer */
2432 DPRINT("Copying to buffer\n");
2433 SizeX
= Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
.Right
-
2434 Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
.Left
+ 1;
2435 SizeY
= Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
.Bottom
-
2436 Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
.Top
+ 1;
2437 RtlCopyMemory(lpBuffer
,
2438 Request
.Data
.ReadConsoleOutputRequest
.CharInfo
,
2439 sizeof(CHAR_INFO
) * SizeX
* SizeY
);
2444 SetLastErrorByStatus(Request
.Status
);
2447 /* Return the read region */
2448 DPRINT("read region: %lx\n", Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
);
2449 *lpReadRegion
= Request
.Data
.ReadConsoleOutputRequest
.ReadRegion
;
2451 /* Release the capture buffer */
2452 CsrFreeCaptureBuffer(CaptureBuffer
);
2454 /* Return TRUE or FALSE */
2455 return NT_SUCCESS(Request
.Status
);
2458 /*--------------------------------------------------------------
2459 * ReadConsoleOutputA
2465 ReadConsoleOutputA(HANDLE hConsoleOutput
,
2466 PCHAR_INFO lpBuffer
,
2468 COORD dwBufferCoord
,
2469 PSMALL_RECT lpReadRegion
)
2471 return IntReadConsoleOutput(hConsoleOutput
,
2480 /*--------------------------------------------------------------
2481 * ReadConsoleOutputW
2487 ReadConsoleOutputW(HANDLE hConsoleOutput
,
2488 PCHAR_INFO lpBuffer
,
2490 COORD dwBufferCoord
,
2491 PSMALL_RECT lpReadRegion
)
2493 return IntReadConsoleOutput(hConsoleOutput
,
2504 IntWriteConsoleOutput(HANDLE hConsoleOutput
,
2505 CONST CHAR_INFO
*lpBuffer
,
2507 COORD dwBufferCoord
,
2508 PSMALL_RECT lpWriteRegion
,
2511 CSR_API_MESSAGE Request
;
2513 PCSR_CAPTURE_BUFFER CaptureBuffer
;
2517 Size
= dwBufferSize
.Y
* dwBufferSize
.X
* sizeof(CHAR_INFO
);
2519 /* Allocate a Capture Buffer */
2520 DPRINT("IntWriteConsoleOutput: %lx %p\n", Size
, lpWriteRegion
);
2521 CaptureBuffer
= CsrAllocateCaptureBuffer(1, Size
);
2523 /* Allocate space in the Buffer */
2524 CsrCaptureMessageBuffer(CaptureBuffer
,
2527 (PVOID
*)&Request
.Data
.WriteConsoleOutputRequest
.CharInfo
);
2529 /* Copy from the buffer */
2530 RtlCopyMemory(Request
.Data
.WriteConsoleOutputRequest
.CharInfo
, lpBuffer
, Size
);
2532 /* Set up the data to send to the Console Server */
2533 CsrRequest
= MAKE_CSR_API(WRITE_CONSOLE_OUTPUT
, CSR_CONSOLE
);
2534 Request
.Data
.WriteConsoleOutputRequest
.ConsoleHandle
= hConsoleOutput
;
2535 Request
.Data
.WriteConsoleOutputRequest
.Unicode
= bUnicode
;
2536 Request
.Data
.WriteConsoleOutputRequest
.BufferSize
= dwBufferSize
;
2537 Request
.Data
.WriteConsoleOutputRequest
.BufferCoord
= dwBufferCoord
;
2538 Request
.Data
.WriteConsoleOutputRequest
.WriteRegion
= *lpWriteRegion
;
2540 /* Call the server */
2541 Status
= CsrClientCallServer(&Request
,
2544 sizeof(CSR_API_MESSAGE
));
2545 DPRINT("Server returned: %x\n", Request
.Status
);
2547 /* Check for success*/
2548 if (!NT_SUCCESS(Request
.Status
))
2551 SetLastErrorByStatus(Request
.Status
);
2554 /* Return the read region */
2555 DPRINT("read region: %lx\n", Request
.Data
.WriteConsoleOutputRequest
.WriteRegion
);
2556 *lpWriteRegion
= Request
.Data
.WriteConsoleOutputRequest
.WriteRegion
;
2558 /* Release the capture buffer */
2559 CsrFreeCaptureBuffer(CaptureBuffer
);
2561 /* Return TRUE or FALSE */
2562 return NT_SUCCESS(Request
.Status
);
2565 /*--------------------------------------------------------------
2566 * WriteConsoleOutputA
2572 WriteConsoleOutputA(HANDLE hConsoleOutput
,
2573 CONST CHAR_INFO
*lpBuffer
,
2575 COORD dwBufferCoord
,
2576 PSMALL_RECT lpWriteRegion
)
2578 return IntWriteConsoleOutput(hConsoleOutput
,
2587 /*--------------------------------------------------------------
2588 * WriteConsoleOutputW
2594 WriteConsoleOutputW(HANDLE hConsoleOutput
,
2595 CONST CHAR_INFO
*lpBuffer
,
2597 COORD dwBufferCoord
,
2598 PSMALL_RECT lpWriteRegion
)
2600 return IntWriteConsoleOutput(hConsoleOutput
,
2611 IntReadConsoleOutputCharacter(HANDLE hConsoleOutput
,
2615 LPDWORD lpNumberOfCharsRead
,
2618 PCSR_API_MESSAGE Request
;
2621 ULONG nChars
, SizeBytes
, CharSize
;
2622 DWORD CharsRead
= 0;
2624 CharSize
= (bUnicode
? sizeof(WCHAR
) : sizeof(CHAR
));
2626 nChars
= min(nLength
, CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR
) / CharSize
;
2627 SizeBytes
= nChars
* CharSize
;
2629 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
2630 max(sizeof(CSR_API_MESSAGE
),
2631 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_CHAR
)
2632 + min (nChars
, CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR
/ CharSize
) * CharSize
));
2633 if (Request
== NULL
)
2635 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2639 CsrRequest
= MAKE_CSR_API(READ_CONSOLE_OUTPUT_CHAR
, CSR_CONSOLE
);
2640 Request
->Data
.ReadConsoleOutputCharRequest
.ReadCoord
= dwReadCoord
;
2646 Request
->Data
.ReadConsoleOutputCharRequest
.ConsoleHandle
= hConsoleOutput
;
2647 Request
->Data
.ReadConsoleOutputCharRequest
.Unicode
= bUnicode
;
2648 Request
->Data
.ReadConsoleOutputCharRequest
.NumCharsToRead
= min(nLength
, nChars
);
2649 SizeBytes
= Request
->Data
.ReadConsoleOutputCharRequest
.NumCharsToRead
* CharSize
;
2651 Status
= CsrClientCallServer(Request
,
2654 max(sizeof(CSR_API_MESSAGE
),
2655 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_CHAR
) + SizeBytes
));
2656 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Request
->Status
))
2658 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2659 SetLastErrorByStatus(Status
);
2663 BytesRead
= Request
->Data
.ReadConsoleOutputCharRequest
.CharsRead
* CharSize
;
2664 memcpy(lpCharacter
, Request
->Data
.ReadConsoleOutputCharRequest
.String
, BytesRead
);
2665 lpCharacter
= (PVOID
)((ULONG_PTR
)lpCharacter
+ (ULONG_PTR
)BytesRead
);
2666 CharsRead
+= Request
->Data
.ReadConsoleOutputCharRequest
.CharsRead
;
2667 nLength
-= Request
->Data
.ReadConsoleOutputCharRequest
.CharsRead
;
2669 Request
->Data
.ReadConsoleOutputCharRequest
.ReadCoord
= Request
->Data
.ReadConsoleOutputCharRequest
.EndCoord
;
2672 if (lpNumberOfCharsRead
!= NULL
)
2674 *lpNumberOfCharsRead
= CharsRead
;
2677 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2683 /*--------------------------------------------------------------
2684 * ReadConsoleOutputCharacterA
2690 ReadConsoleOutputCharacterA(HANDLE hConsoleOutput
,
2694 LPDWORD lpNumberOfCharsRead
)
2696 return IntReadConsoleOutputCharacter(hConsoleOutput
,
2700 lpNumberOfCharsRead
,
2705 /*--------------------------------------------------------------
2706 * ReadConsoleOutputCharacterW
2712 ReadConsoleOutputCharacterW(HANDLE hConsoleOutput
,
2716 LPDWORD lpNumberOfCharsRead
)
2718 return IntReadConsoleOutputCharacter(hConsoleOutput
,
2722 lpNumberOfCharsRead
,
2727 /*--------------------------------------------------------------
2728 * ReadConsoleOutputAttribute
2734 ReadConsoleOutputAttribute(HANDLE hConsoleOutput
,
2738 LPDWORD lpNumberOfAttrsRead
)
2740 PCSR_API_MESSAGE Request
;
2745 if (lpNumberOfAttrsRead
!= NULL
)
2746 *lpNumberOfAttrsRead
= nLength
;
2748 Request
= RtlAllocateHeap(RtlGetProcessHeap(),
2750 max(sizeof(CSR_API_MESSAGE
),
2751 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_ATTRIB
)
2752 + min (nLength
, CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB
/ sizeof(WORD
)) * sizeof(WORD
)));
2753 if (Request
== NULL
)
2755 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2759 CsrRequest
= MAKE_CSR_API(READ_CONSOLE_OUTPUT_ATTRIB
, CSR_CONSOLE
);
2761 while (nLength
!= 0)
2763 Request
->Data
.ReadConsoleOutputAttribRequest
.ConsoleHandle
= hConsoleOutput
;
2764 Request
->Data
.ReadConsoleOutputAttribRequest
.ReadCoord
= dwReadCoord
;
2766 if (nLength
> CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB
/ sizeof(WORD
))
2767 Size
= CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB
/ sizeof(WCHAR
);
2771 Request
->Data
.ReadConsoleOutputAttribRequest
.NumAttrsToRead
= Size
;
2773 Status
= CsrClientCallServer(Request
,
2776 max(sizeof(CSR_API_MESSAGE
),
2777 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_READ_CONSOLE_OUTPUT_ATTRIB
) + Size
* sizeof(WORD
)));
2778 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Request
->Status
))
2780 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2781 SetLastErrorByStatus(Status
);
2785 memcpy(lpAttribute
, Request
->Data
.ReadConsoleOutputAttribRequest
.Attribute
, Size
* sizeof(WORD
));
2786 lpAttribute
+= Size
;
2788 Request
->Data
.ReadConsoleOutputAttribRequest
.ReadCoord
= Request
->Data
.ReadConsoleOutputAttribRequest
.EndCoord
;
2791 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2799 IntWriteConsoleOutputCharacter(HANDLE hConsoleOutput
,
2803 LPDWORD lpNumberOfCharsWritten
,
2806 PCSR_API_MESSAGE Request
;
2809 ULONG SizeBytes
, CharSize
, nChars
;
2812 CharSize
= (bUnicode
? sizeof(WCHAR
) : sizeof(CHAR
));
2814 nChars
= min(nLength
, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR
/ CharSize
);
2815 SizeBytes
= nChars
* CharSize
;
2817 Request
= RtlAllocateHeap(RtlGetProcessHeap(), 0,
2818 max(sizeof(CSR_API_MESSAGE
),
2819 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE_OUTPUT_CHAR
)
2820 + min (nChars
, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR
/ CharSize
) * CharSize
));
2821 if (Request
== NULL
)
2823 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2827 CsrRequest
= MAKE_CSR_API(WRITE_CONSOLE_OUTPUT_CHAR
, CSR_CONSOLE
);
2828 Request
->Data
.WriteConsoleOutputCharRequest
.Coord
= dwWriteCoord
;
2834 Request
->Data
.WriteConsoleOutputCharRequest
.ConsoleHandle
= hConsoleOutput
;
2835 Request
->Data
.WriteConsoleOutputCharRequest
.Unicode
= bUnicode
;
2836 Request
->Data
.WriteConsoleOutputCharRequest
.Length
= (WORD
)min(nLength
, nChars
);
2837 BytesWrite
= Request
->Data
.WriteConsoleOutputCharRequest
.Length
* CharSize
;
2839 memcpy(Request
->Data
.WriteConsoleOutputCharRequest
.String
, lpCharacter
, BytesWrite
);
2841 Status
= CsrClientCallServer(Request
,
2844 max(sizeof(CSR_API_MESSAGE
),
2845 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE_OUTPUT_CHAR
) + BytesWrite
));
2847 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
->Status
))
2849 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2850 SetLastErrorByStatus(Status
);
2854 nLength
-= Request
->Data
.WriteConsoleOutputCharRequest
.NrCharactersWritten
;
2855 lpCharacter
= (PVOID
)((ULONG_PTR
)lpCharacter
+ (ULONG_PTR
)(Request
->Data
.WriteConsoleOutputCharRequest
.NrCharactersWritten
* CharSize
));
2856 Written
+= Request
->Data
.WriteConsoleOutputCharRequest
.NrCharactersWritten
;
2858 Request
->Data
.WriteConsoleOutputCharRequest
.Coord
= Request
->Data
.WriteConsoleOutputCharRequest
.EndCoord
;
2861 if (lpNumberOfCharsWritten
!= NULL
)
2863 *lpNumberOfCharsWritten
= Written
;
2866 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2872 /*--------------------------------------------------------------
2873 * WriteConsoleOutputCharacterA
2879 WriteConsoleOutputCharacterA(HANDLE hConsoleOutput
,
2883 LPDWORD lpNumberOfCharsWritten
)
2885 return IntWriteConsoleOutputCharacter(hConsoleOutput
,
2889 lpNumberOfCharsWritten
,
2894 /*--------------------------------------------------------------
2895 * WriteConsoleOutputCharacterW
2901 WriteConsoleOutputCharacterW(HANDLE hConsoleOutput
,
2902 LPCWSTR lpCharacter
,
2905 LPDWORD lpNumberOfCharsWritten
)
2907 return IntWriteConsoleOutputCharacter(hConsoleOutput
,
2911 lpNumberOfCharsWritten
,
2916 /*--------------------------------------------------------------
2917 * WriteConsoleOutputAttribute
2923 WriteConsoleOutputAttribute(HANDLE hConsoleOutput
,
2924 CONST WORD
*lpAttribute
,
2927 LPDWORD lpNumberOfAttrsWritten
)
2929 PCSR_API_MESSAGE Request
;
2934 Request
= RtlAllocateHeap(RtlGetProcessHeap(),
2936 max(sizeof(CSR_API_MESSAGE
),
2937 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB
)
2938 + min(nLength
, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB
/ sizeof(WORD
)) * sizeof(WORD
)));
2939 if (Request
== NULL
)
2941 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
2945 CsrRequest
= MAKE_CSR_API(WRITE_CONSOLE_OUTPUT_ATTRIB
, CSR_CONSOLE
);
2946 Request
->Data
.WriteConsoleOutputAttribRequest
.Coord
= dwWriteCoord
;
2948 if (lpNumberOfAttrsWritten
)
2949 *lpNumberOfAttrsWritten
= nLength
;
2952 Size
= (WORD
)min(nLength
, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB
/ sizeof(WORD
));
2953 Request
->Data
.WriteConsoleOutputAttribRequest
.ConsoleHandle
= hConsoleOutput
;
2954 Request
->Data
.WriteConsoleOutputAttribRequest
.Length
= Size
;
2955 memcpy(Request
->Data
.WriteConsoleOutputAttribRequest
.Attribute
, lpAttribute
, Size
* sizeof(WORD
));
2957 Status
= CsrClientCallServer(Request
,
2960 max(sizeof(CSR_API_MESSAGE
),
2961 CSR_API_MESSAGE_HEADER_SIZE(CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB
) + Size
* sizeof(WORD
)));
2963 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
->Status
))
2965 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2966 SetLastErrorByStatus (Status
);
2970 lpAttribute
+= Size
;
2971 Request
->Data
.WriteConsoleOutputAttribRequest
.Coord
= Request
->Data
.WriteConsoleOutputAttribRequest
.EndCoord
;
2974 RtlFreeHeap(RtlGetProcessHeap(), 0, Request
);
2980 /*--------------------------------------------------------------
2981 * FillConsoleOutputAttribute
2987 FillConsoleOutputAttribute(HANDLE hConsoleOutput
,
2991 LPDWORD lpNumberOfAttrsWritten
)
2993 CSR_API_MESSAGE Request
;
2997 CsrRequest
= MAKE_CSR_API(FILL_OUTPUT_ATTRIB
, CSR_CONSOLE
);
2998 Request
.Data
.FillOutputAttribRequest
.ConsoleHandle
= hConsoleOutput
;
2999 Request
.Data
.FillOutputAttribRequest
.Attribute
= (CHAR
)wAttribute
;
3000 Request
.Data
.FillOutputAttribRequest
.Coord
= dwWriteCoord
;
3001 Request
.Data
.FillOutputAttribRequest
.Length
= (WORD
)nLength
;
3003 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
3004 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3006 SetLastErrorByStatus ( Status
);
3010 if (lpNumberOfAttrsWritten
)
3011 *lpNumberOfAttrsWritten
= nLength
;
3017 /*--------------------------------------------------------------
3024 GetConsoleMode(HANDLE hConsoleHandle
,
3027 CSR_API_MESSAGE Request
;
3031 CsrRequest
= MAKE_CSR_API(GET_CONSOLE_MODE
, CSR_CONSOLE
);
3032 Request
.Data
.GetConsoleModeRequest
.ConsoleHandle
= hConsoleHandle
;
3034 Status
= CsrClientCallServer( &Request
, NULL
, CsrRequest
, sizeof( CSR_API_MESSAGE
) );
3035 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3037 SetLastErrorByStatus ( Status
);
3040 *lpMode
= Request
.Data
.GetConsoleModeRequest
.ConsoleMode
;
3046 /*--------------------------------------------------------------
3047 * GetNumberOfConsoleInputEvents
3053 GetNumberOfConsoleInputEvents(HANDLE hConsoleInput
,
3054 LPDWORD lpNumberOfEvents
)
3056 CSR_API_MESSAGE Request
;
3060 if (lpNumberOfEvents
== NULL
)
3062 SetLastError(ERROR_INVALID_PARAMETER
);
3066 CsrRequest
= MAKE_CSR_API(GET_NUM_INPUT_EVENTS
, CSR_CONSOLE
);
3067 Request
.Data
.GetNumInputEventsRequest
.ConsoleHandle
= hConsoleInput
;
3069 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
3070 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3072 SetLastErrorByStatus(Status
);
3076 *lpNumberOfEvents
= Request
.Data
.GetNumInputEventsRequest
.NumInputEvents
;
3082 /*--------------------------------------------------------------
3083 * GetLargestConsoleWindowSize
3089 GetLargestConsoleWindowSize(HANDLE hConsoleOutput
)
3091 COORD Coord
= {80,25};
3092 DPRINT1("GetLargestConsoleWindowSize(0x%x) UNIMPLEMENTED!\n", hConsoleOutput
);
3093 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3098 /*--------------------------------------------------------------
3099 * GetConsoleCursorInfo
3105 GetConsoleCursorInfo(HANDLE hConsoleOutput
,
3106 PCONSOLE_CURSOR_INFO lpConsoleCursorInfo
)
3108 CSR_API_MESSAGE Request
;
3112 if (!lpConsoleCursorInfo
)
3114 if (!hConsoleOutput
)
3115 SetLastError(ERROR_INVALID_HANDLE
);
3117 SetLastError(ERROR_INVALID_ACCESS
);
3122 CsrRequest
= MAKE_CSR_API(GET_CURSOR_INFO
, CSR_CONSOLE
);
3123 Request
.Data
.GetCursorInfoRequest
.ConsoleHandle
= hConsoleOutput
;
3125 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
3127 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3129 SetLastErrorByStatus(Status
);
3132 *lpConsoleCursorInfo
= Request
.Data
.GetCursorInfoRequest
.Info
;
3138 /*--------------------------------------------------------------
3139 * GetNumberOfConsoleMouseButtons
3145 GetNumberOfConsoleMouseButtons(LPDWORD lpNumberOfMouseButtons
)
3147 DPRINT1("GetNumberOfConsoleMouseButtons(0x%x) UNIMPLEMENTED!\n", lpNumberOfMouseButtons
);
3148 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3153 /*--------------------------------------------------------------
3160 SetConsoleMode(HANDLE hConsoleHandle
,
3163 CSR_API_MESSAGE Request
;
3167 CsrRequest
= MAKE_CSR_API(SET_CONSOLE_MODE
, CSR_CONSOLE
);
3168 Request
.Data
.SetConsoleModeRequest
.ConsoleHandle
= hConsoleHandle
;
3169 Request
.Data
.SetConsoleModeRequest
.Mode
= dwMode
;
3171 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
3172 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3174 SetLastErrorByStatus ( Status
);
3182 /*--------------------------------------------------------------
3183 * SetConsoleActiveScreenBuffer
3189 SetConsoleActiveScreenBuffer(HANDLE hConsoleOutput
)
3191 CSR_API_MESSAGE Request
;
3195 CsrRequest
= MAKE_CSR_API(SET_SCREEN_BUFFER
, CSR_CONSOLE
);
3196 Request
.Data
.SetScreenBufferRequest
.OutputHandle
= hConsoleOutput
;
3198 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
3199 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3201 SetLastErrorByStatus(Status
);
3209 /*--------------------------------------------------------------
3210 * FlushConsoleInputBuffer
3216 FlushConsoleInputBuffer(HANDLE hConsoleInput
)
3218 CSR_API_MESSAGE Request
;
3222 CsrRequest
= MAKE_CSR_API(FLUSH_INPUT_BUFFER
, CSR_CONSOLE
);
3223 Request
.Data
.FlushInputBufferRequest
.ConsoleInput
= hConsoleInput
;
3225 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
3226 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3228 SetLastErrorByStatus(Status
);
3236 /*--------------------------------------------------------------
3237 * SetConsoleScreenBufferSize
3243 SetConsoleScreenBufferSize(HANDLE hConsoleOutput
,
3246 CSR_API_MESSAGE Request
;
3250 CsrRequest
= MAKE_CSR_API(SET_SCREEN_BUFFER_SIZE
, CSR_CONSOLE
);
3251 Request
.Data
.SetScreenBufferSize
.OutputHandle
= hConsoleOutput
;
3252 Request
.Data
.SetScreenBufferSize
.Size
= dwSize
;
3254 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
3255 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3257 SetLastErrorByStatus(Status
);
3264 /*--------------------------------------------------------------
3265 * SetConsoleCursorInfo
3271 SetConsoleCursorInfo(HANDLE hConsoleOutput
,
3272 CONST CONSOLE_CURSOR_INFO
*lpConsoleCursorInfo
)
3274 CSR_API_MESSAGE Request
;
3278 CsrRequest
= MAKE_CSR_API(SET_CURSOR_INFO
, CSR_CONSOLE
);
3279 Request
.Data
.SetCursorInfoRequest
.ConsoleHandle
= hConsoleOutput
;
3280 Request
.Data
.SetCursorInfoRequest
.Info
= *lpConsoleCursorInfo
;
3282 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
3283 if(!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3285 SetLastErrorByStatus(Status
);
3295 IntScrollConsoleScreenBuffer(HANDLE hConsoleOutput
,
3296 const SMALL_RECT
*lpScrollRectangle
,
3297 const SMALL_RECT
*lpClipRectangle
,
3298 COORD dwDestinationOrigin
,
3299 const CHAR_INFO
*lpFill
,
3302 CSR_API_MESSAGE Request
;
3306 CsrRequest
= MAKE_CSR_API(SCROLL_CONSOLE_SCREEN_BUFFER
, CSR_CONSOLE
);
3307 Request
.Data
.ScrollConsoleScreenBufferRequest
.ConsoleHandle
= hConsoleOutput
;
3308 Request
.Data
.ScrollConsoleScreenBufferRequest
.Unicode
= bUnicode
;
3309 Request
.Data
.ScrollConsoleScreenBufferRequest
.ScrollRectangle
= *lpScrollRectangle
;
3311 if (lpClipRectangle
!= NULL
)
3313 Request
.Data
.ScrollConsoleScreenBufferRequest
.UseClipRectangle
= TRUE
;
3314 Request
.Data
.ScrollConsoleScreenBufferRequest
.ClipRectangle
= *lpClipRectangle
;
3318 Request
.Data
.ScrollConsoleScreenBufferRequest
.UseClipRectangle
= FALSE
;
3321 Request
.Data
.ScrollConsoleScreenBufferRequest
.DestinationOrigin
= dwDestinationOrigin
;
3322 Request
.Data
.ScrollConsoleScreenBufferRequest
.Fill
= *lpFill
;
3324 Status
= CsrClientCallServer(&Request
,
3327 sizeof(CSR_API_MESSAGE
));
3329 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3331 SetLastErrorByStatus(Status
);
3339 /*--------------------------------------------------------------
3340 * ScrollConsoleScreenBufferA
3346 ScrollConsoleScreenBufferA(HANDLE hConsoleOutput
,
3347 CONST SMALL_RECT
*lpScrollRectangle
,
3348 CONST SMALL_RECT
*lpClipRectangle
,
3349 COORD dwDestinationOrigin
,
3350 CONST CHAR_INFO
*lpFill
)
3352 return IntScrollConsoleScreenBuffer(hConsoleOutput
,
3353 (PSMALL_RECT
)lpScrollRectangle
,
3354 (PSMALL_RECT
)lpClipRectangle
,
3355 dwDestinationOrigin
,
3361 /*--------------------------------------------------------------
3362 * ScrollConsoleScreenBufferW
3368 ScrollConsoleScreenBufferW(HANDLE hConsoleOutput
,
3369 CONST SMALL_RECT
*lpScrollRectangle
,
3370 CONST SMALL_RECT
*lpClipRectangle
,
3371 COORD dwDestinationOrigin
,
3372 CONST CHAR_INFO
*lpFill
)
3374 return IntScrollConsoleScreenBuffer(hConsoleOutput
,
3377 dwDestinationOrigin
,
3383 /*--------------------------------------------------------------
3384 * SetConsoleWindowInfo
3390 SetConsoleWindowInfo(HANDLE hConsoleOutput
,
3392 CONST SMALL_RECT
*lpConsoleWindow
)
3394 DPRINT1("SetConsoleWindowInfo(0x%x, 0x%x, 0x%x) UNIMPLEMENTED!\n", hConsoleOutput
, bAbsolute
, lpConsoleWindow
);
3395 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
3400 /*--------------------------------------------------------------
3401 * SetConsoleTextAttribute
3407 SetConsoleTextAttribute(HANDLE hConsoleOutput
,
3410 CSR_API_MESSAGE Request
;
3414 CsrRequest
= MAKE_CSR_API(SET_ATTRIB
, CSR_CONSOLE
);
3415 Request
.Data
.SetAttribRequest
.ConsoleHandle
= hConsoleOutput
;
3416 Request
.Data
.SetAttribRequest
.Attrib
= wAttributes
;
3418 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
3419 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3421 SetLastErrorByStatus(Status
);
3431 AddConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine
)
3433 PHANDLER_ROUTINE
* NewCtrlHandlers
= NULL
;
3435 if (HandlerRoutine
== NULL
)
3437 NtCurrentPeb()->ProcessParameters
->ConsoleFlags
= TRUE
;
3441 if (NrCtrlHandlers
== NrAllocatedHandlers
)
3443 NewCtrlHandlers
= RtlAllocateHeap(RtlGetProcessHeap(),
3445 (NrCtrlHandlers
+ 4) * sizeof(PHANDLER_ROUTINE
));
3446 if (NewCtrlHandlers
== NULL
)
3448 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
3452 memmove(NewCtrlHandlers
, CtrlHandlers
, sizeof(PHANDLER_ROUTINE
) * NrCtrlHandlers
);
3454 if (NrAllocatedHandlers
> 1) RtlFreeHeap(RtlGetProcessHeap(), 0, CtrlHandlers
);
3456 CtrlHandlers
= NewCtrlHandlers
;
3457 NrAllocatedHandlers
+= 4;
3460 ASSERT(NrCtrlHandlers
< NrAllocatedHandlers
);
3462 CtrlHandlers
[NrCtrlHandlers
++] = HandlerRoutine
;
3469 RemoveConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine
)
3473 if (HandlerRoutine
== NULL
)
3475 NtCurrentPeb()->ProcessParameters
->ConsoleFlags
= FALSE
;
3479 for (i
= 0; i
< NrCtrlHandlers
; i
++)
3481 if (CtrlHandlers
[i
] == HandlerRoutine
)
3483 if (i
< (NrCtrlHandlers
- 1))
3485 memmove(&CtrlHandlers
[i
],
3487 (NrCtrlHandlers
- i
+ 1) * sizeof(PHANDLER_ROUTINE
));
3495 SetLastError(ERROR_INVALID_PARAMETER
);
3505 SetConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine
,
3510 RtlEnterCriticalSection(&DllLock
);
3513 Ret
= AddConsoleCtrlHandler(HandlerRoutine
);
3517 Ret
= RemoveConsoleCtrlHandler(HandlerRoutine
);
3520 RtlLeaveCriticalSection(&DllLock
);
3525 /*--------------------------------------------------------------
3526 * GenerateConsoleCtrlEvent
3532 GenerateConsoleCtrlEvent(DWORD dwCtrlEvent
,
3533 DWORD dwProcessGroupId
)
3535 CSR_API_MESSAGE Request
;
3539 if (dwCtrlEvent
!= CTRL_C_EVENT
&& dwCtrlEvent
!= CTRL_BREAK_EVENT
)
3541 SetLastError(ERROR_INVALID_PARAMETER
);
3545 CsrRequest
= MAKE_CSR_API(GENERATE_CTRL_EVENT
, CSR_CONSOLE
);
3546 Request
.Data
.GenerateCtrlEvent
.Event
= dwCtrlEvent
;
3547 Request
.Data
.GenerateCtrlEvent
.ProcessGroup
= dwProcessGroupId
;
3549 Status
= CsrClientCallServer(&Request
,
3552 sizeof(CSR_API_MESSAGE
));
3553 if(!NT_SUCCESS(Status
) || !(NT_SUCCESS(Status
= Request
.Status
)))
3555 SetLastErrorByStatus(Status
);
3564 IntGetConsoleTitle(LPVOID lpConsoleTitle
, DWORD nSize
, BOOL bUnicode
)
3566 CSR_API_MESSAGE Request
;
3567 PCSR_CAPTURE_BUFFER CaptureBuffer
;
3568 ULONG CsrRequest
= MAKE_CSR_API(GET_TITLE
, CSR_CONSOLE
);
3574 Request
.Data
.GetTitleRequest
.Length
= nSize
* (bUnicode
? 1 : sizeof(WCHAR
));
3575 CaptureBuffer
= CsrAllocateCaptureBuffer(1, Request
.Data
.GetTitleRequest
.Length
);
3576 if (CaptureBuffer
== NULL
)
3578 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
3582 CsrAllocateMessagePointer(CaptureBuffer
,
3583 Request
.Data
.GetTitleRequest
.Length
,
3584 (PVOID
*)&Request
.Data
.GetTitleRequest
.Title
);
3586 Status
= CsrClientCallServer(&Request
, CaptureBuffer
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
3587 if (!NT_SUCCESS(Status
) || !(NT_SUCCESS(Status
= Request
.Status
)))
3589 CsrFreeCaptureBuffer(CaptureBuffer
);
3590 SetLastErrorByStatus(Status
);
3596 if (nSize
>= sizeof(WCHAR
))
3597 wcscpy((LPWSTR
)lpConsoleTitle
, Request
.Data
.GetTitleRequest
.Title
);
3601 if (nSize
< Request
.Data
.GetTitleRequest
.Length
/ sizeof(WCHAR
) ||
3602 !WideCharToMultiByte(CP_ACP
, // ANSI code page
3603 0, // performance and mapping flags
3604 Request
.Data
.GetTitleRequest
.Title
, // address of wide-character string
3605 -1, // number of characters in string
3606 (LPSTR
)lpConsoleTitle
, // address of buffer for new string
3607 nSize
, // size of buffer
3611 /* Yes, if the buffer isn't big enough, it returns 0... Bad API */
3612 *(LPSTR
)lpConsoleTitle
= '\0';
3613 Request
.Data
.GetTitleRequest
.Length
= 0;
3616 CsrFreeCaptureBuffer(CaptureBuffer
);
3618 return Request
.Data
.GetTitleRequest
.Length
/ sizeof(WCHAR
);
3621 /*--------------------------------------------------------------
3628 GetConsoleTitleW(LPWSTR lpConsoleTitle
,
3631 return IntGetConsoleTitle(lpConsoleTitle
, nSize
, TRUE
);
3634 /*--------------------------------------------------------------
3643 GetConsoleTitleA(LPSTR lpConsoleTitle
,
3646 return IntGetConsoleTitle(lpConsoleTitle
, nSize
, FALSE
);
3650 /*--------------------------------------------------------------
3657 SetConsoleTitleW(LPCWSTR lpConsoleTitle
)
3659 CSR_API_MESSAGE Request
;
3660 PCSR_CAPTURE_BUFFER CaptureBuffer
;
3661 ULONG CsrRequest
= MAKE_CSR_API(SET_TITLE
, CSR_CONSOLE
);
3664 Request
.Data
.SetTitleRequest
.Length
= wcslen(lpConsoleTitle
) * sizeof(WCHAR
);
3666 CaptureBuffer
= CsrAllocateCaptureBuffer(1, Request
.Data
.SetTitleRequest
.Length
);
3667 if (CaptureBuffer
== NULL
)
3669 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
3673 CsrCaptureMessageBuffer(CaptureBuffer
,
3674 (PVOID
)lpConsoleTitle
,
3675 Request
.Data
.SetTitleRequest
.Length
,
3676 (PVOID
*)&Request
.Data
.SetTitleRequest
.Title
);
3678 Status
= CsrClientCallServer(&Request
, CaptureBuffer
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
3679 CsrFreeCaptureBuffer(CaptureBuffer
);
3680 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3682 SetLastErrorByStatus(Status
);
3690 /*--------------------------------------------------------------
3699 SetConsoleTitleA(LPCSTR lpConsoleTitle
)
3701 ULONG Length
= strlen(lpConsoleTitle
) + 1;
3702 LPWSTR WideTitle
= HeapAlloc(GetProcessHeap(), 0, Length
* sizeof(WCHAR
));
3706 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
3709 MultiByteToWideChar(CP_ACP
, 0, lpConsoleTitle
, -1, WideTitle
, Length
);
3710 Ret
= SetConsoleTitleW(WideTitle
);
3711 HeapFree(GetProcessHeap(), 0, WideTitle
);
3716 /*--------------------------------------------------------------
3717 * CreateConsoleScreenBuffer
3723 CreateConsoleScreenBuffer(DWORD dwDesiredAccess
,
3725 CONST SECURITY_ATTRIBUTES
*lpSecurityAttributes
,
3727 LPVOID lpScreenBufferData
)
3729 CSR_API_MESSAGE Request
;
3733 if (dwDesiredAccess
& ~(GENERIC_READ
| GENERIC_WRITE
)
3734 || dwShareMode
& ~(FILE_SHARE_READ
| FILE_SHARE_WRITE
)
3735 || dwFlags
!= CONSOLE_TEXTMODE_BUFFER
)
3737 SetLastError(ERROR_INVALID_PARAMETER
);
3738 return INVALID_HANDLE_VALUE
;
3741 Request
.Data
.CreateScreenBufferRequest
.Access
= dwDesiredAccess
;
3742 Request
.Data
.CreateScreenBufferRequest
.ShareMode
= dwShareMode
;
3743 Request
.Data
.CreateScreenBufferRequest
.Inheritable
=
3744 lpSecurityAttributes
? lpSecurityAttributes
->bInheritHandle
: FALSE
;
3746 CsrRequest
= MAKE_CSR_API(CREATE_SCREEN_BUFFER
, CSR_CONSOLE
);
3747 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
3748 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3750 SetLastErrorByStatus(Status
);
3751 return INVALID_HANDLE_VALUE
;
3753 return Request
.Data
.CreateScreenBufferRequest
.OutputHandle
;
3757 /*--------------------------------------------------------------
3766 CSR_API_MESSAGE Request
;
3770 CsrRequest
= MAKE_CSR_API(GET_CONSOLE_CP
, CSR_CONSOLE
);
3771 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
3772 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3774 SetLastErrorByStatus (Status
);
3778 return Request
.Data
.GetConsoleCodePage
.CodePage
;
3782 /*--------------------------------------------------------------
3789 SetConsoleCP(UINT wCodePageID
)
3791 CSR_API_MESSAGE Request
;
3795 CsrRequest
= MAKE_CSR_API(SET_CONSOLE_CP
, CSR_CONSOLE
);
3796 Request
.Data
.SetConsoleCodePage
.CodePage
= wCodePageID
;
3798 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
3799 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3801 SetLastErrorByStatus(Status
);
3804 return NT_SUCCESS(Status
);
3808 /*--------------------------------------------------------------
3809 * GetConsoleOutputCP
3815 GetConsoleOutputCP(VOID
)
3817 CSR_API_MESSAGE Request
;
3821 CsrRequest
= MAKE_CSR_API(GET_CONSOLE_OUTPUT_CP
, CSR_CONSOLE
);
3822 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
3823 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3825 SetLastErrorByStatus (Status
);
3829 return Request
.Data
.GetConsoleOutputCodePage
.CodePage
;
3833 /*--------------------------------------------------------------
3834 * SetConsoleOutputCP
3840 SetConsoleOutputCP(UINT wCodePageID
)
3842 CSR_API_MESSAGE Request
;
3846 CsrRequest
= MAKE_CSR_API(SET_CONSOLE_OUTPUT_CP
, CSR_CONSOLE
);
3847 Request
.Data
.SetConsoleOutputCodePage
.CodePage
= wCodePageID
;
3848 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
3849 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3851 SetLastErrorByStatus(Status
);
3854 return NT_SUCCESS(Status
);
3858 /*--------------------------------------------------------------
3859 * GetConsoleProcessList
3865 GetConsoleProcessList(LPDWORD lpdwProcessList
,
3866 DWORD dwProcessCount
)
3868 PCSR_CAPTURE_BUFFER CaptureBuffer
;
3869 CSR_API_MESSAGE Request
;
3874 if (lpdwProcessList
== NULL
|| dwProcessCount
== 0)
3876 SetLastError(ERROR_INVALID_PARAMETER
);
3880 CaptureBuffer
= CsrAllocateCaptureBuffer(1, dwProcessCount
* sizeof(DWORD
));
3881 if (CaptureBuffer
== NULL
)
3883 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
3887 CsrRequest
= MAKE_CSR_API(GET_PROCESS_LIST
, CSR_CONSOLE
);
3888 Request
.Data
.GetProcessListRequest
.nMaxIds
= dwProcessCount
;
3889 CsrAllocateMessagePointer(CaptureBuffer
,
3890 dwProcessCount
* sizeof(DWORD
),
3891 (PVOID
*)&Request
.Data
.GetProcessListRequest
.ProcessId
);
3893 Status
= CsrClientCallServer(&Request
,
3896 sizeof(CSR_API_MESSAGE
));
3897 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3899 SetLastErrorByStatus (Status
);
3904 nProcesses
= Request
.Data
.GetProcessListRequest
.nProcessIdsTotal
;
3905 if (dwProcessCount
>= nProcesses
)
3907 memcpy(lpdwProcessList
, Request
.Data
.GetProcessListRequest
.ProcessId
, nProcesses
* sizeof(DWORD
));
3911 CsrFreeCaptureBuffer(CaptureBuffer
);
3917 /*--------------------------------------------------------------
3918 * GetConsoleSelectionInfo
3924 GetConsoleSelectionInfo(PCONSOLE_SELECTION_INFO lpConsoleSelectionInfo
)
3926 CSR_API_MESSAGE Request
;
3927 ULONG CsrRequest
= MAKE_CSR_API(GET_CONSOLE_SELECTION_INFO
, CSR_CONSOLE
);
3928 NTSTATUS Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
3929 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3931 SetLastErrorByStatus(Status
);
3935 *lpConsoleSelectionInfo
= Request
.Data
.GetConsoleSelectionInfo
.Info
;
3941 /*--------------------------------------------------------------
3948 AttachConsole(DWORD dwProcessId
)
3950 DPRINT1("AttachConsole(0x%x) UNIMPLEMENTED!\n", dwProcessId
);
3954 /*--------------------------------------------------------------
3961 GetConsoleWindow(VOID
)
3963 CSR_API_MESSAGE Request
;
3967 CsrRequest
= MAKE_CSR_API(GET_CONSOLE_WINDOW
, CSR_CONSOLE
);
3968 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
3969 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3971 SetLastErrorByStatus(Status
);
3975 return Request
.Data
.GetConsoleWindowRequest
.WindowHandle
;
3979 /*--------------------------------------------------------------
3986 SetConsoleIcon(HICON hicon
)
3988 CSR_API_MESSAGE Request
;
3992 CsrRequest
= MAKE_CSR_API(SET_CONSOLE_ICON
, CSR_CONSOLE
);
3993 Request
.Data
.SetConsoleIconRequest
.WindowIcon
= hicon
;
3995 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
3996 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
3998 SetLastErrorByStatus(Status
);
4002 return NT_SUCCESS(Status
);
4006 /******************************************************************************
4007 * \name SetConsoleInputExeNameW
4008 * \brief Sets the console input file name from a unicode string.
4009 * \param lpInputExeName Pointer to a unicode string with the name.
4010 * \return TRUE if successful, FALSE if unsuccsedful.
4011 * \remarks If lpInputExeName is 0 or the string length is 0 or greater than 255,
4012 * the function fails and sets last error to ERROR_INVALID_PARAMETER.
4016 SetConsoleInputExeNameW(LPCWSTR lpInputExeName
)
4021 || (lenName
= lstrlenW(lpInputExeName
)) == 0
4022 || lenName
> INPUTEXENAME_BUFLEN
- 1)
4024 /* Fail if string is empty or too long */
4025 SetLastError(ERROR_INVALID_PARAMETER
);
4029 RtlEnterCriticalSection(&ConsoleLock
);
4032 RtlCopyMemory(InputExeName
, lpInputExeName
, lenName
* sizeof(WCHAR
));
4033 InputExeName
[lenName
] = L
'\0';
4037 RtlLeaveCriticalSection(&ConsoleLock
);
4045 /******************************************************************************
4046 * \name SetConsoleInputExeNameA
4047 * \brief Sets the console input file name from an ansi string.
4048 * \param lpInputExeName Pointer to an ansi string with the name.
4049 * \return TRUE if successful, FALSE if unsuccsedful.
4050 * \remarks If lpInputExeName is 0 or the string length is 0 or greater than 255,
4051 * the function fails and sets last error to ERROR_INVALID_PARAMETER.
4055 SetConsoleInputExeNameA(LPCSTR lpInputExeName
)
4057 WCHAR Buffer
[INPUTEXENAME_BUFLEN
];
4058 ANSI_STRING InputExeNameA
;
4059 UNICODE_STRING InputExeNameU
;
4063 RtlInitAnsiString(&InputExeNameA
, lpInputExeName
);
4065 if(InputExeNameA
.Length
== 0 ||
4066 InputExeNameA
.Length
> INPUTEXENAME_BUFLEN
- 1)
4068 /* Fail if string is empty or too long */
4069 SetLastError(ERROR_INVALID_PARAMETER
);
4073 InputExeNameU
.Buffer
= Buffer
;
4074 InputExeNameU
.MaximumLength
= sizeof(Buffer
);
4075 InputExeNameU
.Length
= 0;
4076 Status
= RtlAnsiStringToUnicodeString(&InputExeNameU
, &InputExeNameA
, FALSE
);
4077 if(NT_SUCCESS(Status
))
4079 Ret
= SetConsoleInputExeNameW(InputExeNameU
.Buffer
);
4083 SetLastErrorByStatus(Status
);
4091 /******************************************************************************
4092 * \name GetConsoleInputExeNameW
4093 * \brief Retrieves the console input file name as unicode string.
4094 * \param nBufferLength Length of the buffer in WCHARs.
4095 * Specify 0 to recieve the needed buffer length.
4096 * \param lpBuffer Pointer to a buffer that recieves the string.
4097 * \return Needed buffer size if \p nBufferLength is 0.
4098 * Otherwise 1 if successful, 2 if buffer is too small.
4099 * \remarks Sets last error value to ERROR_BUFFER_OVERFLOW if the buffer
4100 * is not big enough.
4104 GetConsoleInputExeNameW(DWORD nBufferLength
, LPWSTR lpBuffer
)
4106 int lenName
= lstrlenW(InputExeName
);
4108 if (nBufferLength
== 0)
4110 /* Buffer size is requested, return it */
4114 if(lenName
+ 1 > nBufferLength
)
4116 /* Buffer is not large enough! */
4117 SetLastError(ERROR_BUFFER_OVERFLOW
);
4121 RtlEnterCriticalSection(&ConsoleLock
);
4124 RtlCopyMemory(lpBuffer
, InputExeName
, lenName
* sizeof(WCHAR
));
4125 lpBuffer
[lenName
] = '\0';
4129 RtlLeaveCriticalSection(&ConsoleLock
);
4133 /* Success, return 1 */
4138 /******************************************************************************
4139 * \name GetConsoleInputExeNameA
4140 * \brief Retrieves the console input file name as ansi string.
4141 * \param nBufferLength Length of the buffer in CHARs.
4142 * \param lpBuffer Pointer to a buffer that recieves the string.
4143 * \return 1 if successful, 2 if buffer is too small.
4144 * \remarks Sets last error value to ERROR_BUFFER_OVERFLOW if the buffer
4145 * is not big enough. The buffer recieves as much characters as fit.
4149 GetConsoleInputExeNameA(DWORD nBufferLength
, LPSTR lpBuffer
)
4151 WCHAR Buffer
[INPUTEXENAME_BUFLEN
];
4153 UNICODE_STRING BufferU
;
4154 ANSI_STRING BufferA
;
4156 /* Get the unicode name */
4157 Ret
= GetConsoleInputExeNameW(sizeof(Buffer
) / sizeof(Buffer
[0]), Buffer
);
4159 /* Initialize strings for conversion */
4160 RtlInitUnicodeString(&BufferU
, Buffer
);
4162 BufferA
.MaximumLength
= nBufferLength
;
4163 BufferA
.Buffer
= lpBuffer
;
4165 /* Convert unicode name to ansi, copying as much chars as fit */
4166 RtlUnicodeStringToAnsiString(&BufferA
, &BufferU
, FALSE
);
4168 /* Error handling */
4169 if(nBufferLength
<= BufferU
.Length
/ sizeof(WCHAR
))
4171 SetLastError(ERROR_BUFFER_OVERFLOW
);
4179 /*--------------------------------------------------------------
4180 * GetConsoleHistoryInfo
4186 GetConsoleHistoryInfo(PCONSOLE_HISTORY_INFO lpConsoleHistoryInfo
)
4188 CSR_API_MESSAGE Request
;
4189 ULONG CsrRequest
= MAKE_CSR_API(GET_HISTORY_INFO
, CSR_CONSOLE
);
4191 if (lpConsoleHistoryInfo
->cbSize
!= sizeof(CONSOLE_HISTORY_INFO
))
4193 SetLastError(ERROR_INVALID_PARAMETER
);
4196 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
4197 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
4199 SetLastErrorByStatus(Status
);
4202 lpConsoleHistoryInfo
->HistoryBufferSize
= Request
.Data
.GetHistoryInfo
.HistoryBufferSize
;
4203 lpConsoleHistoryInfo
->NumberOfHistoryBuffers
= Request
.Data
.GetHistoryInfo
.NumberOfHistoryBuffers
;
4204 lpConsoleHistoryInfo
->dwFlags
= Request
.Data
.GetHistoryInfo
.dwFlags
;
4209 /*--------------------------------------------------------------
4210 * SetConsoleHistoryInfo
4216 SetConsoleHistoryInfo(IN PCONSOLE_HISTORY_INFO lpConsoleHistoryInfo
)
4218 CSR_API_MESSAGE Request
;
4219 ULONG CsrRequest
= MAKE_CSR_API(GET_HISTORY_INFO
, CSR_CONSOLE
);
4221 if (lpConsoleHistoryInfo
->cbSize
!= sizeof(CONSOLE_HISTORY_INFO
))
4223 SetLastError(ERROR_INVALID_PARAMETER
);
4226 Request
.Data
.SetHistoryInfo
.HistoryBufferSize
= lpConsoleHistoryInfo
->HistoryBufferSize
;
4227 Request
.Data
.SetHistoryInfo
.NumberOfHistoryBuffers
= lpConsoleHistoryInfo
->NumberOfHistoryBuffers
;
4228 Request
.Data
.SetHistoryInfo
.dwFlags
= lpConsoleHistoryInfo
->dwFlags
;
4229 Status
= CsrClientCallServer(&Request
, NULL
, CsrRequest
, sizeof(CSR_API_MESSAGE
));
4230 if (!NT_SUCCESS(Status
) || !NT_SUCCESS(Status
= Request
.Status
))
4232 SetLastErrorByStatus(Status
);
4239 /*--------------------------------------------------------------
4240 * GetConsoleOriginalTitleW
4246 GetConsoleOriginalTitleW(OUT LPWSTR lpConsoleTitle
,
4249 DPRINT1("GetConsoleOriginalTitleW(0x%p, 0x%x) UNIMPLEMENTED!\n", lpConsoleTitle
, nSize
);
4250 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
4255 /*--------------------------------------------------------------
4256 * GetConsoleOriginalTitleA
4262 GetConsoleOriginalTitleA(OUT LPSTR lpConsoleTitle
,
4265 DPRINT1("GetConsoleOriginalTitleA(0x%p, 0x%x) UNIMPLEMENTED!\n", lpConsoleTitle
, nSize
);
4266 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
4271 /*--------------------------------------------------------------
4272 * GetConsoleScreenBufferInfoEx
4278 GetConsoleScreenBufferInfoEx(IN HANDLE hConsoleOutput
,
4279 OUT PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx
)
4281 DPRINT1("GetConsoleScreenBufferInfoEx(0x%p, 0x%p) UNIMPLEMENTED!\n", hConsoleOutput
, lpConsoleScreenBufferInfoEx
);
4282 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
4287 /*--------------------------------------------------------------
4288 * SetConsoleScreenBufferInfoEx
4294 SetConsoleScreenBufferInfoEx(IN HANDLE hConsoleOutput
,
4295 IN PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx
)
4297 DPRINT1("SetConsoleScreenBufferInfoEx(0x%p, 0x%p) UNIMPLEMENTED!\n", hConsoleOutput
, lpConsoleScreenBufferInfoEx
);
4298 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
4303 /*--------------------------------------------------------------
4304 * GetCurrentConsoleFontEx
4310 GetCurrentConsoleFontEx(IN HANDLE hConsoleOutput
,
4311 IN BOOL bMaximumWindow
,
4312 OUT PCONSOLE_FONT_INFOEX lpConsoleCurrentFontEx
)
4314 DPRINT1("GetCurrentConsoleFontEx(0x%p, 0x%x, 0x%p) UNIMPLEMENTED!\n", hConsoleOutput
, bMaximumWindow
, lpConsoleCurrentFontEx
);
4315 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);