rilhandndis.cpp

windows mobile RIL软件

    LeaveCriticalSection(&m_csConnectionList);    
    return hr;
}

// **************************************************************************
// 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_csConnectionList);
    *pfnRilReceiveCallback = NULL;
    *pfnRilTransmitCallback = NULL;
    *pfnRilStatusCallback = NULL;
    *pCallbackContext = NULL;
    for(int i=FIRST_VALID_NDIS_INDEX;i<MAX_OEMNDIS_CHANNELS;i++)
        {
        if ( ContextID && (m_rgpNdisChannels[i].dwCid == ContextID) )
            {
            *pfnRilReceiveCallback = m_rgpNdisChannels[i].RilNdisGprsContext.pfnNdisReceive;
            *pfnRilTransmitCallback = m_rgpNdisChannels[i].RilNdisGprsContext.pfnNdisTransmit;
            *pfnRilStatusCallback = m_rgpNdisChannels[i].RilNdisGprsContext.pfnNdisStatus;
            *pCallbackContext = m_rgpNdisChannels[i].RilNdisGprsContext.pCallbackContext;
            break;
            }
        }
    LeaveCriticalSection(&m_csConnectionList);   
}

// **************************************************************************
// 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::NdisRilInstanceFromHandle( HANDLE hNdisHandle )
{
    HRESULT hr = E_FAIL;
    VOID *pVoid = NULL;
    EnterCriticalSection(&m_csConnectionList);
    for(int i=FIRST_VALID_NDIS_INDEX;i<MAX_OEMNDIS_CHANNELS;i++)
    {
        if ( hNdisHandle && (m_rgpNdisChannels[i].hNdisHandle == hNdisHandle) )
        {
            pVoid = m_rgpNdisChannels[i].dwCrilInstance;
            hr = S_OK;
            break;
        }
    }
    LeaveCriticalSection(&m_csConnectionList);   
    return pVoid;
}

// **************************************************************************
// Function Name: NdisRemoveCallbacks
// 
// Purpose:       
//
// Arguments:     
//
// Return Values:  
//
// Side effects:  
// 
// Description:   
// **************************************************************************
void    CRilNDIS::NdisRemoveCallbacks ( DWORD ContextID )
{    
    DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: NdisRemoveCallbacks cid = %x  \r\n"), ContextID));
    EnterCriticalSection(&m_csConnectionList);
    for(int i=FIRST_VALID_NDIS_INDEX;i<MAX_OEMNDIS_CHANNELS;i++)
    {
        if ( m_rgpNdisChannels[i].RilNdisGprsContext.dwContextID == ContextID )
        {
            m_rgpNdisChannels[i].RilNdisGprsContext.pCallbackContext = NULL;
            m_rgpNdisChannels[i].RilNdisGprsContext.pfnNdisReceive = NULL;
            m_rgpNdisChannels[i].RilNdisGprsContext.pfnNdisStatus = NULL;
            m_rgpNdisChannels[i].RilNdisGprsContext.pfnNdisTransmit = NULL;
            break;
        }
    }
    LeaveCriticalSection(&m_csConnectionList);
}


// **************************************************************************
// Function Name: NdisAddNdisEntry
// 
// Purpose:       Add an NDIS channel entry to mark its use.
//
// Arguments:     IN cid, dwIndex, hHandle (NDIS channel handle), lpOemNdisEvent CrilInstance open structure
//
// Return Values:  
//
// Side effects:  
// 
// Description:   
// **************************************************************************
void    CRilNDIS::NdisAddNdisEntry ( DWORD cid, DWORD dwIndex,  HANDLE hHandle, VOID *hCrilInstance, const RILNDISGPRSCONTEXT *lpRilNdisGprsContext )
{    
    DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS: NdisAddNdisEntry cid = %x, index = %x, handle = %x  \r\n"), cid, dwIndex, hHandle));
    EnterCriticalSection(&m_csConnectionList);
    if ( hHandle && (TRUE == ValidChannelIndex ( dwIndex )) )
    {
        m_rgpNdisChannels[dwIndex].dwCid= cid;
        m_rgpNdisChannels[dwIndex].hNdisHandle = hHandle;
        m_rgpNdisChannels[dwIndex].dwCrilInstance = hCrilInstance;
        CeSafeCopyMemory(&m_rgpNdisChannels[dwIndex].RilNdisGprsContext, lpRilNdisGprsContext, sizeof(m_rgpNdisChannels[dwIndex].RilNdisGprsContext));
    }
    LeaveCriticalSection(&m_csConnectionList);
}

