ddlxioct.cpp

wince5.0 pb中pccard源码

	case SPM_END_GROUP:

		dwRet = ShellProc( SPM_END_GROUP, NULL );
		break;

	case SPM_BEGIN_TEST:
	{
		LPSPS_BEGIN_TEST  lpBeginTest;

		lpBeginTest = (LPSPS_BEGIN_TEST)pBufIn;
		
		if( !lpBeginTest )
		{
			DEBUGMSG(ZONE_FUNCTION, (TEXT("IOControl, SHELLPROC, SPM_BEGIN_TEST pBufIn==NULL\r\n")));
			dwRet = SPR_NOT_HANDLED;
			break;
		}

		if( (int)dwLenIn < 0 )
		{
			DEBUGMSG(ZONE_FUNCTION, (TEXT("IOControl, SHELLPROC, SPM_BEGIN_TEST dwLenIn < 0\r\n")));
			dwRet = SPR_NOT_HANDLED;
			break;
		}

		if( (int)dwLenIn > g_iTblSize )
		{
			DEBUGMSG(ZONE_FUNCTION, (TEXT("IOControl, SHELLPROC, SPM_BEGIN_TEST dwLenIn > iTblSize\r\n")));
			dwRet = SPR_NOT_HANDLED;
			break;
		}

		lpBeginTest->lpFTE = & spsRegister.lpFunctionTable[dwLenIn];
		dwRet = ShellProc( SPM_BEGIN_TEST, (DWORD)lpBeginTest );

		break;
	}

	case SPM_END_TEST:
	{
		LPSPS_END_TEST lpEndTest;
		lpEndTest = (LPSPS_END_TEST)pBufIn;

		if( !lpEndTest )
		{
			DEBUGMSG(ZONE_FUNCTION, (TEXT("IOControl, SHELLPROC, SPM_END_TEST pBufIn==NULL\r\n")));
			dwRet = SPR_NOT_HANDLED;
			break;
		}
		
		if( (int)dwLenIn < 0 )
		{
			DEBUGMSG(ZONE_FUNCTION, (TEXT("IOControl, SHELLPROC, SPM_END_TEST dwLenIn < 0\r\n")));
			dwRet = SPR_NOT_HANDLED;
			break;
		}

		if( (int)dwLenIn > g_iTblSize )
		{
			DEBUGMSG(ZONE_FUNCTION, (TEXT("IOControl, SHELLPROC, SPM_END_TEST dwLenIn > g_iTblSize\r\n")));
			dwRet = SPR_NOT_HANDLED;
			break;
		}

		lpEndTest->lpFTE = & spsRegister.lpFunctionTable[dwLenIn];
		dwRet = ShellProc( SPM_END_TEST, (DWORD)lpEndTest );

		break;
	}

	case SPM_EXCEPTION:

		dwRet = SPR_NOT_HANDLED;
		break;

	default:

		dwRet = SPR_NOT_HANDLED;
		break;
	}

	// Return code is returned in pdwActualOut (if possible)
	if( pdwActualOut )
	{
		*pdwActualOut = dwRet;
	}

	return fRet;
}

// ----------------------------------------------------------------------------
// ProcessTestCommand
// ----------------------------------------------------------------------------

