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; } }