rilhandndisoem1.cpp

windows mobile RIL软件

														AsyncCommandID, 
														&Result, 
														sizeof(Result));
						 pCrilHandle->CRilNdis.NdisRemoveCommand(AsyncCommandID);
						}
					}
				}
			else
				{
				if ( FALSE == NdisSetGprsContextActivated.fContextActivation )
					{
					if ( pCPdpContext) 
						{
						pCrilHandle->CRilNdis.NdisRemoveCallbacks(NdisSetGprsContextActivated.dwContextID);
						pCrilHandle->CRilNdis.NdisAllocateCommand ( OEM_NDIS_CLOSE_COMPLETE, NdisSetGprsContextActivated.dwContextID, (LPVOID)m_pCrilInstance, AsyncCommandID ); 
						Result = pCPdpContext->ActivateContext((PVOID) &NdisSetGprsContextActivated);
						if ( FAILED(Result))
							{
							DEBUGMSG(ZONE_NDIS, (TEXT("RILNDIS: NdisSetGPRSContextActivated  CLOSE handle = %x Call FAILED\r\n"), pCPdpContext));
							pCrilHandle->CRilNdis.NdisShutdownConnection ( NdisSetGprsContextActivated.dwContextID );
							}
						else
							{
							DEBUGMSG(ZONE_NDIS, (TEXT("RILNDIS: NdisSetGPRSContextActivated  CLOSE handle = %x \r\n"), pCPdpContext));
							pCrilHandle->CRilNdis.AddPdpContextEntry(&NdisSetGprsContextActivated,AsyncCommandID,(PVOID)m_pCrilInstance);
							if (FALSE == WaitForCloseResponse())
								{
								Result =  RIL_RESULT_OK;
								((CRilInstanceHandle*)m_pCrilInstance)->Notify(Result, 
														AsyncCommandID, 
														&Result, 
														sizeof(Result));
								pCrilHandle->CRilNdis.NdisRemoveCommand(AsyncCommandID);
								}
							}
						}
					else // No connection object - no connection
						{
						Result = RIL_E_INVALIDCONTEXTSTATE; 
						}
					}
				else 
					{
					if ( NULL == pCPdpContext) // This should normally be the case.
						{ 
						// Check to see if there are any available to initialise.
						if ( SUCCEEDED(pCrilHandle->CRilNdis.NdisGetFreeEntry( &Index)) )
							{
							pCPdpContext = new CPdpContext(NdisRxMsgQueueWriteHandle);
							if ( pCPdpContext )
								{
								pCrilHandle->CRilNdis.NdisAddNdisEntry(NdisSetGprsContextActivated.dwContextID,	Index, m_pCrilInstance, pCPdpContext, &NdisSetGprsContextActivated ); 
								pCrilHandle->CRilNdis.NdisAllocateCommand ( OEM_NDIS_OPEN_COMPLETE, NdisSetGprsContextActivated.dwContextID, (LPVOID)m_pCrilInstance, AsyncCommandID);
								Result = pCPdpContext->ActivateContext((PVOID) &NdisSetGprsContextActivated);
								if ( FAILED(Result))
									{
									pCrilHandle->CRilNdis.NdisRemoveNdisEntry(NdisSetGprsContextActivated.dwContextID);
									}
								else
									{
									pCrilHandle->CRilNdis.AddPdpContextEntry(&NdisSetGprsContextActivated,AsyncCommandID,(PVOID)m_pCrilInstance);
									}
								}
							}
						else
							{
							Result = RIL_E_MAXCONTEXTS;
							}
						}  
					else // connection object - connection
						{
						Result = RIL_E_INVALIDCONTEXTSTATE;
						}
					}
				}
				pCrilHandle->CRilNdis.UnlockPdpContextList();
			}
		}

	if ( FAILED(Result) )
		{
			pCrilHandle->CRilNdis.NdisRemoveCommand( AsyncCommandID );
			AsyncCommandID = Result;
		}

	return AsyncCommandID;
}

// **************************************************************************
// Function Name: NdisReceivePacketDone
// 
// Purpose: 	 Notify the NDIS radio that the Rx packet has been consumed.
//
// Arguments:	 IN Rx packet pointer
//
// Return Values:  E_FAIL if error detected.
//				   Command result for async response.
//
// Side effects:  
// 
// Description:   
// **************************************************************************
HRESULT CRilInstanceNDIS::NdisReceivePacketDone (RILNDISPACKET* lpNdisPacket)
{
	 return S_OK;
}

CAsyncResponse::CAsyncResponse()
{
	InitializeCriticalSection(&m_cs);
	InitializeListHead(&m_AsyncPendingList);
	InitializeListHead(&m_AsyncFreeList);
}