BOOL
ProcessTestCommand(	DWORD dwOpenData,		// handle identifying the open context of the device
				    UINT  uMsg, 			// test message
				   	PBYTE pBufIn,			// input buffer
					DWORD dwLenIn,			// input buffer length
					PBYTE pBufOut,			// output buffer
					DWORD dwLenOut, 		// output buffer length
					PDWORD pdwActualOut) {	// actual output length

	BOOL fRet = TRUE;
	BOOL fException = FALSE;
	DWORD	dwRet = TPR_PASS;
	DWORD dwException = 0;
	DWORD dwStructSize;
	LPFUNCTION_TABLE_ENTRY	lpFTE;
	LPEX_STRUCT lpvNewStructure;

	switch( uMsg )
	{
	case TPM_QUERY_THREAD_COUNT:
		dwStructSize = sizeof(TPS_QUERY_THREAD_COUNT);
		break;
	case TPM_EXECUTE:
		dwStructSize = sizeof(TPS_EXECUTE);
		break;
	default:
		DEBUGMSG(ZONE_WARNING, (TEXT("IOControl, TESTPROC, uMsg=0x%X (not handled).\r\n")));
		return FALSE;
	}

	if( (int)dwLenIn < 0 )
	{
		DEBUGMSG(ZONE_WARNING, (TEXT("IOControl, TESTPROC, dwLenIn < 0\r\n")));
		return SPR_NOT_HANDLED;
	}

	if( (int)dwLenIn > g_iTblSize )
	{
		DEBUGMSG(ZONE_WARNING, (TEXT("IOControl, TESTPROC, dwLenIn > FTE_TBL_SIZE\r\n")));
		return FALSE;
	}

	lpvNewStructure = (LPEX_STRUCT) malloc( sizeof(EX_STRUCT) + dwStructSize );
	if(lpvNewStructure == NULL){
		DEBUGMSG(ZONE_WARNING, (TEXT("IOControl, TESTPROC, not enough memory\r\n")));
		return FALSE;
	}
	memcpy( (lpvNewStructure+1), pBufIn, dwStructSize );
	lpvNewStructure->dwOpenData = dwOpenData;
	lpvNewStructure->dwNotOpenData = ~dwOpenData;

	lpFTE = & g_lpFTE[dwLenIn];

	__try
	{
		dwRet = (lpFTE->lpTestProc)( uMsg, (TPPARAM)(lpvNewStructure+1), lpFTE );
	}
	__except( EXCEPTION_EXECUTE_HANDLER )
	{
		fException = TRUE;
		dwException = _exception_code();
	}

	if ( fException )
	{
		DEBUGMSG(ZONE_ERROR, (TEXT("ProcessTestCommand, lpTestProc=0x%08x caused EXCEPTION 0x%08x.\r\n"),
			lpFTE->lpTestProc,
			dwException));
		free(lpvNewStructure);
		return FALSE;
	}

	// Return code is returned in pdwActualOut (if possible)
	if( pdwActualOut )
	{
		*pdwActualOut = dwRet;
	}

	// copy the data back to the input buffer (in case user data was requested)
	if( dwLenIn >= dwStructSize )
	{
		// this handles the case that the the TPM_QUERY_THREAD_COUNT
		// message was sent to the testproc and value > 0 was returned in 
		// the tpParam struct 
		memcpy( pBufIn, (lpvNewStructure+1), dwStructSize );
	}

	// Release the memory we asked for earlier.
	free( lpvNewStructure );
	
	return fRet;
}

// ----------------------------------------------------------------------------
// void DumpFunctionTableEntry ( LPFUNCTION_TABLE_ENTRY lpFTE )
// ----------------------------------------------------------------------------

void DumpFunctionTableEntry ( LPFUNCTION_TABLE_ENTRY lpFTE )
{
	DEBUGMSG(ZONE_VERBOSE, (TEXT("LPFUNCTION_TABLE_ENTRY = %lX\r\n"), lpFTE));

	if( lpFTE )
	{
		DEBUGMSG(ZONE_VERBOSE, (TEXT("uDepth         = %u\r\n"),
			lpFTE->uDepth));
		DEBUGMSG(ZONE_VERBOSE, (TEXT("dwUserData     = %lu\r\n"),
			lpFTE->uDepth));
		DEBUGMSG(ZONE_VERBOSE, (TEXT("dwUniqueId     = %lu\r\n"),
			lpFTE->uDepth));
		DEBUGMSG(ZONE_VERBOSE, (TEXT("lpDescription  = %lX\r\n"),
			lpFTE->lpDescription));
		DEBUGMSG(ZONE_VERBOSE, (TEXT("*lpDescription = \"%s\"\r\n"),
			lpFTE->lpDescription));
	}
}

// ----------------------------------------------------------------------------
// LPCTSTR ShellCmdToString( UINT uMsg )
// ----------------------------------------------------------------------------

LPCTSTR ShellCmdToString( UINT uMsg )
{
	LPCTSTR lpStr;

	switch( uMsg )
	{
		case SPM_LOAD_DLL:		lpStr = TEXT("SPM_LOAD_DLL");		break;
		case SPM_UNLOAD_DLL:	lpStr = TEXT("SPM_UNLOAD_DLL"); 	break;
		case SPM_SHELL_INFO:	lpStr = TEXT("SPM_SHELL_INFO"); 	break;
		case SPM_REGISTER:		lpStr = TEXT("SPM_REGISTER");		break;
		case SPM_START_SCRIPT:	lpStr = TEXT("SPM_START_SCRIPT");	break;
		case SPM_STOP_SCRIPT:	lpStr = TEXT("SPM_STOP_SCRIPT");	break;
		case SPM_BEGIN_GROUP:	lpStr = TEXT("SPM_BEGIN_GROUP");	break;
		case SPM_END_GROUP: 	lpStr = TEXT("SPM_END_GROUP");		break;
		case SPM_BEGIN_TEST:	lpStr = TEXT("SPM_BEGIN_TEST"); 	break;
		case SPM_END_TEST:		lpStr = TEXT("SPM_END_TEST");		break;
		case SPM_EXCEPTION: 	lpStr = TEXT("SPM_EXCEPTION");		break;
		default:				lpStr = TEXT("UNKNOWN");			break;
	}
	
	return lpStr;
}