// **************************************************************************
// Function Name:  NdisConvertConfig
// 
// Purpose: 
//
// Arguments: 
//
// Return Values:  
//
// Side effects:  
// 
// Description:   
// **************************************************************************
void CRilNDIS::NdisConvertConfig ( const OEMNDISCONFIGURATION* lpOemNdisConfig,  RILNDISIPCONFIG* lpRilNdisIpConfig)
{
    if ( lpOemNdisConfig && lpRilNdisIpConfig )
    {
        memset( lpRilNdisIpConfig, 0, sizeof(RILNDISIPCONFIG));
        lpRilNdisIpConfig->cbSize = sizeof(RILNDISIPCONFIG);

        /* derive whether address is IPv4(default) or IPv6 */
        lpRilNdisIpConfig->dwProtocol = RIL_PARAM_NDISIPCONFIG_PROTOCOL_IPV4;
        if ( lpOemNdisConfig->ipAddress.length == IPV6_ADDRESS_LENGTH )
        {
            lpRilNdisIpConfig->dwProtocol = RIL_PARAM_NDISIPCONFIG_PROTOCOL_IPV6;
        }

        /* fill in protocol specific parameters */
        if ( lpRilNdisIpConfig->dwProtocol == RIL_PARAM_NDISIPCONFIG_PROTOCOL_IPV4 )
        {
            lpRilNdisIpConfig->ipv4.dwFlags |= RIL_PARAM_NDISIPCONFIG_SUBNETMASK;
            lpRilNdisIpConfig->ipv4.inSubnetMask = 0xffffff00;

            if ( lpOemNdisConfig->ipAddress.length && lpOemNdisConfig->ipAddress.address )
            {
                lpRilNdisIpConfig->ipv4.dwFlags |= RIL_PARAM_NDISIPCONFIG_IPADDR;
                lpRilNdisIpConfig->ipv4.dwFlags |= RIL_PARAM_NDISIPCONFIG_DEFAULTGATEWAY;
                lpRilNdisIpConfig->ipv4.inIPAddress = myinet_addr( lpOemNdisConfig->ipAddress.address, lpOemNdisConfig->ipAddress.length );
                lpRilNdisIpConfig->ipv4.inDefaultGateway = lpRilNdisIpConfig->ipv4.inIPAddress ^ 0xFF;
            }

            if ( lpOemNdisConfig->primaryDnsAddress.length && lpOemNdisConfig->primaryDnsAddress.address)
            {
                lpRilNdisIpConfig->ipv4.dwFlags |= RIL_PARAM_NDISIPCONFIG_PRIMARYDNS;
                lpRilNdisIpConfig->ipv4.inPrimaryDNS = myinet_addr( lpOemNdisConfig->primaryDnsAddress.address, lpOemNdisConfig->primaryDnsAddress.length );
            }

            if ( lpOemNdisConfig->secondaryDnsAddress.length && lpOemNdisConfig->secondaryDnsAddress.address)
            {
                lpRilNdisIpConfig->ipv4.dwFlags |= RIL_PARAM_NDISIPCONFIG_SECONDARYDNS;
                lpRilNdisIpConfig->ipv4.inSecondaryDNS = myinet_addr( lpOemNdisConfig->secondaryDnsAddress.address, lpOemNdisConfig->secondaryDnsAddress.length );
            }
        }
        else if ( lpRilNdisIpConfig->dwProtocol == RIL_PARAM_NDISIPCONFIG_PROTOCOL_IPV6 )
        {
            if ( lpOemNdisConfig->ipAddress.length )
            {
                lpRilNdisIpConfig->ipv6.dwFlags |= RIL_PARAM_NDISIPCONFIG_IPV6_IPADDR;
                lpRilNdisIpConfig->ipv6.inIPAddress = myinet_ipv6addr( lpOemNdisConfig->ipAddress.address, lpOemNdisConfig->ipAddress.length );

                UCHAR subnetmask[IPV6_ADDRESS_LENGTH];
                memset( subnetmask, 0xFF, sizeof(subnetmask) );
                lpRilNdisIpConfig->ipv6.dwFlags |= RIL_PARAM_NDISIPCONFIG_IPV6_SUBNETMASK;
                lpRilNdisIpConfig->ipv6.inSubnetMask = myinet_ipv6addr( subnetmask, IPV6_ADDRESS_LENGTH );

                lpRilNdisIpConfig->ipv6.dwFlags |= RIL_PARAM_NDISIPCONFIG_IPV6_DEFAULTGATEWAY;
                lpRilNdisIpConfig->ipv6.inDefaultGateway = lpRilNdisIpConfig->ipv6.inIPAddress;
            }

            if ( lpOemNdisConfig->primaryDnsAddress.length )
            {
                lpRilNdisIpConfig->ipv6.dwFlags |= RIL_PARAM_NDISIPCONFIG_IPV6_PRIMARYDNS;
                lpRilNdisIpConfig->ipv6.inPrimaryDNS = myinet_ipv6addr( lpOemNdisConfig->primaryDnsAddress.address, lpOemNdisConfig->primaryDnsAddress.length );
            }

            if ( lpOemNdisConfig->secondaryDnsAddress.length )
            {
                lpRilNdisIpConfig->ipv6.dwFlags |= RIL_PARAM_NDISIPCONFIG_IPV6_SECONDARYDNS;
                lpRilNdisIpConfig->ipv6.inSecondaryDNS = myinet_ipv6addr( lpOemNdisConfig->secondaryDnsAddress.address, lpOemNdisConfig->secondaryDnsAddress.length );
            }
        }
    }
}

