rilhandndis.cpp

windows mobile RIL软件

        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_CONNECTION:       /* open the connection                         */
            DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS:  OEM_NDIS_OPEN_CONNECTION\r\n")));
            break;
        case OEM_NDIS_CLOSE_CONNECTION:      /* close the connection                        */
            DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS:  OEM_NDIS_CLOSE_CONNECTION\r\n")));
            break;
        case OEM_NDIS_REGISTRATION_STATUS:   /* gsm or gprs registration status change      */
            DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS:  OEM_NDIS_REGISTRATION_STATUS\r\n")));
            break;
        case OEM_NDIS_BUFFER_STATUS:         /* buffer state has changed or response       */
            DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS:  OEM_NDIS_BUFFER_STATUS\r\n")));
            break;
    }
}

void PacketPointers (RILNDISPACKET* lpPacket)
{
    if ( lpPacket )
    {
        LPRILNDISBUFFER pRilNdisBufferIn = NULL;
        
        DEBUGMSG( ZONE_NDISPKTS, (TEXT("RILNDIS: PacketPointer  Packet = %0x, Count = %x"), 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 "), pRilNdisBufferIn->pbyBytes));
                pRilNdisBufferIn++;
            }
        }
    }
}
#else
#define PacketPointers(a)
#define DEBUG_TYPE(a)
#define DumpPacket(a)
#define NdisPacketTest(a)
#define DumpNdisIPConfig(a)
#endif

CRilNDIS::CRilNDIS()
{
    m_pCrilHandle = NULL;
    m_fXon = RIL_NDIS_XON;
    m_hNdisNotifyThread = NULL;
    g_pCRilNdis = this;
}

CRilNDIS::~CRilNDIS()
{
    m_pCrilHandle = NULL;
    g_pCRilNdis = NULL;
}

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

// **************************************************************************
// Function Name: NdisStart
// 
// Purpose:       Initialize to a known state and start NDIS thread.
//
// Arguments: 
//
// Return Values:  
//
// Side effects:  
// 
// Description:   
// **************************************************************************
BOOL CRilNDIS::NdisStart ( HANDLE hCancelEvent )
{
    m_hNdisNotifyThread = NULL;
    m_dwNdisNotifyThreadID = 0;
    m_hCancelEvent = hCancelEvent;
    memset( m_rgpNdisChannels, 0, sizeof(m_rgpNdisChannels)); 
    m_hNdisNotifyThread = CreateThread(NULL, 0, NdisNotifyThreadProc, (LPVOID)m_pCrilHandle, 0, &m_dwNdisNotifyThreadID);
    if ( m_hNdisNotifyThread )
    {
        InitializeCriticalSection(&m_csNdisEventList);
        InitializeCriticalSection(&m_csConnectionList);
        InitializeCriticalSection(&m_PdpContextCriticalSection);
        InitializeListHead(&m_PdpContextPendingList);
        InitializeListHead(&m_PdpContextFreeList);

    }

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

    return (m_hNdisNotifyThread ? TRUE : FALSE );
}

// **************************************************************************
// Function Name: NdisStop
// 
// Purpose:       Bring down to a known state. Wait for NDIS thread to terminate.
//
// Arguments: 
//
// Return Values:  
//
// Side effects:  
// 
// Description:   
// **************************************************************************
void CRilNDIS::NdisStop( void )
{
    if ( m_hNdisNotifyThread )
    {
      (void)WaitForSingleObject(m_hNdisNotifyThread,10000);
      (void)CloseHandle(m_hNdisNotifyThread);
      m_hNdisNotifyThread = NULL;
      m_dwNdisNotifyThreadID = 0;
      DeleteCriticalSection(&m_csNdisEventList);
      DeleteCriticalSection(&m_csConnectionList);
      DeleteCriticalSection(&m_PdpContextCriticalSection);

    }
}

// **************************************************************************
// Function Name:   NdisCountEvents
// 
// Purpose:         Convenience routine. Count number of events in WaitForMultipleObjects list.
//
// Arguments: 
//
// Return Values:  
//
// Side effects:  
// 
// Description:   
// **************************************************************************
DWORD CRilNDIS::NdisCountEvents(void)
{
    DWORD dwCount=0;
    
    for(int i=0;i<MAX_OEMNDIS_EVENTS;i++)
    {
       if ( !m_rgpNdisEvents.lpNdisEventHandlesPrimary[i] )
         break;
       else
         dwCount++;
    }

    return dwCount;
}

