rilhandndisoem1.cpp

手机RILGSM实现的源代码

//
// 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,POEMNDISINITIALIZEOUT);
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 OemNdisOpenRequest cbSize = %x \r\n"),pOemNdisChannel->OemNdisOpenRequest.cbSize));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry OemNdisOpenRequest dwParams = %x \r\n"),pOemNdisChannel->OemNdisOpenRequest.dwParams));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry OemNdisOpenRequest dwContextID = %x \r\n"),pOemNdisChannel->OemNdisOpenRequest.dwContextID));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry OemNdisOpenRequest fContextActivation = %x \r\n"),pOemNdisChannel->OemNdisOpenRequest.fContextActivation));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry OemNdisOpenRequest tszUserName = %s \r\n"),pOemNdisChannel->OemNdisOpenRequest.tszUserName));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry OemNdisOpenRequest tszPassword = %s \r\n"),pOemNdisChannel->OemNdisOpenRequest.tszPassword));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry OemNdisOpenRequest tszDNS1 = %s \r\n"),pOemNdisChannel->OemNdisOpenRequest.tszDNS1));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry OemNdisOpenRequest tszDNS2 = %s \r\n"),pOemNdisChannel->OemNdisOpenRequest.tszDNS2));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry OemNdisOpenRequest pfnNdisReceive = %x \r\n"),pOemNdisChannel->OemNdisOpenRequest.pfnNdisReceive));
		DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: DumpNdisChannelEntry OemNdisOpenRequest pCallbackContext = %x \r\n"),pOemNdisChannel->OemNdisOpenRequest.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 DumpPacket (RILNDISPACKET* lpPacket)
{
	if (ZONE_NDISPKTS)
		{
		if ( lpPacket )
			{
			LPRILNDISBUFFER lpRilNdisBuffer = NULL;
			wchar_t wLineBuf[256];
					
						   
			DEBUGMSG( ZONE_NDISPKTS , (TEXT("RILNDIS DumpPacket lpPacket = %x, dwSize = %x, dwContextId = %x, cBufferCount = %x,\r\n"), 
							 lpPacket, 
							 lpPacket->dwSize, 
							 lpPacket->dwContextId,
							 lpPacket->cBufferCount));	
							 
			   
		   lpRilNdisBuffer = lpPacket->NDISBuffer;

		   for(DWORD i=0; i<lpPacket->cBufferCount; i++)
				{
				DEBUGMSG( ZONE_NDISPKTS, (TEXT("RILNDIS: Dump Packet Buffer = %0x cByteCount = %0x"), lpRilNdisBuffer,	lpRilNdisBuffer->cByteCount));
				
				wcscpy(wLineBuf,L"");
				for(DWORD x=0; x<lpRilNdisBuffer->cByteCount; x++)
					{
					if ( lpRilNdisBuffer->pbyBytes[x] < 0x10 )
						{
						 _itow(0, &wLineBuf[wcslen(wLineBuf)], 16 );
						 _itow(lpRilNdisBuffer->pbyBytes[x], &wLineBuf[wcslen(wLineBuf)], 16);
						}
					else
						{
						 _itow(lpRilNdisBuffer->pbyBytes[x], &wLineBuf[wcslen(wLineBuf)], 16 );
						}
						
					wcscat(&wLineBuf[wcslen(wLineBuf)], L" ");
					if ( wcslen(wLineBuf) > 45)
						{
						DEBUGMSG( ZONE_NDISPKTS,(wLineBuf));
						wcscpy(wLineBuf,L"");
						}
					}
				if ( wcslen(wLineBuf))
					{
					DEBUGMSG( ZONE_NDISPKTS,(wLineBuf));
					wcscpy(wLineBuf,L"");
					}
				lpRilNdisBuffer++; 
				}
			}
		}
}