// ----------------------------------------------------------------------------
// LPCTSTR TestCmdToString( UINT uMsg )
// ----------------------------------------------------------------------------

LPCTSTR TestCmdToString( UINT uMsg )
{
	LPCTSTR lpStr;

	switch( uMsg )
	{
		case	TPM_QUERY_THREAD_COUNT: lpStr = TEXT("TPM_QUERY_THREAD_COUNT"); break;
		case	TPM_EXECUTE:			lpStr = TEXT("TPM_EXECUTE");			break;
		default:						lpStr = TEXT("UNKNOWN");				break;
	}
	
	return lpStr;
}

// ----------------------------------------------------------------------------
// LPCTSTR DdlxGetCmdLine( TPPARAM tpParam )
// ----------------------------------------------------------------------------

extern "C" LPCTSTR DdlxGetCmdLine( TPPARAM tpParam )
{
	DEBUGMSG(ZONE_FUNCTION, (TEXT("++DdlxGetCmdLine\r\n")));

	LPEX_STRUCT lpExStruct = (LPEX_STRUCT)((PBYTE)tpParam - sizeof(EX_STRUCT));

	__try
	{
		if( lpExStruct->dwNotOpenData == ~(lpExStruct->dwOpenData) )
		{
			DEBUGMSG(ZONE_FUNCTION, (TEXT("--DdlxGetCmdLine - Command line[%d]: %s\r\n"),
				lpExStruct->dwOpenData, glpCommandLines[lpExStruct->dwOpenData]+1));
			return glpCommandLines[lpExStruct->dwOpenData]+1;
		}
	}
	__except( EXCEPTION_EXECUTE_HANDLER )
	{
		DEBUGMSG(ZONE_FUNCTION, (TEXT("--DdlxGetCmdLine - no valid pointer (exception)\r\n")));
		return NULL;
	}

	DEBUGMSG(ZONE_FUNCTION, (TEXT("--DdlxGetCmdLine - no valid pointer\r\n")));
	return NULL;
}

// ----------------------------------------------------------------------------
// extern "C" DWORD DdlxGetOpenContext( TPPARAM tpParam )
// ----------------------------------------------------------------------------

extern "C" DWORD DdlxGetOpenContext( TPPARAM tpParam )
{
	DEBUGMSG(ZONE_FUNCTION, (TEXT("++DdlxGetOpenContext\r\n")));

	LPEX_STRUCT lpExStruct = (LPEX_STRUCT)((PBYTE)tpParam - sizeof(EX_STRUCT));

	__try
	{
		if( lpExStruct->dwNotOpenData == ~(lpExStruct->dwOpenData) )
		{
			DEBUGMSG(ZONE_FUNCTION, (TEXT("--DdlxGetOpenContext - dwOpenData: %d\r\n"), lpExStruct->dwOpenData));
			return lpExStruct->dwOpenData;
		}
	}
	__except( EXCEPTION_EXECUTE_HANDLER )
	{
		DEBUGMSG(ZONE_FUNCTION, (TEXT("--DdlxGetOpenContext - no valid pointer (exception)\r\n")));
		return 0;
	}

	DEBUGMSG(ZONE_FUNCTION, (TEXT("--DdlxGetOpenContext - no valid pointer\r\n")));
	return 0;
}


//
// implementation of the kato listener class
//

BOOL
DDLXKato_Talk::Init(){

	MSGQUEUEOPTIONS msgqopts = {0};

	//if we do not use message queue, we 
	//just return 
	if(bUseMsgQueue == FALSE){
		pKato = (CKato *)KatoGetDefaultObject();
		return TRUE;
	}
 	// create a global message queue
    	msgqopts.dwSize = sizeof(MSGQUEUEOPTIONS);
    	msgqopts.dwFlags = MSGQUEUE_ALLOW_BROKEN;
    	msgqopts.dwMaxMessages = 0;
    	msgqopts.cbMaxMessage = sizeof(KATOMSGFORMAT);
    	msgqopts.bReadAccess = FALSE; 
		
    	hMsgQueue = NULL;
    	hMsgQueue = CreateMsgQueue(QUEUENAME, &msgqopts);
	if(hMsgQueue == NULL){
		NKDbgPrintfW(_T("WARNING: MessageQueue \"%s\" can not be created"), QUEUENAME);
		return FALSE;
	}

	return TRUE;
}