CAsyncResponse::~CAsyncResponse()
{
	PASYNCCOMMAND pEntry;
	BOOL ExitNow = FALSE;
	//
	// Find entry with matching ContextID in our list of pending requests
	//
	AsyncListLock();
	while ( FALSE == ExitNow )
		{
		for (pEntry = (PASYNCCOMMAND)(m_AsyncPendingList.Flink);
			 TRUE;
			 pEntry = (PASYNCCOMMAND)pEntry->Node.Flink)
			{
			if (pEntry == (PASYNCCOMMAND)(&m_AsyncPendingList))
				{
				ExitNow = TRUE;
				break;
				}

			RemoveEntryList(&pEntry->Node);
			InsertTailList(&m_AsyncFreeList, &pEntry->Node);
			break;
			}
		}
	ExitNow = FALSE;
	while ( FALSE == ExitNow )
		{
		for (pEntry = (PASYNCCOMMAND)(m_AsyncFreeList.Flink);
			 TRUE;
			 pEntry = (PASYNCCOMMAND)pEntry->Node.Flink)
			{
			if (pEntry == (PASYNCCOMMAND)(&m_AsyncFreeList))
				{
				ExitNow = TRUE;
				break;
				}
			RemoveEntryList(&pEntry->Node);
			LocalFree ( pEntry );
			break;
			}
		}
	AsyncListUnlock();
}


void 
CAsyncResponse::AddCommand ( OEMNDISAPIREFERENCE *lpOemNdisApiReference )
{

	PASYNCCOMMAND pEntry = NULL;

	if ( lpOemNdisApiReference )
		{
		AsyncListLock();
		if (!IsListEmpty(&m_AsyncFreeList))
			{
			pEntry = (PASYNCCOMMAND)RemoveHeadList(&m_AsyncFreeList);
			}

		if (pEntry == NULL)
			{
			pEntry = (PASYNCCOMMAND)LocalAlloc(LPTR, sizeof(*pEntry));
			}

		if ( pEntry )
			{
			memcpy(&pEntry->OemNdisApiReference, lpOemNdisApiReference, sizeof(OEMNDISAPIREFERENCE));
			}
		InsertTailList(&m_AsyncPendingList, &pEntry->Node);
		AsyncListUnlock();
		}
}

void 
CAsyncResponse::RemoveCommand( HRESULT CommandID )
{
	if ( CommandID )
		{
		PASYNCCOMMAND pEntry;
  
		AsyncListLock();
		for (pEntry = (PASYNCCOMMAND)(m_AsyncPendingList.Flink);
			 TRUE;
			 pEntry = (PASYNCCOMMAND)pEntry->Node.Flink)
			{
			if (pEntry == (PASYNCCOMMAND)(&m_AsyncPendingList))
				{
				DEBUGMSG(ZONE_NDIS, (TEXT("RILNDIS: RemoveCommand  CommandID = %x NOT FOUND\r\n"), CommandID));
				break;
				}

			if ( pEntry->OemNdisApiReference.CommandID == CommandID )
				{
				RemoveEntryList(&pEntry->Node);
				InsertTailList(&m_AsyncFreeList, &pEntry->Node);
				break;
				}
			}
		AsyncListUnlock();
		}
}


void 
CAsyncResponse::ProcessCommand ( const OEMNDISAPIREFERENCE *lpOemNdisApiReference )
{
	
	if ( lpOemNdisApiReference )
		{
		CRilInstanceHandle* pCRilInstance=NULL;
		PASYNCCOMMAND pEntry;
	  

		AsyncListLock();  
		for (pEntry = (PASYNCCOMMAND)(m_AsyncPendingList.Flink);
			 TRUE;
			 pEntry = (PASYNCCOMMAND)pEntry->Node.Flink)
			{

			if (pEntry == (PASYNCCOMMAND)(&m_AsyncPendingList))
			{
			DEBUGMSG(ZONE_NDIS, (TEXT("RILNDIS: ProcessCommand Notify FAILED \r\n")));
			break;
			}

			// Result for other event. Success is passed via the status member of the input structure.
			if ( lpOemNdisApiReference->EventType )
				{
				if ( (lpOemNdisApiReference->EventType == pEntry->OemNdisApiReference.EventType) &&
					(lpOemNdisApiReference->ContextID == pEntry->OemNdisApiReference.ContextID))
					{
					pCRilInstance = (CRilInstanceHandle*)pEntry->OemNdisApiReference.pCRilInstance;
					if ( pCRilInstance )
						{
						DWORD Result = lpOemNdisApiReference->Status ? RIL_RESULT_ERROR : RIL_RESULT_OK;
						pCRilInstance->Notify(	Result, 
									pEntry->OemNdisApiReference.CommandID, 
									&lpOemNdisApiReference->RilNdisGprsContextResponse, 
									sizeof(lpOemNdisApiReference->RilNdisGprsContextResponse));
						DEBUGMSG(ZONE_NDIS, (TEXT("RILNDIS: ProcessCommand Notify Command Status = %x Comamand ID = %0x \r\n"), 
									Result, 
									pEntry->OemNdisApiReference.CommandID));
						}
					RemoveEntryList(&pEntry->Node);
					InsertTailList(&m_AsyncFreeList, &pEntry->Node);
					break;
					}
				}
			}
		AsyncListUnlock();
		}
}

