rilhandndis.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(OEM2_DRIVER)
#define DELAYLD_NO_GETPROCFROMDLL
#include "precomp.h"
#include "simmgr.h"
#include "rilndisoem2.h"
#include <Delayld.h>

DWORD WINAPI NdisNotifyThreadProc(LPVOID lpParameter);
#define MAX_NDIS_EVENT_NAME 100
#define MAX_IP_ADDRESS_LENGTH 4

HINSTANCE g_hinstOEMNDIS /*= NULL*/;
CRilNDIS* g_pCRilNdis = NULL;

#define OEM_LIBRARY TEXT("ttpmux")
#define OEM_NdisInitialize TEXT("ttpcomNdisInitialise")
#define OEM_NdisShutdown   TEXT("ttpcomNdisShutdown")
#define OEM_NdisReceiveEvent   TEXT("ttpcomNdisReceiveEvent")
#define OEM_NdisTransmitEvent  TEXT("ttpcomNdisTransmitEvent")

typedef HANDLE  (*PFN_NDIS_INITIALIZE)(DWORD);
typedef BOOL    (*PFN_NDIS_SHUTDOWN)(HANDLE);
typedef BOOL    (*PFN_NDIS_RECEIVE_EVENT)(HANDLE, OEMNDISEVENT*,BOOL*);
typedef BOOL    (*PFN_NDIS_TRANSMIT_EVENT)(HANDLE, const OEMNDISEVENT*);

PFN_NDIS_INITIALIZE      g_pfnNdisInitialize;
PFN_NDIS_SHUTDOWN        g_pfnNdisShutdown;
PFN_NDIS_RECEIVE_EVENT   g_pfnNdisReceiveEvent;
PFN_NDIS_TRANSMIT_EVENT  g_pfnNdisTransmitEvent;


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

HRESULT GetPacketInterface()
{
    HRESULT hr = E_FAIL;

    HINSTANCE hinst;
    hinst = LoadPacketLib();
    if (!hinst)
    {
        ASSERT(0);
        goto Error;
    }

    g_pfnNdisInitialize =    (PFN_NDIS_INITIALIZE)GetProcAddress(hinst, OEM_NdisInitialize );
    g_pfnNdisShutdown =      (PFN_NDIS_SHUTDOWN)GetProcAddress(hinst, OEM_NdisShutdown );
    g_pfnNdisReceiveEvent =  (PFN_NDIS_RECEIVE_EVENT)GetProcAddress(hinst, OEM_NdisReceiveEvent);
    g_pfnNdisTransmitEvent = (PFN_NDIS_TRANSMIT_EVENT)GetProcAddress(hinst, OEM_NdisTransmitEvent);
    if (!g_pfnNdisInitialize || !g_pfnNdisShutdown || !g_pfnNdisReceiveEvent || !g_pfnNdisTransmitEvent)
    {
        ASSERT(0);
        goto Error;
    }
    else
    {
        hr = S_OK;
    }

Error:
    return hr;
}

BOOL ValidChannelIndex ( DWORD dwIndex )
{
    return ((dwIndex >= FIRST_VALID_NDIS_INDEX) && (dwIndex <= MAX_OEMNDIS_CHANNELS)) ? TRUE : FALSE;
    
}

// **************************************************************************
// 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;
}

// **************************************************************************
// 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
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 );
}

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 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_NULL_EVENT:            /* no event available                          */
            DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS:  OEM_NDIS_NULL_EVENT\r\n")));
            break;
        case OEM_NDIS_RX_PACKET:             /* Received a packet                           */
            DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS:  OEM_NDIS_RX_PACKET\r\n")));
            break;
        case OEM_NDIS_TX_PACKET_COMPLETE:    /* TX packet done - buffer can be reused       */
            DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS:  OEM_NDIS_TX_PACKET_COMPLETE\r\n")));
            break;
        case OEM_NDIS_IP_CONFIGURATION:      /* NDIS configuration from network             */
            DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS:  OEM_NDIS_IP_CONFIGURATION\r\n")));
            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_INITIALISE_COMPLETE:   /*Initialise is now complete                   */
            DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS:  OEM_NDIS_INITIALISE_COMPLETE\r\n")));
            break;
        case OEM_NDIS_OPEN_COMPLETE:         /* Open is now complete                        */
            DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS:  OEM_NDIS_OPEN_COMPLETE\r\n")));
            break;
        case OEM_NDIS_CLOSE_COMPLETE:        /* Close is now complete                       */
            DEBUGMSG( ZONE_NDIS, (TEXT("RILNDIS:  OEM_NDIS_CLOSE_COMPLETE\r\n")));
            break;