rilhandndisoem1.cpp

windows mobile RIL软件

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of your Microsoft Windows CE
// Source Alliance Program license form.  If you did not accept the terms of
// such a license, you are not authorized to use this source code.
//

#if defined(OEM1_DRIVER)
#define DELAYLD_NO_GETPROCFROMDLL
#include "precomp.h"
#include <linklist.h>
#include "simmgr.h"
#include "rilndisoem1.h"
#include <Delayld.h>


HINSTANCE g_hinstOEMNDIS /*= NULL*/;

#define OEM_LIBRARY TEXT("csmi")
#define OEM_NdisInitialize TEXT("NdisInitialize")
#define OEM_NdisShutdown   TEXT("NdisShutdown")
#define MAX_IP_ADDRESS_LENGTH 4
typedef HRESULT  (*PFN_NDIS_INITIALIZE)(POEMNDISINITIALIZE);
typedef HRESULT  (*PFN_NDIS_SHUTDOWN)(void);

PFN_NDIS_INITIALIZE 	 g_pfnNdisInitialize;
PFN_NDIS_SHUTDOWN		 g_pfnNdisShutdown;

HINSTANCE LoadPacketLib()
{
	if (!g_hinstOEMNDIS)
		{
		g_hinstOEMNDIS = LoadLibrary(OEM_LIBRARY);
		}
	return g_hinstOEMNDIS;
}

BOOL WaitForCloseResponse(void)
{
	return TRUE;
}

HRESULT GetPacketInterface()
{
	HRESULT Result = E_FAIL;

	HINSTANCE hinst;
	hinst = LoadPacketLib();
	if (hinst)
		{
		g_pfnNdisInitialize =	 (PFN_NDIS_INITIALIZE)GetProcAddress(hinst, OEM_NdisInitialize );
		g_pfnNdisShutdown = 	 (PFN_NDIS_SHUTDOWN)GetProcAddress(hinst, OEM_NdisShutdown );
		if (g_pfnNdisInitialize && g_pfnNdisShutdown )
			{
			Result = S_OK;
			}
		}
	DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: GetPacketInterface LoadLib = %x Initialize = %x Shutdown = %x\r\n"), hinst, g_pfnNdisInitialize, g_pfnNdisShutdown));
	return Result;
}

DWORD WINAPI NdisNotifyThreadProc(LPVOID lpParameter);

// **************************************************************************
// Function Name:  NdisNotifyThreadProc
// 
// Purpose: 	   Process NDIS events from radio.
//
// Arguments: 
//
// Return Values:  
//
// Side effects:  
// 
// Description:   
// **************************************************************************
DWORD WINAPI NdisNotifyThreadProc(LPVOID lpParameter)
{
	CRilHandle* pRilDevice = (CRilHandle*)lpParameter;
	DWORD dwResult;

	if (!CeSetThreadPriority(GetCurrentThread(), 116))
		{
		return 0;
		}

	dwResult = pRilDevice->CRilNdis.NdisNotifyThread();

	return dwResult;
}
#if defined DEBUG

