-/* $Id: console.c,v 1.52 2003/02/24 23:24:55 hbirr Exp $
+/* $Id: console.c,v 1.79 2004/08/28 22:14:08 navaraf Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: lib/kernel32/misc/console.c
* PURPOSE: Win32 server console functions
- * PROGRAMMER: ???
+ * PROGRAMMER: James Tabor
+ * <jimtabor@adsl-64-217-116-74.dsl.hstntx.swbell.net>
* UPDATE HISTORY:
* 199901?? ?? Created
* 19990204 EA SetConsoleTitleA
#include <k32.h>
#define NDEBUG
-#include <kernel32/kernel32.h>
+#include "../include/debug.h"
+
+#define _NOACHS(__X) (sizeof(__X) / sizeof((__X)[0]))
+extern BOOL WINAPI DefaultConsoleCtrlHandler(DWORD Event);
+extern __declspec(noreturn) VOID CALLBACK ConsoleControlDispatcher(DWORD CodeAndFlag);
+extern CRITICAL_SECTION ConsoleLock;
+extern BOOL WINAPI IsDebuggerPresent(VOID);
+
/* GLOBALS *******************************************************************/
static BOOL IgnoreCtrlEvents = FALSE;
-static ULONG NrCtrlHandlers = 0;
+
static PHANDLER_ROUTINE* CtrlHandlers = NULL;
+static ULONG NrCtrlHandlers = 0;
+
+/* Default Console Control Handler *******************************************/
+
+BOOL WINAPI DefaultConsoleCtrlHandler(DWORD Event)
+{
+ switch(Event)
+ {
+ case CTRL_C_EVENT:
+ DPRINT("Ctrl-C Event\n");
+ ExitProcess(0);
+ break;
+
+ case CTRL_BREAK_EVENT:
+ DPRINT("Ctrl-Break Event\n");
+ ExitProcess(0);
+ break;
+
+ case CTRL_SHUTDOWN_EVENT:
+ DPRINT("Ctrl Shutdown Event\n");
+ break;
+
+ case CTRL_CLOSE_EVENT:
+ DPRINT("Ctrl Close Event\n");
+ break;
+
+ case CTRL_LOGOFF_EVENT:
+ DPRINT("Ctrl Logoff Event\n");
+ break;
+ }
+// ExitProcess((UINT)&ExitCode);
+ return TRUE;
+}
+
+
+__declspec(noreturn) VOID CALLBACK ConsoleControlDispatcher(DWORD CodeAndFlag)
+{
+DWORD nExitCode = 0;
+DWORD nCode = CodeAndFlag & MAXLONG;
+UINT i;
+
+SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
+
+ switch(nCode)
+ {
+ case CTRL_C_EVENT:
+ case CTRL_BREAK_EVENT:
+ {
+ if(IsDebuggerPresent())
+ {
+ EXCEPTION_RECORD erException;
+ erException.ExceptionCode =
+ (nCode == CTRL_C_EVENT ? DBG_CONTROL_C : DBG_CONTROL_BREAK);
+ erException.ExceptionFlags = 0;
+ erException.ExceptionRecord = NULL;
+ erException.ExceptionAddress = &DefaultConsoleCtrlHandler;
+ erException.NumberParameters = 0;
+ RtlRaiseException(&erException);
+ }
+ RtlEnterCriticalSection(&ConsoleLock);
+
+ if(!(nCode == CTRL_C_EVENT &&
+ NtCurrentPeb()->ProcessParameters->ProcessGroup & 1))
+ {
+ for(i = NrCtrlHandlers; i > 0; -- i)
+ if(CtrlHandlers[i - 1](nCode)) break;
+ }
+ RtlLeaveCriticalSection(&ConsoleLock);
+ ExitThread(0);
+ }
+ case CTRL_CLOSE_EVENT:
+ case CTRL_LOGOFF_EVENT:
+ case CTRL_SHUTDOWN_EVENT:
+ break;
+
+ default: ExitThread(0);
+ }
+
+ RtlEnterCriticalSection(&ConsoleLock);
+
+ if(!(nCode == CTRL_C_EVENT &&
+ NtCurrentPeb()->ProcessParameters->ProcessGroup & 1))
+ {
+ i = NrCtrlHandlers;
+ while(i > 0)
+ {
+ if (i == 1 && (CodeAndFlag & MINLONG) &&
+ (nCode == CTRL_LOGOFF_EVENT || nCode == CTRL_SHUTDOWN_EVENT))
+ break;
+
+ if(CtrlHandlers[i - 1](nCode))
+ {
+ switch(nCode)
+ {
+ case CTRL_CLOSE_EVENT:
+ case CTRL_LOGOFF_EVENT:
+ case CTRL_SHUTDOWN_EVENT:
+ nExitCode = CodeAndFlag;
+ }
+ break;
+ }
+ --i;
+ }
+ }
+ RtlLeaveCriticalSection(&ConsoleLock);
+ ExitThread(nExitCode);
+}
+
/* FUNCTIONS *****************************************************************/
+/*
+ * @unimplemented
+ */
BOOL STDCALL
AddConsoleAliasA (LPSTR Source,
LPSTR Target,
return FALSE;
}
+
+/*
+ * @unimplemented
+ */
BOOL STDCALL
AddConsoleAliasW (LPWSTR Source,
LPWSTR Target,
return FALSE;
}
+
+/*
+ * @unimplemented
+ */
BOOL STDCALL
ConsoleMenuControl (HANDLE hConsole,
DWORD Unknown1,
return FALSE;
}
-BOOL STDCALL
+
+/*
+ * @implemented
+ */
+HANDLE STDCALL
DuplicateConsoleHandle (HANDLE hConsole,
- DWORD Unknown1,
- DWORD Unknown2,
- DWORD Unknown3)
- /*
- * Undocumented
- */
+ DWORD dwDesiredAccess,
+ BOOL bInheritHandle,
+ DWORD dwOptions)
{
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return FALSE;
+ CSRSS_API_REQUEST Request;
+ CSRSS_API_REPLY Reply;
+ NTSTATUS Status;
+
+ if (IsConsoleHandle (hConsole) == FALSE)
+ {
+ SetLastError (ERROR_INVALID_PARAMETER);
+ return INVALID_HANDLE_VALUE;
+ }
+
+ Request.Type = CSRSS_DUPLICATE_HANDLE;
+ Request.Data.DuplicateHandleRequest.Handle = hConsole;
+ Request.Data.DuplicateHandleRequest.ProcessId = GetCurrentProcessId();
+ Status = CsrClientCallServer(&Request,
+ &Reply,
+ sizeof(CSRSS_API_REQUEST),
+ sizeof(CSRSS_API_REPLY));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status=Reply.Status))
+ {
+ SetLastErrorByStatus(Status);
+ return INVALID_HANDLE_VALUE;
+ }
+ return Reply.Data.DuplicateHandleReply.Handle;
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
ExpungeConsoleCommandHistoryW (DWORD Unknown0)
/*
}
+/*
+ * @unimplemented
+ */
DWORD STDCALL
ExpungeConsoleCommandHistoryA (DWORD Unknown0)
/*
return 0;
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
GetConsoleAliasW (DWORD Unknown0,
DWORD Unknown1,
}
+/*
+ * @unimplemented
+ */
DWORD STDCALL
GetConsoleAliasA (DWORD Unknown0,
DWORD Unknown1,
return 0;
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
GetConsoleAliasExesW (DWORD Unknown0,
DWORD Unknown1)
}
-
+/*
+ * @unimplemented
+ */
DWORD STDCALL
GetConsoleAliasExesA (DWORD Unknown0,
DWORD Unknown1)
}
-
+/*
+ * @unimplemented
+ */
DWORD STDCALL
GetConsoleAliasExesLengthA (VOID)
/*
return 0;
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
GetConsoleAliasExesLengthW (VOID)
/*
return 0;
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
GetConsoleAliasesW (DWORD Unknown0,
DWORD Unknown1,
return 0;
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
GetConsoleAliasesA (DWORD Unknown0,
DWORD Unknown1,
return 0;
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
GetConsoleAliasesLengthW (DWORD Unknown0)
/*
return 0;
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
GetConsoleAliasesLengthA (DWORD Unknown0)
/*
return 0;
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
GetConsoleCommandHistoryW (DWORD Unknown0,
DWORD Unknown1,
return 0;
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
GetConsoleCommandHistoryA (DWORD Unknown0,
DWORD Unknown1,
return 0;
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
GetConsoleCommandHistoryLengthW (DWORD Unknown0)
/*
return 0;
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
GetConsoleCommandHistoryLengthA (DWORD Unknown0)
/*
return 0;
}
+/*
+ * @unimplemented
+ */
DWORD STDCALL
GetConsoleDisplayMode (LPDWORD lpdwMode)
/*
return 0;
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
GetConsoleFontInfo (DWORD Unknown0,
DWORD Unknown1,
return 0;
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
GetConsoleFontSize(HANDLE hConsoleOutput,
DWORD nFont)
return 0;
}
+
+/*
+ * @implemented
+ */
DWORD STDCALL
-GetConsoleHardwareState (DWORD Unknown0,
- DWORD Unknown1,
- DWORD Unknown2)
+GetConsoleHardwareState (HANDLE hConsole,
+ DWORD Flags,
+ PDWORD State)
/*
* Undocumented
*/
{
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return 0;
+ CSRSS_API_REQUEST Request;
+ CSRSS_API_REPLY Reply;
+ NTSTATUS Status;
+
+ Request.Type = CSRSS_SETGET_CONSOLE_HW_STATE;
+ Request.Data.ConsoleHardwareStateRequest.ConsoleHandle = hConsole;
+ Request.Data.ConsoleHardwareStateRequest.SetGet = CONSOLE_HARDWARE_STATE_GET;
+
+ Status = CsrClientCallServer(& Request,
+ & Reply,
+ sizeof(CSRSS_API_REQUEST),
+ sizeof(CSRSS_API_REPLY));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ {
+ SetLastErrorByStatus(Status);
+ return FALSE;
+ }
+ *State = Reply.Data.ConsoleHardwareStateReply.State;
+ return TRUE;
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
GetConsoleInputWaitHandle (VOID)
/*
return FALSE;
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
GetCurrentConsoleFont(HANDLE hConsoleOutput,
BOOL bMaximumWindow,
return 0;
}
+
+/*
+ * @unimplemented
+ */
ULONG STDCALL
GetNumberOfConsoleFonts (VOID)
/*
return 1; /* FIXME: call csrss.exe */
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
InvalidateConsoleDIBits (DWORD Unknown0,
DWORD Unknown1)
return 0;
}
-DWORD STDCALL
-OpenConsoleW (DWORD Unknown0,
- DWORD Unknown1,
- DWORD Unknown2,
- DWORD Unknown3)
+
+/*
+ * @unimplemented
+ */
+HANDLE STDCALL
+OpenConsoleW (LPWSTR wsName,
+ DWORD dwDesiredAccess,
+ BOOL bInheritHandle,
+ DWORD dwCreationDistribution)
/*
* Undocumented
*/
{
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return 0;
+ CSRSS_API_REQUEST Request;
+ CSRSS_API_REPLY Reply;
+ PHANDLE phConsole = NULL;
+ NTSTATUS Status = STATUS_SUCCESS;
+
+
+ if(0 == _wcsicmp(wsName, L"CONIN$"))
+ {
+ Request.Type = CSRSS_GET_INPUT_HANDLE;
+ phConsole = & Reply.Data.GetInputHandleReply.InputHandle;
+ }
+ else if (0 == _wcsicmp(wsName, L"CONOUT$"))
+ {
+ Request.Type = CSRSS_GET_OUTPUT_HANDLE;
+ phConsole = & Reply.Data.GetOutputHandleReply.OutputHandle;
+ }
+ else
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return(INVALID_HANDLE_VALUE);
+ }
+ if ((GENERIC_READ|GENERIC_WRITE) != dwDesiredAccess)
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return(INVALID_HANDLE_VALUE);
+ }
+ if (OPEN_EXISTING != dwCreationDistribution)
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return(INVALID_HANDLE_VALUE);
+ }
+ Status = CsrClientCallServer(& Request,
+ & Reply,
+ sizeof(CSRSS_API_REQUEST),
+ sizeof(CSRSS_API_REPLY));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ {
+ SetLastErrorByStatus(Status);
+ return INVALID_HANDLE_VALUE;
+ }
+ return(*phConsole);
}
-WINBOOL STDCALL
+
+/*
+ * @unimplemented
+ */
+BOOL STDCALL
SetConsoleCommandHistoryMode (DWORD dwMode)
/*
* Undocumented
return FALSE;
}
-WINBOOL STDCALL
+
+/*
+ * @unimplemented
+ */
+BOOL STDCALL
SetConsoleCursor (DWORD Unknown0,
DWORD Unknown1)
/*
return FALSE;
}
-WINBOOL STDCALL
+
+/*
+ * @unimplemented
+ */
+BOOL STDCALL
SetConsoleDisplayMode (HANDLE hOut,
DWORD dwNewMode,
LPDWORD lpdwOldMode)
return FALSE;
}
-WINBOOL STDCALL
+
+/*
+ * @unimplemented
+ */
+BOOL STDCALL
SetConsoleFont (DWORD Unknown0,
DWORD Unknown1)
/*
return FALSE;
}
-WINBOOL STDCALL
-SetConsoleHardwareState (DWORD Unknown0,
- DWORD Unknown1,
- DWORD Unknown2)
+
+/*
+ * @implemented
+ */
+BOOL STDCALL
+SetConsoleHardwareState (HANDLE hConsole,
+ DWORD Flags,
+ DWORD State)
/*
* Undocumented
*/
{
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return FALSE;
+ CSRSS_API_REQUEST Request;
+ CSRSS_API_REPLY Reply;
+ NTSTATUS Status;
+
+ Request.Type = CSRSS_SETGET_CONSOLE_HW_STATE;
+ Request.Data.ConsoleHardwareStateRequest.ConsoleHandle = hConsole;
+ Request.Data.ConsoleHardwareStateRequest.SetGet = CONSOLE_HARDWARE_STATE_SET;
+ Request.Data.ConsoleHardwareStateRequest.State = State;
+
+ Status = CsrClientCallServer(& Request,
+ & Reply,
+ sizeof(CSRSS_API_REQUEST),
+ sizeof(CSRSS_API_REPLY));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ {
+ SetLastErrorByStatus(Status);
+ return FALSE;
+ }
+ return TRUE;
}
-WINBOOL STDCALL
+
+/*
+ * @unimplemented
+ */
+BOOL STDCALL
SetConsoleKeyShortcuts (DWORD Unknown0,
DWORD Unknown1,
DWORD Unknown2,
return FALSE;
}
-WINBOOL STDCALL
+
+/*
+ * @unimplemented
+ */
+BOOL STDCALL
SetConsoleMaximumWindowSize (DWORD Unknown0,
DWORD Unknown1)
/*
return FALSE;
}
-WINBOOL STDCALL
+
+/*
+ * @unimplemented
+ */
+BOOL STDCALL
SetConsoleMenuClose (DWORD Unknown0)
/*
* Undocumented
return FALSE;
}
-WINBOOL STDCALL
+
+/*
+ * @unimplemented
+ */
+BOOL STDCALL
SetConsoleNumberOfCommandsA (DWORD Unknown0,
DWORD Unknown1)
/*
return FALSE;
}
-WINBOOL STDCALL
+
+/*
+ * @unimplemented
+ */
+BOOL STDCALL
SetConsoleNumberOfCommandsW (DWORD Unknown0,
DWORD Unknown1)
/*
return FALSE;
}
-WINBOOL STDCALL
+
+/*
+ * @unimplemented
+ */
+BOOL STDCALL
SetConsolePalette (DWORD Unknown0,
DWORD Unknown1,
DWORD Unknown2)
return FALSE;
}
-WINBOOL STDCALL
+
+/*
+ * @unimplemented
+ */
+BOOL STDCALL
SetLastConsoleEventActive (VOID)
/*
* Undocumented
return FALSE;
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
ShowConsoleCursor (DWORD Unknown0,
DWORD Unknown1)
return 0;
}
-DWORD STDCALL
-VerifyConsoleIoHandle (DWORD Unknown0)
- /*
- * Undocumented
- */
+
+/*
+ * FUNCTION: Checks whether the given handle is a valid console handle.
+ * ARGUMENTS:
+ * Handle - Handle to be checked
+ * RETURNS:
+ * TRUE: Handle is a valid console handle
+ * FALSE: Handle is not a valid console handle.
+ * STATUS: Officially undocumented
+ *
+ * @implemented
+ */
+BOOL STDCALL
+VerifyConsoleIoHandle(HANDLE Handle)
{
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return 0;
+ CSRSS_API_REQUEST Request;
+ CSRSS_API_REPLY Reply;
+ NTSTATUS Status;
+
+ Request.Type = CSRSS_VERIFY_HANDLE;
+ Request.Data.VerifyHandleRequest.Handle = Handle;
+ Status = CsrClientCallServer(&Request,
+ &Reply,
+ sizeof(CSRSS_API_REQUEST),
+ sizeof(CSRSS_API_REPLY));
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastErrorByStatus(Status);
+ return FALSE;
+ }
+
+ return (BOOL)NT_SUCCESS(Reply.Status);
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
WriteConsoleInputVDMA (DWORD Unknown0,
DWORD Unknown1,
return 0;
}
+
+/*
+ * @unimplemented
+ */
DWORD STDCALL
WriteConsoleInputVDMW (DWORD Unknown0,
DWORD Unknown1,
return 0;
}
-WINBOOL STDCALL
+
+/*
+ * @implemented
+ */
+BOOL STDCALL
CloseConsoleHandle(HANDLE Handle)
/*
* Undocumented
&Reply,
sizeof(CSRSS_API_REQUEST),
sizeof(CSRSS_API_REPLY));
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastErrorByStatus(Status);
+ return FALSE;
+ }
- if (NT_SUCCESS(Status))
- {
- return TRUE;
- }
- else
- {
- SetLastErrorByStatus(Status);
- return FALSE;
- }
+ return TRUE;
}
-BOOLEAN STDCALL
+
+/*
+ * internal function
+ */
+BOOL STDCALL
IsConsoleHandle(HANDLE Handle)
{
if ((((ULONG)Handle) & 0x10000003) == 0x3)
return(FALSE);
}
-HANDLE STDCALL
+
+/*
+ * @implemented
+ */
+HANDLE STDCALL
GetStdHandle(DWORD nStdHandle)
/*
* FUNCTION: Get a handle for the standard input, standard output
*/
{
PRTL_USER_PROCESS_PARAMETERS Ppb;
-
- Ppb = NtCurrentPeb()->ProcessParameters;
+
+ Ppb = NtCurrentPeb()->ProcessParameters;
switch (nStdHandle)
{
- case STD_INPUT_HANDLE: return Ppb->hStdInput;
- case STD_OUTPUT_HANDLE: return Ppb->hStdOutput;
- case STD_ERROR_HANDLE: return Ppb->hStdError;
+ case STD_INPUT_HANDLE:
+ return Ppb->hStdInput;
+
+ case STD_OUTPUT_HANDLE:
+ return Ppb->hStdOutput;
+
+ case STD_ERROR_HANDLE:
+ return Ppb->hStdError;
}
+
SetLastError (ERROR_INVALID_PARAMETER);
return INVALID_HANDLE_VALUE;
}
-WINBASEAPI BOOL WINAPI
+
+/*
+ * @implemented
+ */
+BOOL WINAPI
SetStdHandle(DWORD nStdHandle,
HANDLE hHandle)
/*
*/
{
PRTL_USER_PROCESS_PARAMETERS Ppb;
-
+
+ /* no need to check if hHandle == INVALID_HANDLE_VALUE */
+
Ppb = NtCurrentPeb()->ProcessParameters;
-
- /* More checking needed? */
- if (hHandle == INVALID_HANDLE_VALUE)
- {
- SetLastError (ERROR_INVALID_HANDLE);
- return FALSE;
- }
-
- SetLastError(ERROR_SUCCESS); /* OK */
+
switch (nStdHandle)
{
- case STD_INPUT_HANDLE:
- Ppb->hStdInput = hHandle;
- return TRUE;
- case STD_OUTPUT_HANDLE:
- Ppb->hStdOutput = hHandle;
- return TRUE;
- case STD_ERROR_HANDLE:
- Ppb->hStdError = hHandle;
- return TRUE;
+ case STD_INPUT_HANDLE:
+ Ppb->hStdInput = hHandle;
+ return TRUE;
+
+ case STD_OUTPUT_HANDLE:
+ Ppb->hStdOutput = hHandle;
+ return TRUE;
+
+ case STD_ERROR_HANDLE:
+ Ppb->hStdError = hHandle;
+ return TRUE;
}
- SetLastError (ERROR_INVALID_PARAMETER);
+
+ /* windows for whatever reason sets the last error to ERROR_INVALID_HANDLE here */
+ SetLastError (ERROR_INVALID_HANDLE);
return FALSE;
}
/*--------------------------------------------------------------
* WriteConsoleA
+ *
+ * @implemented
*/
-WINBOOL STDCALL
+BOOL STDCALL
WriteConsoleA(HANDLE hConsoleOutput,
CONST VOID *lpBuffer,
DWORD nNumberOfCharsToWrite,
NTSTATUS Status;
USHORT Size;
ULONG MessageSize;
-
- Request = RtlAllocateHeap(GetProcessHeap(),
- HEAP_ZERO_MEMORY,
- sizeof(CSRSS_API_REQUEST) +
- CSRSS_MAX_WRITE_CONSOLE_REQUEST);
+
+ Request = RtlAllocateHeap(GetProcessHeap(), 0,
+ sizeof(CSRSS_API_REQUEST) +
+ min(nNumberOfCharsToWrite,
+ CSRSS_MAX_WRITE_CONSOLE_REQUEST));
if (Request == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
return(FALSE);
}
-
+
Request->Type = CSRSS_WRITE_CONSOLE;
Request->Data.WriteConsoleRequest.ConsoleHandle = hConsoleOutput;
if (lpNumberOfCharsWritten != NULL)
Size = nNumberOfCharsToWrite;
}
Request->Data.WriteConsoleRequest.NrCharactersToWrite = Size;
-
+
memcpy(Request->Data.WriteConsoleRequest.Buffer, lpBuffer, Size);
MessageSize = CSRSS_REQUEST_HEADER_SIZE +
&Reply,
MessageSize,
sizeof(CSRSS_API_REPLY));
-
+
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
{
RtlFreeHeap(GetProcessHeap(), 0, Request);
nNumberOfCharsToWrite -= Size;
lpBuffer += Size;
}
+
RtlFreeHeap(GetProcessHeap(), 0, Request);
+
return TRUE;
}
/*--------------------------------------------------------------
* ReadConsoleA
+ *
+ * @implemented
*/
-WINBOOL STDCALL ReadConsoleA(HANDLE hConsoleInput,
+BOOL STDCALL ReadConsoleA(HANDLE hConsoleInput,
LPVOID lpBuffer,
DWORD nNumberOfCharsToRead,
LPDWORD lpNumberOfCharsRead,
NTSTATUS Status;
ULONG CharsRead = 0;
- Reply = RtlAllocateHeap(GetProcessHeap(),
- HEAP_ZERO_MEMORY,
- sizeof(CSRSS_API_REPLY) + nNumberOfCharsToRead);
+ Reply = RtlAllocateHeap(GetProcessHeap(), 0,
+ sizeof(CSRSS_API_REPLY) + nNumberOfCharsToRead);
if (Reply == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
/*--------------------------------------------------------------
* AllocConsole
+ *
+ * @implemented
*/
-WINBOOL STDCALL AllocConsole(VOID)
+BOOL STDCALL AllocConsole(VOID)
{
CSRSS_API_REQUEST Request;
CSRSS_API_REPLY Reply;
NTSTATUS Status;
+ HANDLE hStdError;
+
+ if(NtCurrentPeb()->ProcessParameters->hConsole)
+ {
+ DPRINT("AllocConsole: Allocate duplicate console to the same Process\n");
+ SetLastErrorByStatus (STATUS_OBJECT_NAME_EXISTS);
+ return FALSE;
+ }
+
+ Request.Data.AllocConsoleRequest.CtrlDispatcher = (PCONTROLDISPATCHER) &ConsoleControlDispatcher;
Request.Type = CSRSS_ALLOC_CONSOLE;
Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
SetLastErrorByStatus ( Status );
return FALSE;
}
+ NtCurrentPeb()->ProcessParameters->hConsole = Reply.Data.AllocConsoleReply.Console;
SetStdHandle( STD_INPUT_HANDLE, Reply.Data.AllocConsoleReply.InputHandle );
SetStdHandle( STD_OUTPUT_HANDLE, Reply.Data.AllocConsoleReply.OutputHandle );
- SetStdHandle( STD_ERROR_HANDLE, Reply.Data.AllocConsoleReply.OutputHandle );
+ hStdError = DuplicateConsoleHandle(Reply.Data.AllocConsoleReply.OutputHandle,
+ 0,
+ TRUE,
+ DUPLICATE_SAME_ACCESS);
+ SetStdHandle( STD_ERROR_HANDLE, hStdError );
return TRUE;
}
/*--------------------------------------------------------------
* FreeConsole
+ *
+ * @implemented
*/
-WINBOOL STDCALL FreeConsole(VOID)
+BOOL STDCALL FreeConsole(VOID)
{
- DbgPrint("FreeConsole() is unimplemented\n");
- return FALSE;
+ // AG: I'm not sure if this is correct (what happens to std handles?)
+ // but I just tried to reverse what AllocConsole() does...
+
+ CSRSS_API_REQUEST Request;
+ CSRSS_API_REPLY Reply;
+ NTSTATUS Status;
+
+ Request.Type = CSRSS_FREE_CONSOLE;
+ Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
+ if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
+ {
+ SetLastErrorByStatus ( Status );
+ return FALSE;
+ }
+
+ return TRUE;
}
/*--------------------------------------------------------------
* GetConsoleScreenBufferInfo
+ *
+ * @implemented
*/
-WINBOOL
+BOOL
STDCALL
GetConsoleScreenBufferInfo(
HANDLE hConsoleOutput,
/*--------------------------------------------------------------
* SetConsoleCursorPosition
+ *
+ * @implemented
*/
-WINBOOL
+BOOL
STDCALL
SetConsoleCursorPosition(
HANDLE hConsoleOutput,
/*--------------------------------------------------------------
* FillConsoleOutputCharacterA
+ *
+ * @implemented
*/
-WINBOOL STDCALL
+BOOL STDCALL
FillConsoleOutputCharacterA(
HANDLE hConsoleOutput,
CHAR cCharacter,
/*--------------------------------------------------------------
* FillConsoleOutputCharacterW
+ *
+ * @unimplemented
*/
-WINBOOL
+BOOL
STDCALL
FillConsoleOutputCharacterW(
HANDLE hConsoleOutput,
)
{
/* TO DO */
+ DbgPrint("%s unimplemented\n", __FUNCTION__);
return FALSE;
}
/*--------------------------------------------------------------
- * PeekConsoleInputA
+ * IntPeekConsoleInput
+ *
+ * INTERNAL
*/
-WINBASEAPI
BOOL
WINAPI
-PeekConsoleInputA(
+IntPeekConsoleInput(
HANDLE hConsoleInput,
PINPUT_RECORD lpBuffer,
DWORD nLength,
- LPDWORD lpNumberOfEventsRead
+ LPDWORD lpNumberOfEventsRead,
+ BOOL bUnicode
)
{
PCSRSS_API_REQUEST Request;
Request->Type = CSRSS_PEEK_CONSOLE_INPUT;
Request->Data.PeekConsoleInputRequest.ConsoleHandle = hConsoleInput;
+ Request->Data.PeekConsoleInputRequest.Unicode = bUnicode;
Request->Data.PeekConsoleInputRequest.Length = nLength;
Request->Data.PeekConsoleInputRequest.InputRecord = (INPUT_RECORD*)BufferTargetBase;
RtlFreeHeap(GetProcessHeap(), 0, Request);
CsrReleaseParameterBuffer(BufferBase);
- return TRUE;
+ return TRUE;
+}
+
+/*--------------------------------------------------------------
+ * PeekConsoleInputA
+ *
+ * @implemented
+ */
+BOOL
+WINAPI
+PeekConsoleInputA(
+ HANDLE hConsoleInput,
+ PINPUT_RECORD lpBuffer,
+ DWORD nLength,
+ LPDWORD lpNumberOfEventsRead
+ )
+{
+ return IntPeekConsoleInput(hConsoleInput, lpBuffer, nLength,
+ lpNumberOfEventsRead, FALSE);
}
/*--------------------------------------------------------------
* PeekConsoleInputW
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
PeekConsoleInputW(
LPDWORD lpNumberOfEventsRead
)
{
-/* TO DO */
- return FALSE;
+ return IntPeekConsoleInput(hConsoleInput, lpBuffer, nLength,
+ lpNumberOfEventsRead, TRUE);
}
/*--------------------------------------------------------------
- * ReadConsoleInputA
+ * IntReadConsoleInput
+ *
+ * INTERNAL
*/
-WINBASEAPI BOOL WINAPI
-ReadConsoleInputA(HANDLE hConsoleInput,
- PINPUT_RECORD lpBuffer,
- DWORD nLength,
- LPDWORD lpNumberOfEventsRead)
+BOOL WINAPI
+IntReadConsoleInput(HANDLE hConsoleInput,
+ PINPUT_RECORD lpBuffer,
+ DWORD nLength,
+ LPDWORD lpNumberOfEventsRead,
+ BOOL bUnicode)
{
CSRSS_API_REQUEST Request;
CSRSS_API_REPLY Reply;
Request.Type = CSRSS_READ_INPUT;
Request.Data.ReadInputRequest.ConsoleHandle = hConsoleInput;
+ Request.Data.ReadInputRequest.Unicode = bUnicode;
Status = CsrClientCallServer(&Request, &Reply, sizeof(CSRSS_API_REQUEST),
sizeof(CSRSS_API_REPLY));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
}
}
- NumEventsRead = 0;
+ NumEventsRead = 1;
*lpBuffer = Reply.Data.ReadInputReply.Input;
lpBuffer++;
- NumEventsRead++;
while ((NumEventsRead < nLength) && (Reply.Data.ReadInputReply.MoreEvents))
{
}
+/*--------------------------------------------------------------
+ * ReadConsoleInputA
+ *
+ * @implemented
+ */
+BOOL WINAPI
+ReadConsoleInputA(HANDLE hConsoleInput,
+ PINPUT_RECORD lpBuffer,
+ DWORD nLength,
+ LPDWORD lpNumberOfEventsRead)
+{
+ return IntReadConsoleInput(hConsoleInput, lpBuffer, nLength,
+ lpNumberOfEventsRead, FALSE);
+}
+
+
/*--------------------------------------------------------------
* ReadConsoleInputW
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
ReadConsoleInputW(
LPDWORD lpNumberOfEventsRead
)
{
-/* TO DO */
- return FALSE;
+ return IntReadConsoleInput(hConsoleInput, lpBuffer, nLength,
+ lpNumberOfEventsRead, TRUE);
}
/*--------------------------------------------------------------
* WriteConsoleInputA
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
WriteConsoleInputA(
/*--------------------------------------------------------------
* WriteConsoleInputW
+ *
+ * @unimplemented
*/
-WINBASEAPI
BOOL
WINAPI
WriteConsoleInputW(
)
{
/* TO DO */
+ DbgPrint("%s unimplemented\n", __FUNCTION__);
return FALSE;
}
/*--------------------------------------------------------------
- * ReadConsoleOutputA
+ * IntReadConsoleOutput
+ *
+ * INTERNAL
*/
-WINBASEAPI
BOOL
WINAPI
-ReadConsoleOutputA(
- HANDLE hConsoleOutput,
- PCHAR_INFO lpBuffer,
- COORD dwBufferSize,
- COORD dwBufferCoord,
- PSMALL_RECT lpReadRegion
+IntReadConsoleOutput(
+ HANDLE hConsoleOutput,
+ PCHAR_INFO lpBuffer,
+ COORD dwBufferSize,
+ COORD dwBufferCoord,
+ PSMALL_RECT lpReadRegion,
+ BOOL bUnicode
)
{
PCSRSS_API_REQUEST Request;
Request->Type = CSRSS_READ_CONSOLE_OUTPUT;
Request->Data.ReadConsoleOutputRequest.ConsoleHandle = hConsoleOutput;
+ Request->Data.ReadConsoleOutputRequest.Unicode = bUnicode;
Request->Data.ReadConsoleOutputRequest.BufferSize = dwBufferSize;
Request->Data.ReadConsoleOutputRequest.BufferCoord = dwBufferCoord;
Request->Data.ReadConsoleOutputRequest.ReadRegion = *lpReadRegion;
return TRUE;
}
+/*--------------------------------------------------------------
+ * ReadConsoleOutputA
+ *
+ * @implemented
+ */
+BOOL
+WINAPI
+ReadConsoleOutputA(
+ HANDLE hConsoleOutput,
+ PCHAR_INFO lpBuffer,
+ COORD dwBufferSize,
+ COORD dwBufferCoord,
+ PSMALL_RECT lpReadRegion
+ )
+{
+ return IntReadConsoleOutput(hConsoleOutput, lpBuffer, dwBufferSize,
+ dwBufferCoord, lpReadRegion, FALSE);
+}
+
/*--------------------------------------------------------------
* ReadConsoleOutputW
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
ReadConsoleOutputW(
PSMALL_RECT lpReadRegion
)
{
-/* TO DO */
- return FALSE;
+ return IntReadConsoleOutput(hConsoleOutput, lpBuffer, dwBufferSize,
+ dwBufferCoord, lpReadRegion, TRUE);
}
+
/*--------------------------------------------------------------
- * WriteConsoleOutputA
+ * IntWriteConsoleOutput
+ *
+ * INTERNAL
*/
-WINBASEAPI BOOL WINAPI
-WriteConsoleOutputA(HANDLE hConsoleOutput,
- CONST CHAR_INFO *lpBuffer,
- COORD dwBufferSize,
- COORD dwBufferCoord,
- PSMALL_RECT lpWriteRegion)
+BOOL WINAPI
+IntWriteConsoleOutput(HANDLE hConsoleOutput,
+ CONST CHAR_INFO *lpBuffer,
+ COORD dwBufferSize,
+ COORD dwBufferCoord,
+ PSMALL_RECT lpWriteRegion,
+ BOOL bUnicode)
{
PCSRSS_API_REQUEST Request;
CSRSS_API_REPLY Reply;
NTSTATUS Status;
ULONG Size;
- BOOLEAN Result;
- ULONG i, j;
PVOID BufferBase;
PVOID BufferTargetBase;
}
Request->Type = CSRSS_WRITE_CONSOLE_OUTPUT;
Request->Data.WriteConsoleOutputRequest.ConsoleHandle = hConsoleOutput;
+ Request->Data.WriteConsoleOutputRequest.Unicode = bUnicode;
Request->Data.WriteConsoleOutputRequest.BufferSize = dwBufferSize;
Request->Data.WriteConsoleOutputRequest.BufferCoord = dwBufferCoord;
Request->Data.WriteConsoleOutputRequest.WriteRegion = *lpWriteRegion;
return(TRUE);
}
+/*--------------------------------------------------------------
+ * WriteConsoleOutputA
+ *
+ * @implemented
+ */
+BOOL WINAPI
+WriteConsoleOutputA(HANDLE hConsoleOutput,
+ CONST CHAR_INFO *lpBuffer,
+ COORD dwBufferSize,
+ COORD dwBufferCoord,
+ PSMALL_RECT lpWriteRegion)
+{
+ return IntWriteConsoleOutput(hConsoleOutput, lpBuffer, dwBufferSize,
+ dwBufferCoord, lpWriteRegion, FALSE);
+}
+
/*--------------------------------------------------------------
* WriteConsoleOutputW
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
WriteConsoleOutputW(
PSMALL_RECT lpWriteRegion
)
{
-/* TO DO */
- return FALSE;
+ return IntWriteConsoleOutput(hConsoleOutput, lpBuffer, dwBufferSize,
+ dwBufferCoord, lpWriteRegion, TRUE);
}
/*--------------------------------------------------------------
* ReadConsoleOutputCharacterA
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
ReadConsoleOutputCharacterA(
NTSTATUS Status;
DWORD Size;
- Reply = RtlAllocateHeap(GetProcessHeap(),
- HEAP_ZERO_MEMORY,
- sizeof(CSRSS_API_REPLY) + CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR);
+ Reply = RtlAllocateHeap(GetProcessHeap(), 0,
+ sizeof(CSRSS_API_REPLY) +
+ min(nLength, CSRSS_MAX_READ_CONSOLE_OUTPUT_CHAR));
if (Reply == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
/*--------------------------------------------------------------
* ReadConsoleOutputCharacterW
+ *
+ * @unimplemented
*/
-WINBASEAPI
BOOL
WINAPI
ReadConsoleOutputCharacterW(
)
{
/* TO DO */
+ DbgPrint("%s unimplemented\n", __FUNCTION__);
return FALSE;
}
/*--------------------------------------------------------------
* ReadConsoleOutputAttribute
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
ReadConsoleOutputAttribute(
NTSTATUS Status;
DWORD Size, i;
- Reply = RtlAllocateHeap(GetProcessHeap(),
- HEAP_ZERO_MEMORY,
- sizeof(CSRSS_API_REPLY) + CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB);
+ Reply = RtlAllocateHeap(GetProcessHeap(), 0,
+ sizeof(CSRSS_API_REPLY) +
+ min(nLength, CSRSS_MAX_READ_CONSOLE_OUTPUT_ATTRIB));
if (Reply == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
/*--------------------------------------------------------------
* WriteConsoleOutputCharacterA
+ *
+ * @implemented
*/
-WINBASEAPI BOOL WINAPI
+BOOL WINAPI
WriteConsoleOutputCharacterA(HANDLE hConsoleOutput,
LPCSTR lpCharacter,
DWORD nLength,
CSRSS_API_REPLY Reply;
NTSTATUS Status;
WORD Size;
-
- Request = RtlAllocateHeap(GetProcessHeap(),
- HEAP_ZERO_MEMORY,
- sizeof(CSRSS_API_REQUEST) + CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR);
+
+ Request = RtlAllocateHeap(GetProcessHeap(), 0,
+ sizeof(CSRSS_API_REQUEST) +
+ min(nLength, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR));
if( !Request )
{
SetLastError( ERROR_OUTOFMEMORY );
/*--------------------------------------------------------------
* WriteConsoleOutputCharacterW
+ *
+ * @implemented
*/
-WINBASEAPI
-BOOL
-WINAPI
-WriteConsoleOutputCharacterW(
- HANDLE hConsoleOutput,
- LPCWSTR lpCharacter,
- DWORD nLength,
- COORD dwWriteCoord,
- LPDWORD lpNumberOfCharsWritten
- )
+BOOL WINAPI
+WriteConsoleOutputCharacterW(HANDLE hConsoleOutput,
+ LPCWSTR lpCharacter,
+ DWORD nLength,
+ COORD dwWriteCoord,
+ LPDWORD lpNumberOfCharsWritten)
{
-/* TO DO */
- return FALSE;
-}
+ PCSRSS_API_REQUEST Request;
+ CSRSS_API_REPLY Reply;
+ NTSTATUS Status;
+ WORD Size;
+
+ Request = RtlAllocateHeap(GetProcessHeap(), 0,
+ sizeof(CSRSS_API_REQUEST) +
+ min(nLength, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR));
+ if( !Request )
+ {
+ SetLastError( ERROR_OUTOFMEMORY );
+ return FALSE;
+ }
+ Request->Type = CSRSS_WRITE_CONSOLE_OUTPUT_CHAR;
+ Request->Data.WriteConsoleOutputCharRequest.ConsoleHandle = hConsoleOutput;
+ Request->Data.WriteConsoleOutputCharRequest.Coord = dwWriteCoord;
+ if( lpNumberOfCharsWritten )
+ *lpNumberOfCharsWritten = nLength;
+ while( nLength )
+ {
+ Size = nLength > CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR ? CSRSS_MAX_WRITE_CONSOLE_OUTPUT_CHAR : nLength;
+ Request->Data.WriteConsoleOutputCharRequest.Length = Size;
+ Status = RtlUnicodeToOemN (&Request->Data.WriteConsoleOutputCharRequest.String[0],
+ Size,
+ NULL,
+ (PWCHAR)lpCharacter,
+ Size * sizeof(WCHAR));
+ if (!NT_SUCCESS(Status))
+ {
+ RtlFreeHeap (GetProcessHeap(), 0, Request);
+ SetLastErrorByStatus (Status);
+ return FALSE;
+ }
+ Status = CsrClientCallServer( Request, &Reply, sizeof( CSRSS_API_REQUEST ) + Size, sizeof( CSRSS_API_REPLY ) );
+ if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
+ {
+ RtlFreeHeap( GetProcessHeap(), 0, Request );
+ SetLastErrorByStatus ( Status );
+ return FALSE;
+ }
+ nLength -= Size;
+ lpCharacter += Size;
+ Request->Data.WriteConsoleOutputCharRequest.Coord = Reply.Data.WriteConsoleOutputCharReply.EndCoord;
+ }
+
+ RtlFreeHeap( GetProcessHeap(), 0, Request );
+ return TRUE;
+}
/*--------------------------------------------------------------
* WriteConsoleOutputAttribute
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
WriteConsoleOutputAttribute(
WORD Size;
int c;
- Request = RtlAllocateHeap(GetProcessHeap(),
- HEAP_ZERO_MEMORY,
- sizeof(CSRSS_API_REQUEST) + CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB);
+ Request = RtlAllocateHeap(GetProcessHeap(), 0,
+ sizeof(CSRSS_API_REQUEST) +
+ min(nLength, CSRSS_MAX_WRITE_CONSOLE_OUTPUT_ATTRIB));
if( !Request )
{
SetLastError( ERROR_OUTOFMEMORY );
/*--------------------------------------------------------------
* FillConsoleOutputAttribute
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
FillConsoleOutputAttribute(
/*--------------------------------------------------------------
* GetConsoleMode
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
GetConsoleMode(
CSRSS_API_REPLY Reply;
NTSTATUS Status;
- Request.Type = CSRSS_GET_MODE;
+ Request.Type = CSRSS_GET_CONSOLE_MODE;
Request.Data.GetConsoleModeRequest.ConsoleHandle = hConsoleHandle;
Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
/*--------------------------------------------------------------
* GetNumberOfConsoleInputEvents
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
GetNumberOfConsoleInputEvents(
/*--------------------------------------------------------------
* GetLargestConsoleWindowSize
+ *
+ * @unimplemented
*/
-WINBASEAPI
COORD
WINAPI
GetLargestConsoleWindowSize(
/*--------------------------------------------------------------
* GetConsoleCursorInfo
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
GetConsoleCursorInfo(
/*--------------------------------------------------------------
* GetNumberOfConsoleMouseButtons
+ *
+ * @unimplemented
*/
-WINBASEAPI
BOOL
WINAPI
GetNumberOfConsoleMouseButtons(
/*--------------------------------------------------------------
* SetConsoleMode
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
SetConsoleMode(
CSRSS_API_REPLY Reply;
NTSTATUS Status;
- Request.Type = CSRSS_SET_MODE;
+ Request.Type = CSRSS_SET_CONSOLE_MODE;
Request.Data.SetConsoleModeRequest.ConsoleHandle = hConsoleHandle;
Request.Data.SetConsoleModeRequest.Mode = dwMode;
Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
/*--------------------------------------------------------------
* SetConsoleActiveScreenBuffer
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
SetConsoleActiveScreenBuffer(
NTSTATUS Status;
Request.Type = CSRSS_SET_SCREEN_BUFFER;
- Request.Data.SetActiveScreenBufferRequest.OutputHandle = hConsoleOutput;
+ Request.Data.SetScreenBufferRequest.OutputHandle = hConsoleOutput;
Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
if( !NT_SUCCESS( Status ) || !NT_SUCCESS( Status = Reply.Status ) )
{
/*--------------------------------------------------------------
* FlushConsoleInputBuffer
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
FlushConsoleInputBuffer(
/*--------------------------------------------------------------
* SetConsoleScreenBufferSize
+ *
+ * @unimplemented
*/
-WINBASEAPI
BOOL
WINAPI
SetConsoleScreenBufferSize(
)
{
/* TO DO */
+ DbgPrint("%s unimplemented\n", __FUNCTION__);
return FALSE;
}
/*--------------------------------------------------------------
* SetConsoleCursorInfo
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
SetConsoleCursorInfo(
/*--------------------------------------------------------------
* ScrollConsoleScreenBufferA
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
ScrollConsoleScreenBufferA(
/*--------------------------------------------------------------
* ScrollConsoleScreenBufferW
+ *
+ * @unimplemented
*/
-WINBASEAPI
BOOL
WINAPI
ScrollConsoleScreenBufferW(
)
{
/* TO DO */
+ DbgPrint("%s unimplemented\n", __FUNCTION__);
return FALSE;
}
/*--------------------------------------------------------------
* SetConsoleWindowInfo
+ *
+ * @unimplemented
*/
-WINBASEAPI
BOOL
WINAPI
SetConsoleWindowInfo(
)
{
/* TO DO */
+ DbgPrint("%s unimplemented\n", __FUNCTION__);
return FALSE;
}
/*--------------------------------------------------------------
* SetConsoleTextAttribute
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
SetConsoleTextAttribute(
return TRUE;
}
+
BOOL STATIC
AddConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine)
{
else
{
NrCtrlHandlers++;
- CtrlHandlers =
- RtlReAllocateHeap(RtlGetProcessHeap(),
- HEAP_ZERO_MEMORY,
- (PVOID)CtrlHandlers,
- NrCtrlHandlers * sizeof(PHANDLER_ROUTINE));
+ if (CtrlHandlers == NULL)
+ {
+ CtrlHandlers = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY,
+ NrCtrlHandlers * sizeof(PHANDLER_ROUTINE));
+ }
+ else
+ {
+ CtrlHandlers = RtlReAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY,
+ (PVOID)CtrlHandlers,
+ NrCtrlHandlers * sizeof(PHANDLER_ROUTINE));
+ }
if (CtrlHandlers == NULL)
{
+ NrCtrlHandlers = 0;
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return(FALSE);
}
}
}
+
BOOL STATIC
RemoveConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine)
{
{
for (i = 0; i < NrCtrlHandlers; i++)
{
- if (CtrlHandlers[i] == HandlerRoutine)
+ if ( ((void*)(CtrlHandlers[i])) == (void*)HandlerRoutine)
{
- CtrlHandlers[i] = CtrlHandlers[NrCtrlHandlers - 1];
NrCtrlHandlers--;
+ memmove(CtrlHandlers + i, CtrlHandlers + i + 1,
+ (NrCtrlHandlers - i) * sizeof(PHANDLER_ROUTINE));
CtrlHandlers =
RtlReAllocateHeap(RtlGetProcessHeap(),
HEAP_ZERO_MEMORY,
return(FALSE);
}
-WINBASEAPI BOOL WINAPI
-SetConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine,
+
+/*
+ * @implemented
+ */
+BOOL WINAPI
+SetConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine,
BOOL Add)
{
BOOLEAN Ret;
/*--------------------------------------------------------------
* GenerateConsoleCtrlEvent
+ *
+ * @unimplemented
*/
-WINBASEAPI BOOL WINAPI
+BOOL WINAPI
GenerateConsoleCtrlEvent(
DWORD dwCtrlEvent,
DWORD dwProcessGroupId
/*--------------------------------------------------------------
* GetConsoleTitleW
+ *
+ * @implemented
*/
-#define MAX_CONSOLE_TITLE_LENGTH 80
-
-WINBASEAPI
DWORD
WINAPI
GetConsoleTitleW(
DWORD nSize
)
{
- union {
- CSRSS_API_REQUEST quest;
- CSRSS_API_REPLY ply;
- } Re;
- NTSTATUS Status;
-
- /* Marshall data */
- Re.quest.Type = CSRSS_GET_TITLE;
- Re.quest.Data.GetTitleRequest.ConsoleHandle =
- GetStdHandle (STD_INPUT_HANDLE);
-
- /* Call CSRSS */
- Status = CsrClientCallServer (
- & Re.quest,
- & Re.ply,
- (sizeof (CSRSS_GET_TITLE_REQUEST) +
- sizeof (LPC_MESSAGE) +
- sizeof (ULONG)),
- sizeof (CSRSS_API_REPLY)
- );
- if ( !NT_SUCCESS(Status)
- || !NT_SUCCESS (Status = Re.ply.Status)
- )
- {
- SetLastErrorByStatus (Status);
- return (0);
- }
+ CSRSS_API_REQUEST Request;
+ PCSRSS_API_REPLY Reply;
+ NTSTATUS Status;
+ HANDLE hConsole;
- /* Convert size in characters to size in bytes */
- nSize = sizeof (WCHAR) * nSize;
+ hConsole = CreateFileW(L"CONIN$", GENERIC_READ, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+ if (hConsole == INVALID_HANDLE_VALUE)
+ {
+ return 0;
+ }
- /* Unmarshall data */
- if (nSize < Re.ply.Data.GetTitleReply.Length)
- {
- DbgPrint ("%s: ret=%d\n", __FUNCTION__, Re.ply.Data.GetTitleReply.Length);
- nSize /= sizeof (WCHAR);
- if (nSize > 1)
- {
- wcsncpy (
- lpConsoleTitle,
- Re.ply.Data.GetTitleReply.Title,
- (nSize - 1)
- );
- /* Add null */
- lpConsoleTitle [nSize --] = L'\0';
- }
- }
- else
- {
- nSize = Re.ply.Data.GetTitleReply.Length / sizeof (WCHAR);
- wcscpy (lpConsoleTitle, Re.ply.Data.GetTitleReply.Title);
- }
+ Reply = RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CSRSS_API_REPLY) + CSRSS_MAX_TITLE_LENGTH * sizeof(WCHAR));
+ if(Reply == NULL)
+ {
+ CloseHandle(hConsole);
+ SetLastError(ERROR_OUTOFMEMORY);
+ return 0;
+ }
- return nSize;
+ Request.Type = CSRSS_GET_TITLE;
+ Request.Data.GetTitleRequest.ConsoleHandle = hConsole;
+
+ Status = CsrClientCallServer(&Request, Reply, sizeof(CSRSS_API_REQUEST), sizeof(CSRSS_API_REPLY) + CSRSS_MAX_TITLE_LENGTH * sizeof(WCHAR));
+ CloseHandle(hConsole);
+ if(!NT_SUCCESS(Status) || !(NT_SUCCESS(Status = Reply->Status)))
+ {
+ SetLastErrorByStatus(Status);
+ RtlFreeHeap(GetProcessHeap(), 0, Reply);
+ return 0;
+ }
+
+ if(nSize * sizeof(WCHAR) < Reply->Data.GetTitleReply.Length)
+ {
+ wcsncpy(lpConsoleTitle, Reply->Data.GetTitleReply.Title, nSize - 1);
+ lpConsoleTitle[nSize--] = L'\0';
+ }
+ else
+ {
+ nSize = Reply->Data.GetTitleReply.Length / sizeof (WCHAR);
+ wcscpy(lpConsoleTitle, Reply->Data.GetTitleReply.Title);
+ lpConsoleTitle[nSize] = L'\0';
+ }
+
+ RtlFreeHeap(GetProcessHeap(), 0, Reply);
+ return nSize;
}
* GetConsoleTitleA
*
* 19990306 EA
+ *
+ * @implemented
*/
-WINBASEAPI
DWORD
WINAPI
GetConsoleTitleA(
DWORD nSize
)
{
- wchar_t WideTitle [MAX_CONSOLE_TITLE_LENGTH];
+ wchar_t WideTitle [CSRSS_MAX_TITLE_LENGTH];
DWORD nWideTitle = sizeof WideTitle;
-// DWORD nWritten;
+ DWORD nWritten;
if (!lpConsoleTitle || !nSize) return 0;
nWideTitle = GetConsoleTitleW( (LPWSTR) WideTitle, nWideTitle );
if (!nWideTitle) return 0;
-#if 0
+
if ( (nWritten = WideCharToMultiByte(
CP_ACP, // ANSI code page
0, // performance and mapping flags
lpConsoleTitle[nWritten] = '\0';
return nWritten;
}
-#endif
+
return 0;
}
/*--------------------------------------------------------------
* SetConsoleTitleW
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
SetConsoleTitleW(
CSRSS_API_REPLY Reply;
NTSTATUS Status;
unsigned int c;
+ HANDLE hConsole;
+
+ hConsole = CreateFileW(L"CONIN$", GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+ if (hConsole == INVALID_HANDLE_VALUE)
+ {
+ return FALSE;
+ }
Request = RtlAllocateHeap(GetProcessHeap(),
HEAP_ZERO_MEMORY,
sizeof(CSRSS_API_REQUEST) + CSRSS_MAX_SET_TITLE_REQUEST);
if (Request == NULL)
{
+ CloseHandle(hConsole);
SetLastError(ERROR_OUTOFMEMORY);
return(FALSE);
}
Request->Type = CSRSS_SET_TITLE;
- Request->Data.SetTitleRequest.Console = GetStdHandle( STD_INPUT_HANDLE );
+ Request->Data.SetTitleRequest.Console = hConsole;
for( c = 0; lpConsoleTitle[c] && c < CSRSS_MAX_TITLE_LENGTH; c++ )
Request->Data.SetTitleRequest.Title[c] = lpConsoleTitle[c];
Request->Data.SetTitleRequest.Length = c;
Status = CsrClientCallServer(Request,
&Reply,
- sizeof(CSRSS_SET_TITLE_REQUEST) +
- c +
- sizeof( LPC_MESSAGE ) +
- sizeof( ULONG ),
+ sizeof(CSRSS_API_REQUEST) +
+ c * sizeof(WCHAR),
sizeof(CSRSS_API_REPLY));
-
+ CloseHandle(hConsole);
if (!NT_SUCCESS(Status) || !NT_SUCCESS( Status = Reply.Status ) )
{
RtlFreeHeap( GetProcessHeap(), 0, Request );
* SetConsoleTitleA
*
* 19990204 EA Added
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
SetConsoleTitleA(
CSRSS_API_REPLY Reply;
NTSTATUS Status;
unsigned int c;
+ HANDLE hConsole;
+
+ hConsole = CreateFileW(L"CONIN$", GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+ if (hConsole == INVALID_HANDLE_VALUE)
+ {
+ return FALSE;
+ }
Request = RtlAllocateHeap(GetProcessHeap(),
HEAP_ZERO_MEMORY,
sizeof(CSRSS_API_REQUEST) + CSRSS_MAX_SET_TITLE_REQUEST);
if (Request == NULL)
{
+ CloseHandle(hConsole);
SetLastError(ERROR_OUTOFMEMORY);
return(FALSE);
}
Request->Type = CSRSS_SET_TITLE;
- Request->Data.SetTitleRequest.Console = GetStdHandle( STD_INPUT_HANDLE );
+ Request->Data.SetTitleRequest.Console = hConsole;
for( c = 0; lpConsoleTitle[c] && c < CSRSS_MAX_TITLE_LENGTH; c++ )
Request->Data.SetTitleRequest.Title[c] = lpConsoleTitle[c];
Request->Data.SetTitleRequest.Length = c;
Status = CsrClientCallServer(Request,
&Reply,
- sizeof(CSRSS_SET_TITLE_REQUEST) +
- c +
- sizeof( LPC_MESSAGE ) +
- sizeof( ULONG ),
+ sizeof(CSRSS_API_REQUEST) +
+ c * sizeof(WCHAR),
sizeof(CSRSS_API_REPLY));
-
+ CloseHandle(hConsole);
if (!NT_SUCCESS(Status) || !NT_SUCCESS( Status = Reply.Status ) )
{
RtlFreeHeap( GetProcessHeap(), 0, Request );
/*--------------------------------------------------------------
* ReadConsoleW
+ *
+ * @unimplemented
*/
-WINBASEAPI
BOOL
WINAPI
ReadConsoleW(
)
{
/* --- TO DO --- */
+ DbgPrint("%s unimplemented\n", __FUNCTION__);
return FALSE;
}
/*--------------------------------------------------------------
* WriteConsoleW
+ *
+ * @unimplemented
*/
-WINBASEAPI
BOOL
WINAPI
WriteConsoleW(
LPVOID lpReserved
)
{
+ DbgPrint("%s unimplemented\n", __FUNCTION__);
#if 0
PCSRSS_API_REQUEST Request;
CSRSS_API_REPLY Reply;
/*--------------------------------------------------------------
* CreateConsoleScreenBuffer
+ *
+ * @implemented
*/
-WINBASEAPI
HANDLE
WINAPI
CreateConsoleScreenBuffer(
/*--------------------------------------------------------------
* GetConsoleCP
+ *
+ * @implemented
*/
-WINBASEAPI
UINT
WINAPI
GetConsoleCP( VOID )
{
-/* --- TO DO --- */
- return CP_OEMCP; /* FIXME */
+ CSRSS_API_REQUEST Request;
+ CSRSS_API_REPLY Reply;
+ NTSTATUS Status;
+
+ Request.Type = CSRSS_GET_CONSOLE_CP;
+ Status = CsrClientCallServer(&Request, &Reply, sizeof(CSRSS_API_REQUEST),
+ sizeof(CSRSS_API_REPLY));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ {
+ SetLastErrorByStatus (Status);
+ return 0;
+ }
+ return Reply.Data.GetConsoleCodePage.CodePage;
}
/*--------------------------------------------------------------
* SetConsoleCP
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
SetConsoleCP(
UINT wCodePageID
)
{
-/* --- TO DO --- */
- return FALSE;
+ CSRSS_API_REQUEST Request;
+ CSRSS_API_REPLY Reply;
+ NTSTATUS Status;
+
+ Request.Type = CSRSS_SET_CONSOLE_CP;
+ Request.Data.SetConsoleCodePage.CodePage = wCodePageID;
+ Status = CsrClientCallServer(&Request, &Reply, sizeof(CSRSS_API_REQUEST),
+ sizeof(CSRSS_API_REPLY));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ {
+ SetLastErrorByStatus (Status);
+ }
+ return NT_SUCCESS(Status);
}
/*--------------------------------------------------------------
* GetConsoleOutputCP
+ *
+ * @implemented
*/
-WINBASEAPI
UINT
WINAPI
GetConsoleOutputCP( VOID )
{
-/* --- TO DO --- */
- return 0; /* FIXME */
+ CSRSS_API_REQUEST Request;
+ CSRSS_API_REPLY Reply;
+ NTSTATUS Status;
+
+ Request.Type = CSRSS_GET_CONSOLE_OUTPUT_CP;
+ Status = CsrClientCallServer(&Request, &Reply, sizeof(CSRSS_API_REQUEST),
+ sizeof(CSRSS_API_REPLY));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ {
+ SetLastErrorByStatus (Status);
+ return 0;
+ }
+ return Reply.Data.GetConsoleOutputCodePage.CodePage;
}
/*--------------------------------------------------------------
* SetConsoleOutputCP
+ *
+ * @implemented
*/
-WINBASEAPI
BOOL
WINAPI
SetConsoleOutputCP(
UINT wCodePageID
)
{
-/* --- TO DO --- */
- return FALSE;
+ CSRSS_API_REQUEST Request;
+ CSRSS_API_REPLY Reply;
+ NTSTATUS Status;
+
+ Request.Type = CSRSS_SET_CONSOLE_OUTPUT_CP;
+ Request.Data.SetConsoleOutputCodePage.CodePage = wCodePageID;
+ Status = CsrClientCallServer(&Request, &Reply, sizeof(CSRSS_API_REQUEST),
+ sizeof(CSRSS_API_REPLY));
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ {
+ SetLastErrorByStatus (Status);
+ }
+ return NT_SUCCESS(Status);
}
/*--------------------------------------------------------------
* GetConsoleProcessList
+ *
+ * @unimplemented
*/
DWORD STDCALL
GetConsoleProcessList(LPDWORD lpdwProcessList,
/*--------------------------------------------------------------
* GetConsoleSelectionInfo
+ *
+ * @unimplemented
*/
BOOL STDCALL
GetConsoleSelectionInfo(PCONSOLE_SELECTION_INFO lpConsoleSelectionInfo)
/*--------------------------------------------------------------
* AttachConsole
+ *
+ * @unimplemented
*/
BOOL STDCALL
AttachConsole(DWORD dwProcessId)
return FALSE;
}
+/*--------------------------------------------------------------
+ * GetConsoleWindow
+ *
+ * @implemented
+ */
+HWND STDCALL
+GetConsoleWindow (VOID)
+{
+ CSRSS_API_REQUEST Request;
+ CSRSS_API_REPLY Reply;
+ NTSTATUS Status;
+
+ Request.Type = CSRSS_GET_CONSOLE_WINDOW;
+ Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
+ if (!NT_SUCCESS(Status ) || !NT_SUCCESS(Status = Reply.Status))
+ {
+ SetLastErrorByStatus (Status);
+ return (HWND) NULL;
+ }
+ return Reply.Data.GetConsoleWindowReply.WindowHandle;
+}
+
+
+/*--------------------------------------------------------------
+ * SetConsoleIcon
+ *
+ * @implemented
+ */
+BOOL STDCALL SetConsoleIcon(HICON hicon)
+{
+ CSRSS_API_REQUEST Request;
+ CSRSS_API_REPLY Reply;
+ NTSTATUS Status;
+
+ Request.Type = CSRSS_SET_CONSOLE_ICON;
+ Request.Data.SetConsoleIconRequest.WindowIcon = hicon;
+ Status = CsrClientCallServer( &Request, &Reply, sizeof( CSRSS_API_REQUEST ), sizeof( CSRSS_API_REPLY ) );
+ if (!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Reply.Status))
+ {
+ SetLastErrorByStatus (Status);
+ return FALSE;
+ }
+ return NT_SUCCESS(Status);
+}
+
/* EOF */
projects / reactos.git / blobdiff