BOOL
APIENTRY
SetConsolePaletteInternal(
IN HANDLE hConsoleOutput,
IN HPALETTE hPalette,
IN UINT dwUsage
)
{
CONSOLE_API_MSG m;
PCONSOLE_SETPALETTE_MSG a = &m.u.SetConsolePalette;
NTSTATUS Status;
a->ConsoleHandle = GET_CONSOLE_HANDLE;
a->OutputHandle = hConsoleOutput;
a->hPalette = hPalette;
a->dwUsage = dwUsage;
CsrClientCallServer( (PCSR_API_MSG)&m,
NULL,
CSR_MAKE_API_NUMBER( CONSRV_SERVERDLL_INDEX,
ConsolepSetPalette
),
sizeof( *a )
);
if (!NT_SUCCESS( m.ReturnValue)) {
SET_LAST_NT_ERROR(m.ReturnValue);
return FALSE;
}
else {
return TRUE;
}
}
VOID
APIENTRY
SetLastConsoleEventActiveInternal( VOID )
/*++
Routine Description:
Sends a ConsolepNotifyLastClose command to the server.
Arguments:
none.
Return Value:
None.
--*/
{
CONSOLE_API_MSG m;
PCONSOLE_NOTIFYLASTCLOSE_MSG a = &m.u.SetLastConsoleEventActive;
a->ConsoleHandle = GET_CONSOLE_HANDLE;
CsrClientCallServer( (PCSR_API_MSG)&m,
NULL,
CSR_MAKE_API_NUMBER( CONSRV_SERVERDLL_INDEX,
ConsolepNotifyLastClose
),
sizeof( *a )
);
}
NTSTATUS
CsrSetPriorityClass(
IN HANDLE ProcessHandle,
IN OUT PULONG PriorityClass
)
{
NTSTATUS Status;
CSR_API_MSG m;
PCSR_SETPRIORITY_CLASS_MSG a = &m.u.PriorityClass;
a->ProcessHandle = ProcessHandle;
a->PriorityClass = *PriorityClass;
Status = CsrClientCallServer(
&m,
NULL,
CSR_MAKE_API_NUMBER( CSRSRV_SERVERDLL_INDEX,
CsrpSetPriorityClass
),
sizeof( *a )
);
if ( *PriorityClass == 0 ) {
*PriorityClass = a->PriorityClass;
}
return Status;
}
DWORD CTestCall(HWND hwnd, int a, int b, int c, int d, int e)
{
return CSMakeCall(
CSR_MAKE_API_NUMBER(4,FI_CTESTCALL),
(PDWORD)&hwnd,
CSInTestCall,
NULL);
}
BOOL
APIENTRY
SetConsoleHardwareState(
IN HANDLE hConsoleOutput,
IN COORD dwResolution,
IN COORD dwFontSize
)
/*++
Description:
This routine set the video resolution and font.
Parameters:
hConsoleOutput - Supplies a console output handle.
dwResolution - Contains screen resolution to set.
Resolution is returned in pixels.
dwFontSize - Contains font size to set.
Font size is returned in pixels.
Return value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
CONSOLE_API_MSG m;
PCONSOLE_SETHARDWARESTATE_MSG a = &m.u.SetConsoleHardwareState;
a->ConsoleHandle = GET_CONSOLE_HANDLE;
a->OutputHandle = hConsoleOutput;
a->Resolution = dwResolution;
a->FontSize = dwFontSize;
CsrClientCallServer( (PCSR_API_MSG)&m,
NULL,
CSR_MAKE_API_NUMBER( CONSRV_SERVERDLL_INDEX,
ConsolepSetHardwareState
),
sizeof( *a )
);
if (!NT_SUCCESS( m.ReturnValue)) {
SET_LAST_NT_ERROR(m.ReturnValue);
return FALSE;
}
else {
return TRUE;
}
}
BOOL
APIENTRY
GetConsoleDisplayMode(
OUT LPDWORD lpModeFlags
)
/*++
Description:
This routine returns the display mode of the console.
Parameters:
lpModeFlags - pointer to store display mode in.
Return value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
CONSOLE_API_MSG m;
PCONSOLE_GETDISPLAYMODE_MSG a = &m.u.GetConsoleDisplayMode;
a->ConsoleHandle = GET_CONSOLE_HANDLE;
CsrClientCallServer( (PCSR_API_MSG)&m,
NULL,
CSR_MAKE_API_NUMBER( CONSRV_SERVERDLL_INDEX,
ConsolepGetDisplayMode
),
sizeof( *a )
);
if (!NT_SUCCESS( m.ReturnValue)) {
SET_LAST_NT_ERROR(m.ReturnValue);
return FALSE;
}
else {
try {
*lpModeFlags = a->ModeFlags;
}
except( EXCEPTION_EXECUTE_HANDLER ) {
SET_LAST_ERROR(ERROR_INVALID_ACCESS);
return FALSE;
}
return TRUE;
}
}
BOOL
WINAPI
SetConsoleCursor(
IN HANDLE hConsoleOutput,
IN HCURSOR hCursor
)
/*++
Description:
Sets the mouse pointer for the specified screen buffer.
Parameters:
hConsoleOutput - Supplies a console output handle.
hCursor - win32 cursor handle, should be NULL to set the default
cursor.
Return value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
CONSOLE_API_MSG m;
PCONSOLE_SETCURSOR_MSG a = &m.u.SetConsoleCursor;
a->ConsoleHandle = GET_CONSOLE_HANDLE;
a->OutputHandle = hConsoleOutput;
a->CursorHandle = hCursor;
CsrClientCallServer( (PCSR_API_MSG)&m,
NULL,
CSR_MAKE_API_NUMBER( CONSRV_SERVERDLL_INDEX,
ConsolepSetCursor
),
sizeof( *a )
);
if (!NT_SUCCESS( m.ReturnValue)) {
SET_LAST_NT_ERROR(m.ReturnValue);
return FALSE;
}
else {
return TRUE;
}
}
HMENU
APIENTRY
ConsoleMenuControl(
IN HANDLE hConsoleOutput,
IN UINT dwCommandIdLow,
IN UINT dwCommandIdHigh
)
/*++
Description:
Sets the command id range for the current screen buffer and returns the
menu handle.
Parameters:
hConsoleOutput - Supplies a console output handle.
dwCommandIdLow - Specifies the lowest command id to store in the input buffer.
dwCommandIdHigh - Specifies the highest command id to store in the input
buffer.
Return value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
CONSOLE_API_MSG m;
PCONSOLE_MENUCONTROL_MSG a = &m.u.ConsoleMenuControl;
a->ConsoleHandle = GET_CONSOLE_HANDLE;
a->OutputHandle = hConsoleOutput;
a->CommandIdLow =dwCommandIdLow;
a->CommandIdHigh = dwCommandIdHigh;
CsrClientCallServer( (PCSR_API_MSG)&m,
NULL,
CSR_MAKE_API_NUMBER( CONSRV_SERVERDLL_INDEX,
ConsolepMenuControl
),
sizeof( *a )
);
return a->hMenu;
}
DWORD AITestCall(HWND hwnd, int a, int b, int c, int d, int e)
{
#if defined(_MIPS_) || defined(_PPC_)
return AIMakeCSCall(
#else
return MakeCSCall(
#endif
CSR_MAKE_API_NUMBER(4,FI_CTESTCALL),
(PDWORD)&hwnd,
InTestCall,
NULL
);
}
BOOL
APIENTRY
SetConsoleMenuClose(
IN BOOL bEnable
)
/*++
Description:
This routine returns the display mode of the console.
Parameters:
bEnable - if TRUE, close is enabled in the system menu.
Return value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
CONSOLE_API_MSG m;
PCONSOLE_SETMENUCLOSE_MSG a = &m.u.SetConsoleMenuClose;
a->ConsoleHandle = GET_CONSOLE_HANDLE;
a->Enable = bEnable;
CsrClientCallServer( (PCSR_API_MSG)&m,
NULL,
CSR_MAKE_API_NUMBER( CONSRV_SERVERDLL_INDEX,
ConsolepSetMenuClose
),
sizeof( *a )
);
if (!NT_SUCCESS( m.ReturnValue)) {
SET_LAST_NT_ERROR(m.ReturnValue);
return FALSE;
}
else {
return TRUE;
}
}
int
WINAPI
ShowConsoleCursor(
IN HANDLE hConsoleOutput,
IN BOOL bShow
)
/*++
Description:
Sets the mouse pointer visibility counter. If the counter is less than
zero, the mouse pointer is not shown.
Parameters:
hOutput - Supplies a console output handle.
bShow - if TRUE, the display count is to be increased. if FALSE,
decreased.
Return value:
The return value specifies the new display count.
--*/
{
CONSOLE_API_MSG m;
PCONSOLE_SHOWCURSOR_MSG a = &m.u.ShowConsoleCursor;
a->ConsoleHandle = GET_CONSOLE_HANDLE;
a->OutputHandle = hConsoleOutput;
a->bShow = bShow;
CsrClientCallServer( (PCSR_API_MSG)&m,
NULL,
CSR_MAKE_API_NUMBER( CONSRV_SERVERDLL_INDEX,
ConsolepShowCursor
),
sizeof( *a )
);
return a->DisplayCount;
}
NTSTATUS
CsrIdentifyAlertableThread( VOID )
{
NTSTATUS Status;
CSR_API_MSG m;
PCSR_IDENTIFY_ALERTABLE_MSG a = &m.u.IndentifyAlertable;
a->ClientId = NtCurrentTeb()->ClientId;
Status = CsrClientCallServer(
&m,
NULL,
CSR_MAKE_API_NUMBER( CSRSRV_SERVERDLL_INDEX,
CsrpIdentifyAlertable
),
sizeof( *a )
);
return Status;
}
BOOL xxxActivateDebugger(
UINT fsModifiers)
{
ULONG ArgLength;
USER_API_MSG m;
PACTIVATEDEBUGGERMSG a = &m.u.ActivateDebugger;
PEPROCESS Process;
HANDLE hDebugPort;
NTSTATUS Status;
if (fsModifiers & MOD_CONTROL) {
#ifdef DEBUG
if (RipOutput(0, RIP_WARNING, "User debugger", 0, "Debug prompt", NULL)) {
DbgBreakPoint();
}
#endif
return FALSE;
} else if (fsModifiers & MOD_SHIFT) {
/*
* Bail out if the process is not being debugged.
*/
if (gpepCSRSS->DebugPort == NULL)
return FALSE;
a->ClientId.UniqueProcess = gpepCSRSS->UniqueProcessId;
} else {
if ((gpqForeground == NULL) || (gpqForeground->ptiKeyboard == NULL))
return FALSE;
a->ClientId = gpqForeground->ptiKeyboard->Thread->Cid;
/*
* Bail out if the process is not being debugged.
*/
if (!NT_SUCCESS(LockProcessByClientId(a->ClientId.UniqueProcess,
&Process)))
return FALSE;
hDebugPort = Process->DebugPort;
UnlockProcess(Process);
if (hDebugPort == NULL)
return FALSE;
}
/*
* Send the datagram to CSR
*/
if (CsrApiPort != NULL) {
ArgLength = sizeof(*a);
ArgLength |= (ArgLength << 16);
ArgLength += ((sizeof( CSR_API_MSG ) - sizeof( m.u )) << 16) |
(FIELD_OFFSET( CSR_API_MSG, u ) - sizeof( m.h ));
m.h.u1.Length = ArgLength;
m.h.u2.ZeroInit = 0;
m.CaptureBuffer = NULL;
m.ApiNumber = CSR_MAKE_API_NUMBER( USERSRV_SERVERDLL_INDEX,
UserpActivateDebugger);
LeaveCrit();
Status = LpcRequestPort(CsrApiPort, (PPORT_MESSAGE)&m);
EnterCrit();
UserAssert(NT_SUCCESS(Status));
}
/*
* Don't eat this event unless we are breaking into CSR! Since we have
* choosen an arbitrary hot key like F12 for the debug key, we need to
* pass on the key to the application, or apps that want this key would
* never see it. If we had an api for installing a debug hot key
* (export or MOD_DEBUG flag to RegisterHotKey()), then it would be ok
* to eat because the user selected the hot key. But it is not ok to
* eat it as long as we've picked an arbitrary hot key. scottlu.
*/
if (fsModifiers & MOD_SHIFT)
return TRUE;
else
return FALSE;
}
BOOL
APIENTRY
VDMConsoleOperation(
DWORD iFunction,
LPVOID lpData
)
/*++
Parameters:
iFunction - Function Index.
VDM_HIDE_WINDOW
Return Value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
CONSOLE_API_MSG m;
PCONSOLE_VDM_MSG a = &m.u.VDMConsoleOperation;
LPRECT lpRect;
LPPOINT lpPoint;
PBOOL lpBool;
PCSR_CAPTURE_HEADER CaptureBuffer = NULL;
#if defined(FE_SB)
#if defined(i386)
LPVDM_IOCTL_PARAM lpIoctlParam;
#endif
#endif // FE_SB
a->ConsoleHandle = GET_CONSOLE_HANDLE;
a->iFunction = iFunction;
if (iFunction == VDM_CLIENT_TO_SCREEN ||
iFunction == VDM_SCREEN_TO_CLIENT) {
lpPoint = (LPPOINT)lpData;
a->Point = *lpPoint;
} else if (iFunction == VDM_FULLSCREEN_NOPAINT) {
a->Bool = (lpData != NULL);
}
#if defined(FE_SB)
else if (iFunction == VDM_SET_VIDEO_MODE) {
a->Bool = (lpData != NULL);
}
#if defined(i386)
else if (iFunction == VDM_SAVE_RESTORE_HW_STATE) {
a->Bool = (lpData != NULL);
}
else if (iFunction == VDM_VIDEO_IOCTL) {
lpIoctlParam = (LPVDM_IOCTL_PARAM)lpData;
a->VDMIoctlParam = *lpIoctlParam;
if (lpIoctlParam->lpvInBuffer != NULL) {
if (lpIoctlParam->lpvOutBuffer != NULL || lpIoctlParam->cbInBuffer == 0) {
SET_LAST_ERROR(ERROR_INVALID_PARAMETER);
return FALSE;
}
CaptureBuffer = CsrAllocateCaptureBuffer( 1,
lpIoctlParam->cbInBuffer
);
if (CaptureBuffer == NULL) {
SET_LAST_ERROR(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
CsrCaptureMessageBuffer( CaptureBuffer,
(PCHAR) lpIoctlParam->lpvInBuffer,
lpIoctlParam->cbInBuffer,
(PVOID *) &a->VDMIoctlParam.lpvInBuffer
);
}
if (lpIoctlParam->lpvOutBuffer != NULL) {
if (lpIoctlParam->cbOutBuffer == 0) {
SET_LAST_ERROR(ERROR_INVALID_PARAMETER);
return FALSE;
}
CaptureBuffer = CsrAllocateCaptureBuffer( 1,
lpIoctlParam->cbOutBuffer
);
if (CaptureBuffer == NULL) {
SET_LAST_ERROR(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
CsrCaptureMessageBuffer( CaptureBuffer,
(PCHAR) lpIoctlParam->lpvOutBuffer,
lpIoctlParam->cbOutBuffer,
(PVOID *) &a->VDMIoctlParam.lpvOutBuffer
);
}
}
#endif // i386
#endif // FE_SB
CsrClientCallServer( (PCSR_API_MSG)&m,
CaptureBuffer,
CSR_MAKE_API_NUMBER( CONSRV_SERVERDLL_INDEX,
ConsolepVDMOperation
),
sizeof( *a )
);
if (NT_SUCCESS( m.ReturnValue )) {
switch (iFunction) {
case VDM_IS_ICONIC:
case VDM_IS_HIDDEN:
lpBool = (PBOOL)lpData;
*lpBool = a->Bool;
break;
case VDM_CLIENT_RECT:
lpRect = (LPRECT)lpData;
*lpRect = a->Rect;
break;
case VDM_CLIENT_TO_SCREEN:
case VDM_SCREEN_TO_CLIENT:
*lpPoint = a->Point;
break;
#if defined(FE_SB)
#if defined(i386)
case VDM_VIDEO_IOCTL:
if (lpIoctlParam->lpvOutBuffer != NULL) {
try {
RtlCopyMemory( lpIoctlParam->lpvOutBuffer,
a->VDMIoctlParam.lpvOutBuffer,
lpIoctlParam->cbOutBuffer );
} except( EXCEPTION_EXECUTE_HANDLER ) {
CsrFreeCaptureBuffer( CaptureBuffer );
SET_LAST_ERROR(ERROR_INVALID_ACCESS);
return FALSE;
}
}
if (CaptureBuffer != NULL) {
CsrFreeCaptureBuffer( CaptureBuffer );
}
break;
#endif // i386
#endif // FE_SB
default:
break;
}
return TRUE;
} else {
#if defined(FE_SB)
#if defined(i386)
if (CaptureBuffer != NULL) {
NTSTATUS
CsrClientConnectToServer(
IN PWSTR ObjectDirectory,
IN ULONG ServerDllIndex,
IN PCSR_CALLBACK_INFO CallbackInformation OPTIONAL,
IN PVOID ConnectionInformation,
IN OUT PULONG ConnectionInformationLength OPTIONAL,
OUT PBOOLEAN CalledFromServer OPTIONAL
)
/*++
Routine Description:
This function is called by the client side DLL to connect with its
server side DLL.
Arguments:
ObjectDirectory - Points to a null terminate string that is the same
as the value of the ObjectDirectory= argument passed to the CSRSS
program.
ServerDllIndex - Index of the server DLL that is being connected to.
It should match one of the ServerDll= arguments passed to the CSRSS
program.
CallbackInformation - An optional pointer to a structure that contains
a pointer to the client callback function dispatch table.
ConnectionInformation - An optional pointer to uninterpreted data.
This data is intended for clients to pass package, version and
protocol identification information to the server to allow the
server to determine if it can satisify the client before
accepting the connection. Upon return to the client, the
ConnectionInformation data block contains any information passed
back from the server DLL by its call to the
CsrCompleteConnection call. The output data overwrites the
input data.
ConnectionInformationLength - Pointer to the length of the
ConnectionInformation data block. The output value is the
length of the data stored in the ConnectionInformation data
block by the server's call to the NtCompleteConnectPort
service. This parameter is OPTIONAL only if the
ConnectionInformation parameter is NULL, otherwise it is
required.
CalledFromServer - On output, TRUE if the dll has been called from
a server process.
Return Value:
Status value.
--*/
{
NTSTATUS Status;
CSR_API_MSG m;
PCSR_CLIENTCONNECT_MSG a = &m.u.ClientConnect;
PCSR_CAPTURE_HEADER CaptureBuffer;
HANDLE CsrServerModuleHandle;
STRING ProcedureName;
ANSI_STRING DllName;
UNICODE_STRING DllName_U;
PIMAGE_NT_HEADERS NtHeaders;
if (ARGUMENT_PRESENT( ConnectionInformation ) &&
(!ARGUMENT_PRESENT( ConnectionInformationLength ) ||
*ConnectionInformationLength == 0
)
) {
return( STATUS_INVALID_PARAMETER );
}
if (!CsrInitOnceDone) {
Status = CsrOneTimeInitialize();
if (!NT_SUCCESS( Status )) {
return( Status );
}
}
if (ARGUMENT_PRESENT( CallbackInformation )) {
CsrLoadedClientDll[ ServerDllIndex ] = RtlAllocateHeap( CsrHeap, MAKE_TAG( CSR_TAG ), sizeof(CSR_CALLBACK_INFO) );
CsrLoadedClientDll[ ServerDllIndex ]->ApiNumberBase =
CallbackInformation->ApiNumberBase;
CsrLoadedClientDll[ ServerDllIndex ]->MaxApiNumber =
CallbackInformation->MaxApiNumber;
CsrLoadedClientDll[ ServerDllIndex ]->CallbackDispatchTable =
CallbackInformation->CallbackDispatchTable;
}
//
// if we are being called by a server process, skip lpc port initialization
// and call to server connect routine and just initialize heap. the
// dll initialization routine will do any necessary initialization. this
// stuff only needs to be done for the first connect.
//
if ( CsrServerProcess == TRUE ) {
*CalledFromServer = CsrServerProcess;
return STATUS_SUCCESS;
}
//
// If the image is an NT Native image, we are running in the
// context of the server.
//
NtHeaders = RtlImageNtHeader(NtCurrentPeb()->ImageBaseAddress);
CsrServerProcess =
(NtHeaders->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_NATIVE) ? TRUE : FALSE;
if ( CsrServerProcess ) {
extern PVOID NtDllBase;
RtlInitAnsiString( &DllName, "csrsrv" );
Status = RtlAnsiStringToUnicodeString(&DllName_U, &DllName, TRUE);
ASSERT(NT_SUCCESS(Status));
LdrDisableThreadCalloutsForDll(NtDllBase);
Status = LdrGetDllHandle(
UNICODE_NULL,
NULL,
&DllName_U,
(PVOID *)&CsrServerModuleHandle
);
RtlFreeUnicodeString(&DllName_U);
CsrServerProcess = TRUE;
RtlInitString(&ProcedureName,"CsrCallServerFromServer");
Status = LdrGetProcedureAddress(
CsrServerModuleHandle,
&ProcedureName,
0L,
(PVOID *)&CsrServerApiRoutine
);
ASSERT(NT_SUCCESS(Status));
RtlInitString(&ProcedureName, "CsrLocateThreadInProcess");
Status = LdrGetProcedureAddress(
CsrServerModuleHandle,
&ProcedureName,
0L,
(PVOID *)&CsrpLocateThreadInProcess
);
ASSERT(NT_SUCCESS(Status));
ASSERT (CsrPortHeap==NULL);
CsrPortHeap = RtlProcessHeap();
CsrPortBaseTag = RtlCreateTagHeap( CsrPortHeap,
0,
L"CSRPORT!",
L"CAPTURE\0"
);
if (ARGUMENT_PRESENT(CalledFromServer)) {
*CalledFromServer = CsrServerProcess;
}
return STATUS_SUCCESS;
}
if ( ARGUMENT_PRESENT(ConnectionInformation) ) {
CsrServerProcess = FALSE;
if (CsrPortHandle == NULL) {
Status = CsrpConnectToServer( ObjectDirectory );
if (!NT_SUCCESS( Status )) {
return( Status );
}
}
a->ServerDllIndex = ServerDllIndex;
a->ConnectionInformationLength = *ConnectionInformationLength;
if (ARGUMENT_PRESENT( ConnectionInformation )) {
CaptureBuffer = CsrAllocateCaptureBuffer( 1,
0,
a->ConnectionInformationLength
);
if (CaptureBuffer == NULL) {
return( STATUS_NO_MEMORY );
}
CsrAllocateMessagePointer( CaptureBuffer,
a->ConnectionInformationLength,
(PVOID *)&a->ConnectionInformation
);
RtlMoveMemory( a->ConnectionInformation,
ConnectionInformation,
a->ConnectionInformationLength
);
*ConnectionInformationLength = a->ConnectionInformationLength;
}
else {
CaptureBuffer = NULL;
}
Status = CsrClientCallServer( &m,
CaptureBuffer,
CSR_MAKE_API_NUMBER( CSRSRV_SERVERDLL_INDEX,
CsrpClientConnect
),
sizeof( *a )
);
if (CaptureBuffer != NULL) {
if (ARGUMENT_PRESENT( ConnectionInformation )) {
RtlMoveMemory( ConnectionInformation,
a->ConnectionInformation,
*ConnectionInformationLength
);
}
CsrFreeCaptureBuffer( CaptureBuffer );
}
}
else {
Status = STATUS_SUCCESS;
}
if (ARGUMENT_PRESENT(CalledFromServer)) {
*CalledFromServer = CsrServerProcess;
}
return( Status );
}
BOOL
APIENTRY
GetConsoleHardwareState(
IN HANDLE hConsoleOutput,
OUT PCOORD lpResolution,
OUT PCOORD lpFontSize
)
/*++
Description:
This routine returns the video resolution and font.
Parameters:
hConsoleOutput - Supplies a console output handle.
lpResolution - Pointer to structure to store screen
resolution in. Resolution is returned in pixels.
lpFontSize - Pointer to structure to store font size in.
Font size is returned in pixels.
Return value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
CONSOLE_API_MSG m;
PCONSOLE_GETHARDWARESTATE_MSG a = &m.u.GetConsoleHardwareState;
a->ConsoleHandle = GET_CONSOLE_HANDLE;
a->OutputHandle = hConsoleOutput;
CsrClientCallServer( (PCSR_API_MSG)&m,
NULL,
CSR_MAKE_API_NUMBER( CONSRV_SERVERDLL_INDEX,
ConsolepGetHardwareState
),
sizeof( *a )
);
if (!NT_SUCCESS( m.ReturnValue)) {
SET_LAST_NT_ERROR(m.ReturnValue);
return FALSE;
}
else {
try {
*lpResolution = a->Resolution;
*lpFontSize = a->FontSize;
}
except( EXCEPTION_EXECUTE_HANDLER ) {
SET_LAST_ERROR(ERROR_INVALID_ACCESS);
return FALSE;
}
return TRUE;
}
}
BOOL
APIENTRY
RegisterConsoleVDM(
IN DWORD dwRegisterFlags,
IN HANDLE hStartHardwareEvent,
IN HANDLE hEndHardwareEvent,
IN LPWSTR lpStateSectionName,
IN DWORD dwStateSectionNameLength,
OUT LPDWORD lpStateLength,
OUT PVOID *lpState,
IN LPWSTR lpVDMBufferSectionName,
IN DWORD dwVDMBufferSectionNameLength,
IN COORD VDMBufferSize OPTIONAL,
OUT PVOID *lpVDMBuffer
)
/*++
Description:
This routine registers the VDM with the console.
Parameters:
hStartHardwareEvent - the event the VDM waits on to be
notified of gaining/losing control of the hardware.
hEndHardwareEvent - the event the VDM sets when it is done
saving/restoring the hardware.
Return value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
CONSOLE_API_MSG m;
PCONSOLE_REGISTERVDM_MSG a = &m.u.RegisterConsoleVDM;
PCSR_CAPTURE_HEADER CaptureBuffer;
a->ConsoleHandle = GET_CONSOLE_HANDLE;
a->RegisterFlags = dwRegisterFlags;
if (dwRegisterFlags) {
a->StartEvent = hStartHardwareEvent;
a->EndEvent = hEndHardwareEvent;
a->VDMBufferSectionNameLength = dwVDMBufferSectionNameLength;
a->VDMBufferSize = VDMBufferSize;
a->StateSectionNameLength = dwStateSectionNameLength;
CaptureBuffer = CsrAllocateCaptureBuffer( 2,
dwStateSectionNameLength+dwVDMBufferSectionNameLength
);
if (CaptureBuffer == NULL) {
SET_LAST_ERROR(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
CsrCaptureMessageBuffer( CaptureBuffer,
lpStateSectionName,
dwStateSectionNameLength,
(PVOID *) &a->StateSectionName
);
CsrCaptureMessageBuffer( CaptureBuffer,
lpVDMBufferSectionName,
dwVDMBufferSectionNameLength,
(PVOID *) &a->VDMBufferSectionName
);
} else {
CaptureBuffer = NULL;
}
CsrClientCallServer( (PCSR_API_MSG)&m,
CaptureBuffer,
CSR_MAKE_API_NUMBER( CONSRV_SERVERDLL_INDEX,
ConsolepRegisterVDM
),
sizeof( *a )
);
if (CaptureBuffer != NULL) {
CsrFreeCaptureBuffer( CaptureBuffer );
}
if (!NT_SUCCESS( m.ReturnValue)) {
SET_LAST_NT_ERROR(m.ReturnValue);
return FALSE;
}
else {
if (dwRegisterFlags) {
try {
*lpStateLength = a->StateLength;
*lpState = a->StateBuffer;
*lpVDMBuffer = a->VDMBuffer;
}
except (EXCEPTION_EXECUTE_HANDLER) {
SET_LAST_ERROR(ERROR_INVALID_ACCESS);
return FALSE;
}
}
return TRUE;
}
}
BOOL
APIENTRY
SetConsoleDisplayMode(
IN HANDLE hConsoleOutput,
IN DWORD dwFlags,
OUT PCOORD lpNewScreenBufferDimensions
)
/*++
Description:
This routine sets the console display mode for an output buffer.
This API is only supported on x86 machines. Frame buffer consoles
are always windowed.
Parameters:
hConsoleOutput - Supplies a console output handle.
dwFlags - Specifies the display mode. Options are:
CONSOLE_FULLSCREEN_MODE - data is displayed fullscreen
CONSOLE_WINDOWED_MODE - data is displayed in a window
lpNewScreenBufferDimensions - On output, contains the new dimensions of
the screen buffer. The dimensions are in rows and columns for
textmode screen buffers.
Return value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
CONSOLE_API_MSG m;
PCONSOLE_SETDISPLAYMODE_MSG a = &m.u.SetConsoleDisplayMode;
NTSTATUS Status;
#if !defined(_X86_)
return FALSE;
#else
Status = NtCreateEvent(&(a->hEvent),
EVENT_ALL_ACCESS,
NULL,
SynchronizationEvent,
(BOOLEAN)FALSE
);
if (!NT_SUCCESS(Status)) {
SET_LAST_NT_ERROR(Status);
return FALSE;
}
a->ConsoleHandle = GET_CONSOLE_HANDLE;
a->OutputHandle = hConsoleOutput;
a->dwFlags = dwFlags;
CsrClientCallServer( (PCSR_API_MSG)&m,
NULL,
CSR_MAKE_API_NUMBER( CONSRV_SERVERDLL_INDEX,
ConsolepSetDisplayMode
),
sizeof( *a )
);
if (!NT_SUCCESS( m.ReturnValue)) {
SET_LAST_NT_ERROR(m.ReturnValue);
NtClose(a->hEvent);
return FALSE;
}
else {
Status = NtWaitForSingleObject(a->hEvent, FALSE, NULL);
NtClose(a->hEvent);
if (Status != 0) {
SET_LAST_NT_ERROR(Status);
return FALSE;
}
try {
*lpNewScreenBufferDimensions = a->ScreenBufferDimensions;
}
except( EXCEPTION_EXECUTE_HANDLER ) {
SET_LAST_ERROR(ERROR_INVALID_ACCESS);
return FALSE;
}
return TRUE;
}
#endif
}
BOOL
WINAPI
GetConsoleMode(
IN HANDLE hConsoleHandle,
OUT LPDWORD lpMode
)
/*++
Parameters:
hConsoleHandle - Supplies a console input or output handle.
lpMode - Supplies a pointer to a dword in which to store the mode.
Input Mode Flags:
ENABLE_LINE_INPUT - line oriented input is on.
ENABLE_ECHO_INPUT - characters will be written to the screen as they are
read.
ENABLE_WINDOW_INPUT - the caller is windows-aware
Output Mode Flags:
ENABLE_LINE_OUTPUT - line oriented output is on.
ENABLE_WRAP_AT_EOL_OUTPUT - the cursor will move to the
beginning of the next line when the end of the row
is reached.
Return Value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
CONSOLE_API_MSG m;
PCONSOLE_MODE_MSG a = &m.u.GetConsoleMode;
a->ConsoleHandle = GET_CONSOLE_HANDLE;
a->Handle = hConsoleHandle;
CsrClientCallServer( (PCSR_API_MSG)&m,
NULL,
CSR_MAKE_API_NUMBER( CONSRV_SERVERDLL_INDEX,
ConsolepGetMode
),
sizeof( *a )
);
if (NT_SUCCESS( m.ReturnValue )) {
try {
*lpMode = a->Mode;
} except( EXCEPTION_EXECUTE_HANDLER ) {
SET_LAST_ERROR (ERROR_INVALID_ACCESS);
return FALSE;
}
return TRUE;
} else {
BOOL
APIENTRY
SetConsoleKeyShortcuts(
IN BOOL bSet,
IN BYTE bReserveKeys,
IN LPAPPKEY lpAppKeys,
IN DWORD dwNumAppKeys
)
/*++
Description:
Only one set of key shortcuts is valid per console. Calling
SetConsoleKeyShortcuts(set) overwrites any previous settings.
SetConsoleKeyShortcuts(!set) removes any shortcuts.
Parameters:
bSet - if TRUE, set shortcuts. else remove shortcuts.
bReserveKeys - byte containing reserve key info.
lpAppKeys - pointer to application-defined shortcut keys. can be null.
dwNumAppKeys - number of app keys contained in lpAppKeys.
Return value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
CONSOLE_API_MSG m;
PCONSOLE_SETKEYSHORTCUTS_MSG a = &m.u.SetConsoleKeyShortcuts;
PCSR_CAPTURE_HEADER CaptureBuffer;
a->ConsoleHandle = GET_CONSOLE_HANDLE;
a->Set = bSet;
a->ReserveKeys = bReserveKeys;
if (lpAppKeys == NULL) {
a->NumAppKeys = 0;
CaptureBuffer = NULL;
} else {
a->NumAppKeys = dwNumAppKeys;
CaptureBuffer = CsrAllocateCaptureBuffer( 1,
dwNumAppKeys * sizeof(APPKEY)
);
if (CaptureBuffer == NULL) {
SET_LAST_ERROR(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
CsrCaptureMessageBuffer( CaptureBuffer,
lpAppKeys,
dwNumAppKeys * sizeof(APPKEY),
(PVOID *) &a->AppKeys
);
}
CsrClientCallServer( (PCSR_API_MSG)&m,
CaptureBuffer,
CSR_MAKE_API_NUMBER( CONSRV_SERVERDLL_INDEX,
ConsolepSetKeyShortcuts
),
sizeof( *a )
);
if (CaptureBuffer)
CsrFreeCaptureBuffer( CaptureBuffer );
if (!NT_SUCCESS( m.ReturnValue)) {
SET_LAST_NT_ERROR(m.ReturnValue);
return FALSE;
}
else {
return TRUE;
}
}