void DEBUG_TYPE( OEMNDISEVENTTYPE type)
{
	switch ( type )
		{
		case OEM_NDIS_RX_PACKET:			 /* Received a packet							*/
			break;
		case OEM_NDIS_TX_PACKET_COMPLETE:	 /* TX packet done - buffer can be reused		*/
			break;
		case OEM_NDIS_XOFF: 				 /* Please stop sending data to me				*/
			DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: OEM_NDIS_XOFF\r\n")));
			break;
		case OEM_NDIS_XON:					 /* Restart sending data to me					*/
			DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: OEM_NDIS_XON\r\n")));
			break;
		case OEM_NDIS_TX_PACKET:			 /* Request to transmit a packet				*/
			DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: OEM_NDIS_TX_PACKET\r\n")));
			break;
		case OEM_NDIS_RX_PACKET_COMPLETE:	 /* RX packet complete - buffer can be reused	*/
			DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: OEM_NDIS_RX_PACKET_COMPLETE\r\n")));
			break;
		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;
		}
}

void PacketPointers (RILNDISPACKET* lpPacket)
{
	if ( lpPacket )
		{
		LPRILNDISBUFFER pRilNdisBufferIn = NULL;
		
		DEBUGMSG( ZONE_NDISPKTS, (TEXT("RILNDIS: PacketPointer	Packet = %0x, Count = %x\r\n"), lpPacket, lpPacket->cBufferCount));
		
		if ( lpPacket->cBufferCount )
			{
			pRilNdisBufferIn = lpPacket->NDISBuffer;
				
			for(DWORD i=0; i<lpPacket->cBufferCount; i++)
				{
				DEBUGMSG( ZONE_NDISPKTS, (TEXT("RILNDIS: PacketPointer Buffer = %0x \r\n"), pRilNdisBufferIn->pbyBytes));
				pRilNdisBufferIn++;
				}
			}
		}
}

BOOL NdisPacketTest ( RILNDISPACKET* lpNdisPacket )
{
	BOOL fReturn = FALSE;

	DEBUGMSG(ZONE_NDISPKTS, (TEXT("RILNDIS: NdisPacketTest Packet = %x \r\n"), lpNdisPacket));	  

	if ( lpNdisPacket )
		{
		if ( lpNdisPacket->cBufferCount )
			{
			DEBUGMSG(ZONE_NDISPKTS, (TEXT("RILNDIS: NdisPacketTest cBufferCount = %d \r\n"), lpNdisPacket->cBufferCount));
			LPRILNDISBUFFER lpRilNdisBuffer = lpNdisPacket->NDISBuffer;
			DWORD dwBufferCount=0;
			for(DWORD i=0; i<lpNdisPacket->cBufferCount;i++)
				{
				DEBUGMSG(ZONE_NDISPKTS, (TEXT("RILNDIS: NdisPacketTest NDISBuffer[%d] = %x \r\n"), i, lpRilNdisBuffer));
				if ( lpRilNdisBuffer )
					{
					DEBUGMSG(ZONE_NDISPKTS, (TEXT("RILNDIS: NdisPacketTest NDISBuffer[%d].pbyBytes = %x, cByteCount = %x \r\n"), i, lpRilNdisBuffer->pbyBytes,lpRilNdisBuffer->cByteCount));
					if (lpRilNdisBuffer->pbyBytes /*&& lpRilNdisBuffer->cByteCount*/)
						{
						/* Apparently we can get buffers without any data. Don't fail the packet test if this is true */
						dwBufferCount++;
						lpRilNdisBuffer++;
						continue;
						}
					break;
					}
				}
			if ( dwBufferCount == lpNdisPacket->cBufferCount )
				{
				fReturn = TRUE;
				}
			}
		}
	ASSERT(fReturn);
	return ( fReturn );
}

#else
#define DumpNdisChannelEntry(a)
#define PacketPointers(a)
#define DEBUG_TYPE(a)
#define DumpPacket(a)
#define NdisPacketTest(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_TxMsgQueue = NULL;
	m_TxMsgQueueRead = NULL;
	m_RxMsgQueueWrite = NULL;
	m_pNdisChannels = NULL;
	m_NumNdisChannels = 0;
	m_Xon = RIL_NDIS_XON;
}

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]);