void DumpNdisChannelEntry( POEMNDISCHANNELS pOemNdisChannel )
{
	DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry = %x \r\n"), pOemNdisChannel ));

	if ( pOemNdisChannel )
		{
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry ContextID = %x \r\n"),pOemNdisChannel->ContextID));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry pCRilInstance = %x \r\n"),pOemNdisChannel->pCRilInstance));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry pCPdpContext = %x \r\n"),pOemNdisChannel->pCPdpContext));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry RilNdisGprsContext cbSize = %x \r\n"),pOemNdisChannel->RilNdisGprsContext.cbSize));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry RilNdisGprsContext dwParams = %x \r\n"),pOemNdisChannel->RilNdisGprsContext.dwParams));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry RilNdisGprsContext dwContextID = %x \r\n"),pOemNdisChannel->RilNdisGprsContext.dwContextID));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry RilNdisGprsContext fContextActivation = %x \r\n"),pOemNdisChannel->RilNdisGprsContext.fContextActivation));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry RilNdisGprsContext tszUserName = %s \r\n"),pOemNdisChannel->RilNdisGprsContext.tszUserName));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry RilNdisGprsContext tszPassword = %s \r\n"),pOemNdisChannel->RilNdisGprsContext.tszPassword));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry RilNdisGprsContext tszDNS1 = %s \r\n"),pOemNdisChannel->RilNdisGprsContext.tszDNS1));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry RilNdisGprsContext tszDNS2 = %s \r\n"),pOemNdisChannel->RilNdisGprsContext.tszDNS2));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry RilNdisGprsContext pfnNdisReceivePacket = %x \r\n"),pOemNdisChannel->RilNdisGprsContext.pfnNdisReceive));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry RilNdisGprsContext pfnNdisTransmitDone = %x \r\n"),pOemNdisChannel->RilNdisGprsContext.pfnNdisTransmit));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry RilNdisGprsContext pfnNdisStatus = %x \r\n"),pOemNdisChannel->RilNdisGprsContext.pfnNdisStatus));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry RilNdisGprsContext pCallbackContext = %x \r\n"),pOemNdisChannel->RilNdisGprsContext.pCallbackContext));

		}

}

void DumpNdisIPConfig( RILNDISIPCONFIG* pRilNdisIpConfig )
{
	if ( pRilNdisIpConfig )
		{
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisIPConfig cbSize = %x \r\n"),pRilNdisIpConfig->cbSize));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisIPConfig dwContextId = %x \r\n"),pRilNdisIpConfig->dwContextId));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisIPConfig dwProtocol = %x \r\n"),pRilNdisIpConfig->dwProtocol));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisIPConfig ipv4.dwFlags = %x \r\n"),pRilNdisIpConfig->ipv4.dwFlags));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisIPConfig ipv4.inIPAddress = %x \r\n"),pRilNdisIpConfig->ipv4.inIPAddress));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisIPConfig ipv4.inPrimaryDNS = %x \r\n"),pRilNdisIpConfig->ipv4.inPrimaryDNS));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisIPConfig ipv4.inSecondaryDNS = %x \r\n"),pRilNdisIpConfig->ipv4.inSecondaryDNS));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisIPConfig ipv4.inDefaultGateway = %x \r\n"),pRilNdisIpConfig->ipv4.inDefaultGateway));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisIPConfig ipv4.inSubnetMask = %x \r\n"),pRilNdisIpConfig->ipv4.inSubnetMask));

		}
}

void DEBUG_TYPE( OEMNDISEVENTTYPE type)
{
	switch ( type )
		{
		case OEM_NDIS_OPEN_COMPLETE:	/* RX packet complete - buffer can be reused   */
			DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: OEM_NDIS_OPEN_COMPLETE\r\n")));
			break;
		case OEM_NDIS_CLOSE_COMPLETE:	 /* RX packet complete - buffer can be reused	*/
			DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: OEM_NDIS_CLOSE_COMPLETE\r\n")));
			break;
		}
}

#else
#define DumpNdisChannelEntry(a)
#define DEBUG_TYPE(a)
#define DumpNdisIPConfig(a)
#endif

// **************************************************************************
// Function Name:  myinet_addr
// 
// Purpose: Convert string IP address into a DWORD
//
// Arguments: 
//
// Return Values:  
//
// Side effects:  
// 
// Description:   
// **************************************************************************

DWORD myinet_addr(const UCHAR *lpString, UCHAR length)
{
  DWORD dwIpAddr = 0;
  
	if ( length > MAX_IP_ADDRESS_LENGTH  )
		{
		length = MAX_IP_ADDRESS_LENGTH;
		}
	 
	for(int i=0; i<length; i++)
		{
		if ( i )
			{
			dwIpAddr <<= 8;
			}
		dwIpAddr |= lpString[i];
		}
	
	return dwIpAddr;
}