BOOL
DDLXKato_Talk::Stop(){
	
	CloseMsgQueue(hMsgQueue);

	return TRUE;

}

INT
DDLXKato_Talk::BeginLevel (DWORD dwLevelID, LPCWSTR wszFormat, ...){
	va_list pArgs; 
   	va_start(pArgs, wszFormat);

	KATOMSGFORMAT	msg={0};
	DWORD	dwCount = 0;
	
	ASSERT(hMsgQueue);
	
	msg.dwCommand = C_BeginLevel;
	msg.dwOption = dwLevelID;
      _vsnwprintf(msg.szMsg, KATO_MAX_STRING_LENGTH, wszFormat, pArgs);

	if(bUseMsgQueue == FALSE){
		pKato->BeginLevel(dwLevelID, msg.szMsg);
		return 0;
	}
	
	do{
		if(WriteMsgQueue(hMsgQueue, &msg, sizeof(KATOMSGFORMAT), TALK_WAIT_TIME, 0) == FALSE){
			dwCount ++; //failed, go to retry again
		}
		else
			break;
	}while(dwCount < 100);

	va_end(pArgs);

	if(dwCount >= 100)
		return -1;

	return 0;
}


INT
DDLXKato_Talk::EndLevel (LPCWSTR wszFormat, ...){
	va_list pArgs; 
   	va_start(pArgs, wszFormat);

	KATOMSGFORMAT	msg={0};
	DWORD	dwCount = 0;
	
	ASSERT(hMsgQueue);
	
	msg.dwCommand = C_EndLevel;
      _vsnwprintf(msg.szMsg, KATO_MAX_STRING_LENGTH, wszFormat, pArgs);

	if(bUseMsgQueue == FALSE){
		pKato->EndLevel(msg.szMsg);
		return 0;
	}

	do{
		if(WriteMsgQueue(hMsgQueue, &msg, sizeof(KATOMSGFORMAT), TALK_WAIT_TIME, 0) == FALSE){
			dwCount ++; //failed, go to retry again
		}
		else
			break;
	}while(dwCount < 100);

	va_end(pArgs);

	if(dwCount >= 100)
		return -1;

	return 0;
}

INT
DDLXKato_Talk::Log (DWORD dwVerbosity, LPCWSTR wszFormat, ...){
	va_list pArgs; 
   	va_start(pArgs, wszFormat);

	KATOMSGFORMAT	msg={0};
	DWORD	dwCount = 0;
	
	ASSERT(hMsgQueue);
	
	msg.dwCommand = C_Log;
	msg.dwOption = dwVerbosity;
      _vsnwprintf(msg.szMsg, KATO_MAX_STRING_LENGTH, wszFormat, pArgs);

	if(bUseMsgQueue == FALSE){
		pKato->Log(dwVerbosity, msg.szMsg);
		return 0;
	}

	do{
		if(WriteMsgQueue(hMsgQueue, &msg, sizeof(KATOMSGFORMAT), TALK_WAIT_TIME, 0) == FALSE){
			dwCount ++; //failed, go to retry again
		}
		else
			break;
	}while(dwCount < 100);

	va_end(pArgs);

	if(dwCount >= 100)
		return -1;

	return 0;
}


INT
DDLXKato_Talk::Comment (DWORD dwVerbosity, LPCWSTR wszFormat, ...){
	va_list pArgs; 
   	va_start(pArgs, wszFormat);

	KATOMSGFORMAT	msg={0};
	DWORD	dwCount = 0;
	
	ASSERT(hMsgQueue);
	
	msg.dwCommand = C_Comment;
	msg.dwOption = dwVerbosity;
      _vsnwprintf(msg.szMsg, KATO_MAX_STRING_LENGTH, wszFormat, pArgs);

	if(bUseMsgQueue == FALSE){
		pKato->Comment(dwVerbosity, msg.szMsg);
		return 0;
	}

	do{
		if(WriteMsgQueue(hMsgQueue, &msg, sizeof(KATOMSGFORMAT), TALK_WAIT_TIME, 0) == FALSE){
			dwCount ++; //failed, go to retry again
		}
		else
			break;
	}while(dwCount < 100);

	va_end(pArgs);
	
	if(dwCount >= 100)
		return -1;

	return 0;
}