// **************************************************************************
// Function Name:  NdisCloseAllConnections
// 
// Purpose:        Close all NDIS connections
//
// Arguments: 
//
// Return Values:  
//
// Side effects:  
// 
// Description:   
// **************************************************************************
void   CRilNDIS::NdisCloseAllConnections ( void )
{
    EnterCriticalSection(&m_csConnectionList);
    DWORD ContextID;
    RILGPRSCONTEXTACTIVATED RilGprsContexActivated;
    RilGprsContexActivated.cbSize = sizeof(RILGPRSCONTEXTACTIVATED);
    RilGprsContexActivated.fActivated = FALSE;
    RilGprsContexActivated.dwEvent = RIL_RILGPRSCONTEXTACTIVATED_MEDEACT;


    for(int i=FIRST_VALID_NDIS_INDEX;i<MAX_OEMNDIS_CHANNELS;i++)
        {
        if ( m_rgpNdisChannels[i].hNdisHandle  )
            {
            if ( S_OK  == NdisCidFromHandle( m_rgpNdisChannels[i].hNdisHandle, &ContextID) )
                {
                RemoveAndSignalAllPdpContextEntries(ContextID);
                }
            if ( S_OK  == NdisCidFromHandle( m_rgpNdisChannels[i].hNdisHandle, &RilGprsContexActivated.dwContextID) )
            ((CRilHandle*)m_pCrilHandle)->BroadcastRealBlobNotification(RIL_NOTIFY_GPRSCONNECTIONSTATUS, &RilGprsContexActivated, sizeof(RILGPRSCONTEXTACTIVATED));

            // Remove the entry from our list of Ndis handles/Cids
            NdisRemoveNdisEntry(m_rgpNdisChannels[i].hNdisHandle);
            // Now remove the event object.
            NdisRemoveNotifyEvent(m_rgpNdisChannels[i].hNdisHandle);
            }
        }
    LeaveCriticalSection(&m_csConnectionList);
}

// **************************************************************************
// Function Name:   NdisShutdownConnection
// 
// Purpose:         Shutdown and NDIS connection and cleanup related items.
//
// Arguments:       IN handle to channel to close.
//
// Return Values:  
//
// Side effects:  
// 
// Description:   
// **************************************************************************
void CRilNDIS:: NdisShutdownConnection ( HANDLE hHandle )
{

    if ( hHandle )
    {
        // We want to Shutdown this handle and remove from NDIS channel information.
        NdisInterfaceShutdown(hHandle);         
        // Notify it's down
        RILGPRSCONTEXTACTIVATED RilGprsContexActivated;
        RilGprsContexActivated.cbSize = sizeof(RILGPRSCONTEXTACTIVATED);
        RilGprsContexActivated.fActivated = FALSE;
        RilGprsContexActivated.dwEvent = RIL_RILGPRSCONTEXTACTIVATED_MEDEACT;
        if ( S_OK  == NdisCidFromHandle( hHandle, &RilGprsContexActivated.dwContextID) )
            ((CRilHandle*)m_pCrilHandle)->BroadcastRealBlobNotification(RIL_NOTIFY_GPRSCONNECTIONSTATUS, &RilGprsContexActivated, sizeof(RILGPRSCONTEXTACTIVATED));
        // Remove the entry from our list of Ndis handles/Cids
        NdisRemoveNdisEntry(hHandle);
        // Now remove the event object.
        NdisRemoveNotifyEvent(hHandle);
    }
}

void RilNdisSendPacket (const LPRILNDISPACKET lpPacketToSend)
{
    if ( g_pCRilNdis && lpPacketToSend)
    {
       {
           HANDLE hNdis;
           if ( S_OK == g_pCRilNdis->NdisHandleFromCid( lpPacketToSend->dwContextId, &hNdis ))
           {
               CRilInstanceNDIS *pCRilInstanceNdis;
               pCRilInstanceNdis = (CRilInstanceNDIS*)g_pCRilNdis->NdisRilInstanceFromHandle( hNdis );
               if ( pCRilInstanceNdis )
               {
               pCRilInstanceNdis->NdisSendPacket(lpPacketToSend);
               }
           }
       }          
    }
}

void RilNdisRecievePacketDone(const LPRILNDISPACKET lpPacketReceived)
{
    if ( g_pCRilNdis && lpPacketReceived)
    {
       {
           HANDLE hNdis;
           if ( S_OK == g_pCRilNdis->NdisHandleFromCid( lpPacketReceived->dwContextId, &hNdis ))
           {