// **************************************************************************
// Function Name:  myinet_ipv6addr
//
// Purpose: Convert string IPV6 address into a RILNDISIPV6ADDR
//
// Arguments:
//
// Return Values: RILNDISIPV6ADDR struct
//
// Side effects:
//
// Description:
// **************************************************************************
RILNDISIPV6ADDR myinet_ipv6addr(const UCHAR *lpString, UCHAR length)
{
	RILNDISIPV6ADDR ipv6addr;

	memset( &ipv6addr, 0, sizeof(ipv6addr) );

	if ( length == IPV6_ADDRESS_LENGTH )
		{
		memcpy( ipv6addr.Byte, lpString, (IPV6_ADDRESS_LENGTH_IN_UCHAR*sizeof(UCHAR)) );
		}

	return ipv6addr;
}


CRilNDIS::CRilNDIS()
{
	m_pCRilHandle = NULL;
	m_RxMsgQueue = NULL;
	m_RxMsgQueueWrite = NULL;
	m_pNdisChannels = NULL;
	m_NumNdisChannels = 0;
	m_NdisNotifyThread = NULL;
}

CRilNDIS::~CRilNDIS()
{
	m_pCRilHandle = NULL;
}

void CRilNDIS::Init(PVOID pHandle)
{
	m_pCRilHandle = pHandle;
}

BOOL CRilNDIS::NdisStart ( HANDLE CancelEvent )
{
	m_NdisNotifyThread = NULL;
	m_NdisNotifyThreadID = 0;
	m_CancelEvent = CancelEvent;
	m_NdisNotifyThread = CreateThread(NULL, 0, NdisNotifyThreadProc, (LPVOID)m_pCRilHandle, 0, &m_NdisNotifyThreadID);
	if ( m_NdisNotifyThread )
		{
		InitializeCriticalSection(&m_NdisEventList);
		InitializeCriticalSection(&m_ConnectionList);
		InitializeCriticalSection(&m_PdpContextCriticalSection);
		InitializeListHead(&m_PdpContextPendingList);
		InitializeListHead(&m_PdpContextFreeList);
		}

	if ( FAILED(GetPacketInterface()))
		{
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: NdisStart GetPacketInterface FAILED \r\n")));
		}

	return (m_NdisNotifyThread ? TRUE : FALSE );
}

void CRilNDIS::NdisStop( void )
{
	if ( m_NdisNotifyThread )
		{
		(void)WaitForSingleObject(m_NdisNotifyThread,10000);
		(void)CloseHandle(m_NdisNotifyThread);
		m_NdisNotifyThread = NULL;
		m_NdisNotifyThreadID = 0;
		DeleteCriticalSection(&m_NdisEventList);
		DeleteCriticalSection(&m_ConnectionList);
		DeleteCriticalSection(&m_PdpContextCriticalSection);
		}
}

HRESULT
CRilNDIS::NdisGetFreeEntry ( DWORD *Index )
{
	HRESULT Result = E_FAIL;
	EnterCriticalSection(&m_ConnectionList);
	for ( DWORD IndexCount=0; IndexCount<m_NumNdisChannels; IndexCount++)
		{
		DumpNdisChannelEntry(&m_pNdisChannels[IndexCount]);
		if ( 0 == m_pNdisChannels[IndexCount].ContextID )
			{
			Result = S_OK;
			*Index = IndexCount;
			break;
			}
		}
	LeaveCriticalSection(&m_ConnectionList);
	return Result;
}

void	
CRilNDIS::NdisRemoveNdisEntry ( DWORD ContextID )
{
	EnterCriticalSection(&m_ConnectionList);
	for(DWORD i=0;i<m_NumNdisChannels;i++)
		{
		if ( ContextID && (m_pNdisChannels[i].ContextID == ContextID) ) 
			{
			if ( m_pNdisChannels[i].pCPdpContext )
				{
				delete (CPdpContext*)m_pNdisChannels[i].pCPdpContext;
				}
			m_NdisAsyncCommandList.RemoveAllCommands( ContextID );
			memset( &m_pNdisChannels[i], 0, sizeof(OEMNDISCHANNELS)); 
			break;
			}
		}
	LeaveCriticalSection(&m_ConnectionList);			
}