void 
CAsyncResponse::RemoveAllCommands( DWORD ContextID )
{
	PASYNCCOMMAND pEntry;
	BOOL ExitNow = FALSE;
	//
	// Find entry with matching ContextID in our list of pending requests
	//
	AsyncListLock();
	while ( FALSE == ExitNow )
		{
		for (pEntry = (PASYNCCOMMAND)(m_AsyncPendingList.Flink);
			 TRUE;
			 pEntry = (PASYNCCOMMAND)pEntry->Node.Flink)
			{
			if (pEntry == (PASYNCCOMMAND)(&m_AsyncPendingList))
				{
				ExitNow = TRUE;
				break;
				}
			if ( ContextID == pEntry->OemNdisApiReference.ContextID )
				{
				RemoveEntryList(&pEntry->Node);
				InsertTailList(&m_AsyncFreeList, &pEntry->Node);
				break;
				}
			}
		}
	AsyncListUnlock();
}

inline void
CAsyncResponse::AsyncListLock()
{
	EnterCriticalSection(&m_cs);
}

inline void
CAsyncResponse::AsyncListUnlock()
{
	LeaveCriticalSection(&m_cs);
}
DWORD WINAPI ProcessObjectsThreadProc(LPVOID pParameter);


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CPdpContext::CPdpContext(PVOID pEventNotification )
{
	InitializeCriticalSection(&m_Lock);
	m_ProcessObjextsThreadID = 0;
	m_CrilCancelEvent = NULL;
	m_ContextID = 0;
	m_CrilAsyncCommandDone = NULL;
	m_RilResultCode = 0;
	m_ActivationState = ACTIVATION_STATE_DISCONNECTED;
	memset(&m_OemNdisIpConfig, 0, sizeof(m_OemNdisIpConfig));

	if ( pEventNotification )
		{
		m_AppMsgQueue = pEventNotification;
		
		m_ProcessObjectsThread = CreateThread(NULL, 0, ProcessObjectsThreadProc, (LPVOID)this, 0, &m_ProcessObjextsThreadID);
		}

	DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS CPdpContext: CPdpContext Create Connection Object %x \r\n"), this));
}

CPdpContext::~CPdpContext()
{
	DWORD ExitCode;
	DeleteCriticalSection(&m_Lock);

	if ( m_ProcessObjectsThread  )
		{
		if ( NULL == m_CrilCancelEvent )
			{
			if ( GetExitCodeThread(m_ProcessObjectsThread, &ExitCode ))
				{
				if ( STILL_ACTIVE == ExitCode )
					{
					Sleep(100);
					}
				}
			}
		
		if ( m_CrilCancelEvent )
			{
			SetEvent(m_CrilCancelEvent);
			WaitForSingleObject(m_ProcessObjectsThread, INFINITE );
			CloseHandle(m_ProcessObjectsThread);
			}
		}
	DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS CPdpContext: CPdpContext Delete Connection Object %x \r\n"), this));
}

inline void
CPdpContext::Lock()
{
	EnterCriticalSection(&m_Lock);
}

inline void
CPdpContext::Unlock()
{
	LeaveCriticalSection(&m_Lock);
}

inline BOOL
CPdpContext::IsLocked()
{
	return m_Lock.OwnerThread == (HANDLE)GetCurrentThreadId();
}


// **************************************************************************
// Function Name:  ProcessObjectsThreadProc
// 
// Purpose: 	   Process NDIS events from radio.
//
// Arguments: 
//
// Return Values:  
//
// Side effects:  
// 
// Description:   
// **************************************************************************
DWORD WINAPI ProcessObjectsThreadProc(LPVOID pParameter)
{
	CPdpContext* pCPdpContext = (CPdpContext*)pParameter;
	DWORD Result;

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

	Result = pCPdpContext->ProcessObjectsThread();

	return Result;
}