Microsoft/WindowsXP-SP1
Microsoft
/
WindowsXP-SP1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
WindowsXP-SP1/termsrv/icaapi/icakey.c

526 lines
14 KiB
C
Raw Permalink Blame History

/*************************************************************************
* T1.C
*
* Test program for ICA DLL Interface to ICA Device Driver
*
* copyright notice: Copyright 1996, Citrix Systems Inc.
* Copyright (C) 1997-1999 Microsoft Corp.
*************************************************************************/
#include "precomp.h"
#pragma hdrstop
#include <stdio.h>
#define MAX_READ 2
/*
* Data types and definitions
*/
#define KEYBOARD_THREAD_STACKSIZE 1024 * 4
typedef struct _THREADDATA {
HANDLE handle;
} THREADDATA, * PTHREADDATA;
/*
* Global variables
*/
static HANDLE ghIca = NULL;
static HANDLE ghStack = NULL;
static HANDLE ghKeyboard = NULL;
static HANDLE ghMouse = NULL;
static HANDLE ghVideo = NULL;
static HANDLE ghBeep = NULL;
static HANDLE ghCommand = NULL;
static HANDLE ghCdm = NULL;
static HANDLE ghThreadKeyboardRead = NULL;
static HANDLE ghStopEvent = NULL;
/*
* Private procedures
*/
LONG OpenStacks( void );
LONG ConnectStacks( void );
LONG CloseStacks( void );
LONG Initialize( void );
VOID KeyboardReadThread( PTHREADDATA pThreadData );
LONG KeyboardTest( void );
/****************************************************************************
*
* main
*
* Main process entry point
*
* ENTRY:
* argc (input)
* Number of parameters
*
* argv (input)
* Array of argument strings
*
* EXIT:
* STATUS_SUCCESS - Success
* other - Error return code
*
****************************************************************************/
int _cdecl
main (int argc, char *argv[])
{
BOOL fSuccess = TRUE;
LONG rc;
/*
* Open the ICA driver, an ICA stack, and some channels
*/
if ( rc = OpenStacks() ) {
goto done;
}
/*
* Do some initialization
*/
if ( rc = Initialize() ) {
goto done;
}
printf( "Sleeping...\n" );
Sleep(3000); // Give thread some time
if ( rc = KeyboardTest() ) {
goto done;
}
/*
* Wait for stop event to be triggered.
*/
printf( "ICAKEY main: Waiting for stop event...\n" );
WaitForSingleObject( ghStopEvent, (DWORD)30000 );
printf( "ICAKEY main: ...Stop event triggered\n" );
done:
fSuccess = !rc;
if ( rc = CloseStacks() ) {
fSuccess = FALSE;
}
printf( "ICAKEY main: Test %s!\n", fSuccess ? "successful" : "failed" );
return( 0 );
}
/****************************************************************************
*
* OpenStacks
*
* Open ICA device driver, ICA stack, and ICA channels
*
* ENTRY:
* void
*
* EXIT:
* STATUS_SUCCESS - Success
* other - Error return code
*
****************************************************************************/
LONG
OpenStacks( void )
{
NTSTATUS rc;
/*
* Open an instance of the ICA device driver
*/
if ( rc = IcaOpen( &ghIca ) ) {
printf( "ICAKEY OpenStacks: Error 0x%x from IcaOpen\n",
rc );
goto done;
}
printf( "ICAKEY OpenStacks: Handle to ICA device driver: %08lX\n", ghIca );
/*
* Open an ICA stack instance
*/
if ( rc = IcaStackOpen( ghIca, Stack_Primary, &ghStack ) ) {
printf( "ICAKEY OpenStacks: Error 0x%x from IcaStackOpen\n", rc );
goto done;
}
printf( "ICAKEY OpenStacks: Handle to ICA stack: %08lX\n", ghStack );
/*
* Open the keyboard channel
*/
if ( rc = IcaChannelOpen( ghIca, Channel_Keyboard, NULL, &ghKeyboard ) ) {
printf( "ICAKEY OpenStacks: Error 0x%x from IcaChannelOpen( keyboard )\n", rc );
goto done;
}
printf( "ICAKEY OpenStacks: Handle to keyboard channel: %08lX\n", ghKeyboard );
/*
* Open the mouse channel
*/
if ( rc = IcaChannelOpen( ghIca, Channel_Mouse, NULL, &ghMouse ) ) {
printf( "ICAKEY OpenStacks: Error 0x%x from IcaChannelOpen( mouse )", rc );
goto done;
}
printf( "ICAKEY OpenStacks: Handle to mouse channel: %08lX\n", ghMouse );
/*
* Open the video channel
*/
if ( rc = IcaChannelOpen( ghIca, Channel_Video, NULL, &ghVideo ) ) {
printf( "ICAKEY OpenStacks: Error 0x%x from IcaChannelOpen( video )", rc );
goto done;
}
printf( "ICAKEY OpenStacks: Handle to video channel: %08lX\n", ghVideo );
/*
* Open the beep channel
*/
if ( rc = IcaChannelOpen( ghIca, Channel_Beep, NULL, &ghBeep ) ) {
printf( "ICAKEY OpenStacks: Error 0x%x from IcaChannelOpen( beep )", rc );
goto done;
}
printf( "ICAKEY OpenStacks: Handle to beep channel: %08lX\n", ghBeep );
/*
* Open the command channel
*/
if ( rc = IcaChannelOpen( ghIca, Channel_Command, NULL, &ghCommand ) ) {
printf( "ICAKEY OpenStacks: Error 0x%x from IcaChannelOpen( command )", rc );
goto done;
}
printf( "ICAKEY OpenStacks: Handle to command channel: %08lX\n", ghCommand );
/*
* Open the cdm channel
*/
if ( rc = IcaChannelOpen( ghIca, Channel_Virtual, VIRTUAL_CDM, &ghCdm ) ) {
printf( "ICAKEY OpenStacks: Error 0x%x from IcaChannelOpen( VIRTUAL_CDM )", rc );
goto done;
}
printf( "ICAKEY OpenStacks: Handle to cdm channel: %08lX\n", ghCdm );
done:
return( rc );
}
/****************************************************************************
*
* CloseStacks
*
* Close the ICA device driver, ICA stack, and ICA channels
*
* ENTRY:
* void
*
* EXIT:
* STATUS_SUCCESS - Success
* other - Error return code
*
****************************************************************************/
LONG
CloseStacks( void )
{
LONG rc = STATUS_SUCCESS;
/*
* Close the stop event handle
*/
if ( ghStopEvent ) {
CloseHandle( ghStopEvent );
}
/*
* Kill the keyboard read thread
*/
if ( ghThreadKeyboardRead ) {
TerminateThread( ghThreadKeyboardRead, 0 );
CloseHandle( ghThreadKeyboardRead );
}
/*
* Close the keyboard channel
*/
if ( ghKeyboard ) {
if ( rc = IcaChannelClose( ghKeyboard ) ) {
printf( "ICAKEY CloseStacks: Error 0x%x from IcaChannelClose( Keyboard )\n", rc );
}
}
/*
* Close the mouse channel
*/
if ( ghMouse ) {
if ( rc = IcaChannelClose( ghMouse ) ) {
printf( "ICAKEY CloseStacks: Error 0x%x from IcaChannelClose( Mouse )\n", rc );
}
}
/*
* Close the video channel
*/
if ( ghVideo ) {
if ( rc = IcaChannelClose( ghVideo ) ) {
printf( "ICAKEY CloseStacks: Error 0x%x from IcaChannelClose( Video )\n", rc );
}
}
/*
* Close the beep channel
*/
if ( ghBeep ) {
if ( rc = IcaChannelClose( ghBeep ) ) {
printf( "ICAKEY CloseStacks: Error 0x%x from IcaChannelClose( Beep )\n", rc );
}
}
/*
* Close the command channel
*/
if ( ghCommand ) {
if ( rc = IcaChannelClose( ghCommand ) ) {
printf( "ICAKEY CloseStacks: Error 0x%x from IcaChannelClose( Command )\n", rc );
}
}
/*
* Close the cdm channel
*/
if ( ghCdm ) {
if ( rc = IcaChannelClose( ghCdm ) ) {
printf( "ICAKEY CloseStacks: Error 0x%x from IcaChannelClose( Cdm )\n", rc );
}
}
/*
* Close the ICA stack instance
*/
if ( ghStack ) {
if ( rc = IcaStackClose( ghStack ) ) {
printf( "ICAKEY CloseStacks: Error 0x%x from IcaStackClose\n", rc );
}
}
/*
* Close the ICA device driver instance
*/
if ( ghIca ) {
if ( rc = IcaClose( ghIca ) ) {
printf( "ICAKEY CloseStacks: Error 0x%x from IcaClose\n", rc );
}
}
return( rc );
}
/****************************************************************************
*
* Initialize
*
* Do some initialization
*
* ENTRY:
* void
*
* EXIT:
* STATUS_SUCCESS - Success
* other - Error return code
*
****************************************************************************/
LONG
Initialize( void )
{
LONG rc = STATUS_SUCCESS;
DWORD tidKeyboardReadThread;
THREADDATA ThreadData;
/*
* Create stop event to wait on later.
*/
if ( !(ghStopEvent = CreateEvent( NULL, TRUE, FALSE, NULL )) ) {
printf( "ICAKEY Initialize: Error 0x%x in CreateEvent\n", GetLastError() );
goto done;
}
ThreadData.handle = ghKeyboard;
/*
* Startup the virtual channel read thread
*/
if ( !(ghThreadKeyboardRead = CreateThread( NULL,
KEYBOARD_THREAD_STACKSIZE,
(LPTHREAD_START_ROUTINE)KeyboardReadThread,
(LPVOID)&ThreadData, 0,
(LPDWORD)&tidKeyboardReadThread )) ) {
rc = GetLastError();
printf( "ICAKEY Initialize: Error 0x%x creating keyboard read thread\n", rc );
goto done;
}
done:
return( rc );
}
/*******************************************************************************
*
* Function: KeyboardReadThread
*
* Purpose: Keyboard read thread
*
* Entry:
* pThreadData
* Pointer to thread creation data
*
* Exit:
* void
*
******************************************************************************/
VOID KeyboardReadThread( PTHREADDATA pThreadData )
{
int rc;
HANDLE handle = pThreadData->handle;
KEYBOARD_INPUT_DATA KeyboardInputData;
DWORD cbRead;
OVERLAPPED Overlapped;
DWORD dwError;
int NumberRead = 0;
Overlapped.Offset = 0;
Overlapped.OffsetHigh = 0;
Overlapped.hEvent = NULL;
printf( "Keyboard read thread starting...\n" );
/*
* Now dedicate this thread to monitor the keyboard
*/
do {
cbRead = 0;
if ( !ReadFile( ghKeyboard,
&KeyboardInputData,
sizeof( KeyboardInputData ),
&cbRead, &Overlapped ) ) {
dwError = GetLastError();
if ( dwError == ERROR_IO_PENDING ) {
// check on the results of the asynchronous read
if ( !GetOverlappedResult( ghKeyboard, &Overlapped,
&cbRead, TRUE) ) { // wait for result
printf( "ICAKEY KeyboardReadThread: Error 0x%x from GetOverlappedResult( Channel_Keyboard )\n",
GetLastError() );
break;
}
}
else {
printf( "ICAKEY KeyboardReadThread: Error 0x%x from ReadFile( Channel_Keyboard )\n",
dwError );
break;
}
}
printf( "Unit number: 0x%x\nScan code: %02X\nFlags: %04X\nExtra info: %08X\n",
KeyboardInputData.UnitId,
KeyboardInputData.MakeCode,
KeyboardInputData.Flags,
KeyboardInputData.ExtraInformation );
NumberRead++;
if ( NumberRead == MAX_READ )
break;
} while ( 1 );
printf( "Keyboard read thread exiting...\n" );
SetEvent( ghStopEvent );
ExitThread( 0 );
}
/****************************************************************************
*
* KeyboardTest
*
* Stuff some data into the keyboard channel for testing purposes
*
* ENTRY:
* void
*
* EXIT:
* STATUS_SUCCESS - Success
* other - Error return code
*
****************************************************************************/
LONG
KeyboardTest( void )
{
LONG rc = STATUS_SUCCESS;
KEYBOARD_INPUT_DATA KeyboardInputData;
ULONG cbReturned;
/*
* Initialize the keystroke to fabricate
*/
KeyboardInputData.UnitId = 0;
KeyboardInputData.MakeCode = 0x32; // Capital 'M'
KeyboardInputData.Flags = KEY_MAKE;
KeyboardInputData.Reserved = 0;
KeyboardInputData.ExtraInformation = 0;
/*
* First stuff the make
*/
if ( rc = IcaChannelIoControl( ghKeyboard,
IOCTL_KEYBOARD_ICA_INPUT,
&KeyboardInputData,
sizeof( KeyboardInputData ),
NULL,
0,
&cbReturned ) ) {
printf( "ICAKEY KeyboardTest: Error 0x%x in IcaChannelIoControl\n", rc );
goto done;
}
KeyboardInputData.Flags = KEY_BREAK;
/*
* Now stuff the break
*/
if ( rc = IcaChannelIoControl( ghKeyboard,
IOCTL_KEYBOARD_ICA_INPUT,
&KeyboardInputData,
sizeof( KeyboardInputData ),
NULL,
0,
&cbReturned ) ) {
printf( "ICAKEY KeyboardTest: Error 0x%x in IcaChannelIoControl\n", rc );
goto done;
}
done:
return( rc );
}
Reference in New Issue View Git Blame Copy Permalink