void	
CRilNDIS::NdisAddNdisEntry ( DWORD ContextID, DWORD Index, PVOID pCRilInstance, PVOID pCPdpContext, const RILNDISGPRSCONTEXT *lpRilNdisGprsContext )
{	 
	DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: NdisAddNdisEntry cid = %x, index = %x, pCrilInstance = %x pCPdpContext = %x \r\n"), ContextID, Index, pCRilInstance, pCPdpContext));
	EnterCriticalSection(&m_ConnectionList);
	ASSERT((Index >= 0) && (Index < m_NumNdisChannels));
	if ( pCRilInstance )
		{
		m_pNdisChannels[Index].ContextID= ContextID;
		m_pNdisChannels[Index].pCRilInstance = pCRilInstance;
		m_pNdisChannels[Index].pCPdpContext = pCPdpContext;
		CeSafeCopyMemory(&m_pNdisChannels[Index].RilNdisGprsContext, lpRilNdisGprsContext, sizeof(m_pNdisChannels[Index].RilNdisGprsContext));
		DumpNdisChannelEntry(&m_pNdisChannels[Index]);
		}
	LeaveCriticalSection(&m_ConnectionList);
}

PVOID
CRilNDIS::NdisPdpContextFromCid( DWORD ContextID  )
{
	PVOID pReturn = NULL;
	EnterCriticalSection(&m_ConnectionList);
	for(DWORD i=0;i<m_NumNdisChannels;i++)
		{
		if ( ContextID && (m_pNdisChannels[i].ContextID== ContextID) )
			{
			pReturn = m_pNdisChannels[i].pCPdpContext;
			break;
			}
		}
	LeaveCriticalSection(&m_ConnectionList);   
	return pReturn;
}
// **************************************************************************
// Function Name: NdisRilInstanceFromHandle
// 
// Purpose: 	  Search of the NDIS channel handle associated with a cid.
//
// Arguments:	  IN cid, OUT hNdisHandle
//
// Return Values: E_FAIL if not found.
//
// Side effects:  
// 
// Description:   
// **************************************************************************
VOID* CRilNDIS::NdisRilInstanceFromCID( DWORD ContextID )
{
	PVOID pReturn = NULL;
	EnterCriticalSection(&m_ConnectionList);
	for(DWORD i=0;i<m_NumNdisChannels;i++)
		{
		if ( ContextID && (m_pNdisChannels[i].ContextID == ContextID) )
			{
			pReturn = m_pNdisChannels[i].pCRilInstance;
			break;
			}
		}
	LeaveCriticalSection(&m_ConnectionList);   
	return pReturn;
}

// **************************************************************************
// Function Name: NdisRilCallbackFromCID
// 
// Purpose: 	  Search of the NDIS channel handle associated with a cid.
//
// Arguments:	  IN cid, OUT hNdisHandle
//
// Return Values: E_FAIL if not found.
//
// Side effects:  
// 
// Description:   
// **************************************************************************
void CRilNDIS::NdisRilCallbacksFromCID( DWORD ContextID, PVOID *pCallbackContext, RILNDISRECEIVECALLBACK *pfnRilReceiveCallback, RILNDISTRANSMITCALLBACK *pfnRilTransmitCallback, RILNDISSTATUSCALLBACK *pfnRilStatusCallback)
{
	EnterCriticalSection(&m_ConnectionList);
	*pfnRilReceiveCallback = NULL;
	*pfnRilTransmitCallback = NULL;
	*pfnRilStatusCallback = NULL;
	*pCallbackContext = NULL;
	for(DWORD i=0;i<m_NumNdisChannels;i++)
		{
		if ( ContextID && (m_pNdisChannels[i].ContextID == ContextID) )
			{
			*pfnRilReceiveCallback = m_pNdisChannels[i].RilNdisGprsContext.pfnNdisReceive;
			*pfnRilTransmitCallback = m_pNdisChannels[i].RilNdisGprsContext.pfnNdisTransmit;
			*pfnRilStatusCallback = m_pNdisChannels[i].RilNdisGprsContext.pfnNdisStatus;
			*pCallbackContext = m_pNdisChannels[i].RilNdisGprsContext.pCallbackContext;
			break;
			}
		}
	LeaveCriticalSection(&m_ConnectionList);   
}

// **************************************************************************
// Function Name: NdisRilGprsContextFromCID
// 
// Purpose: 	  Search of the NDIS channel handle associated with a cid.