// **************************************************************************
// Function Name:  NdisGetFreeNdisEntry
// 
// Purpose:        Find an unused NDIS channel.
//
// Arguments:      OUT index value if one is available.
//
// Return Values:  E_FAIL if all indeces are in use.
//
// Side effects:  
// 
// Description:   
// **************************************************************************
HRESULT    CRilNDIS::NdisGetFreeNdisEntry ( DWORD *lpIndex )
{
    HRESULT hr = E_FAIL;
   
    EnterCriticalSection(&m_csConnectionList); 
    for(DWORD i = FIRST_VALID_NDIS_INDEX; i < MAX_OEMNDIS_CHANNELS; i++)
    {
      if ( 0 == m_rgpNdisChannels[i].hNdisHandle )
      {
         hr = S_OK;
         *lpIndex = i;
         break;
      }
    }
    LeaveCriticalSection(&m_csConnectionList);
    return hr;
}

// **************************************************************************
// Function Name:   NdisRemoveNdisEntry
// 
// Purpose:         Free an NDIS channel for use by others.
//
// Arguments:       IN Handle to the NDIS channel
//
// Return Values:  
//
// Side effects:  
// 
// Description:   
// **************************************************************************
void    CRilNDIS::NdisRemoveNdisEntry ( HANDLE hNdisHandle )
{
    EnterCriticalSection(&m_csConnectionList);
    for(int i=FIRST_VALID_NDIS_INDEX;i<MAX_OEMNDIS_CHANNELS;i++)
    {
      if ( hNdisHandle && (m_rgpNdisChannels[i].hNdisHandle == hNdisHandle) ) 
      {
        m_NdisAsyncCommandList.RemoveAllCommands( hNdisHandle );
        CloseHandle(hNdisHandle);
        memset( &m_rgpNdisChannels[i], 0, sizeof(OEMNDISCHANNELS)); 
        break;
      }
    }
    LeaveCriticalSection(&m_csConnectionList);            
}

// **************************************************************************
// Function Name: NdisCidFromHandle
// 
// Purpose:       Find the cid associated to a given NDIS channel handle.
//
// Arguments:     IN NdisHandle, OUT lpCid
//
// Return Values: E_FAIL if not found.
//
// Side effects:  
// 
// Description:   
// **************************************************************************
HRESULT  CRilNDIS:: NdisCidFromHandle( HANDLE hNdisHandle, DWORD *lpCid )
{
    HRESULT hr = E_FAIL;
    EnterCriticalSection(&m_csConnectionList); 
    for(int i=FIRST_VALID_NDIS_INDEX; i < MAX_OEMNDIS_CHANNELS; i++)
      if ( hNdisHandle && (m_rgpNdisChannels[i].hNdisHandle == hNdisHandle) )
      {
         *lpCid = m_rgpNdisChannels[i].dwCid;
         hr = S_OK;
         break;
      }

    DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: NdisCidFromHandle hr = %s ContextID = %x \r\n"), 
              (hr == S_OK) ? L"S_OK" : L"E_FAIL", *lpCid));
    LeaveCriticalSection(&m_csConnectionList);    
    return hr;
}

// **************************************************************************
// Function Name: NdisOemNdisOpenRequestFromHandle
// 
// Purpose:       Find the cid associated to a given NDIS channel handle.
//
// Arguments:     IN NdisHandle, OUT lpCid
//
// Return Values: E_FAIL if not found.
//
// Side effects:  
// 
// Description:   
// **************************************************************************
HRESULT  CRilNDIS:: NdisOemNdisOpenRequestFromHandle( HANDLE hNdisHandle, RILNDISGPRSCONTEXT *lpRilNdisGprsContext )
{
    HRESULT hr = E_FAIL;
    EnterCriticalSection(&m_csConnectionList);    
    for(int i=FIRST_VALID_NDIS_INDEX; i < MAX_OEMNDIS_CHANNELS; i++)
    {
      if ( hNdisHandle && (m_rgpNdisChannels[i].hNdisHandle == hNdisHandle) && lpRilNdisGprsContext)
      {
         memmove( lpRilNdisGprsContext, &(m_rgpNdisChannels[i].RilNdisGprsContext), sizeof(*lpRilNdisGprsContext));
         hr = S_OK;
         break;
      }
    }

    DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: NdisOemNdisOpenRequestFromHandle hr = %s  \r\n"), 
              (hr == S_OK) ? L"S_OK" : L"E_FAIL"));
    LeaveCriticalSection(&m_csConnectionList);    
    return hr;
}

// **************************************************************************
// Function Name: NdisHandleFromCid
// 
// 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:   
// **************************************************************************
HRESULT CRilNDIS::NdisHandleFromCid( DWORD cid, HANDLE *hNdisHandle )
{
    HRESULT hr = E_FAIL;
    EnterCriticalSection(&m_csConnectionList);    
    if ( TRUE == ValidChannelIndex ( cid ) )
    {
        for(int i=FIRST_VALID_NDIS_INDEX;i<MAX_OEMNDIS_CHANNELS;i++)
        {
            if ( (m_rgpNdisChannels[i].dwCid == cid) && m_rgpNdisChannels[i].hNdisHandle )
            {
                *hNdisHandle = m_rgpNdisChannels[i].hNdisHandle;
                hr = S_OK;
                break;
            }
        }
    }