ttpcom.cpp

我自己编译的armv4i wince60模拟器的bps源文件,已经验证可以使用,欢迎下载

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

    CRilNDISTTPCOM* pCRilNdis = static_cast<CRilNDISTTPCOM*>(pRilDevice->m_pCRilNdis);
    dwResult = pCRilNdis->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];
            const size_t LineBufCch = sizeof(wLineBuf) / sizeof(*wLineBuf);
            LPWSTR pLineBuf;
            size_t LineBufRemainingCch;
                    
                           
            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));
                
                pLineBuf = wLineBuf;
                LineBufRemainingCch = LineBufCch;
                for(DWORD x=0; x<lpRilNdisBuffer->cByteCount; x++)
                {
                    StringCchPrintfExW( pLineBuf, LineBufRemainingCch, &pLineBuf, &LineBufRemainingCch, STRSAFE_IGNORE_NULLS,
                                        L"%.2X ", lpRilNdisBuffer->pbyBytes[ x ] );

                    if ( (pLineBuf - wLineBuf) > 45 )
                    {
                        DEBUGMSG( ZONE_NDISPKTS,(wLineBuf));
                        pLineBuf = wLineBuf;
                        LineBufRemainingCch = LineBufCch;
                    }
                }
                if ( pLineBuf > wLineBuf )
                {
                    DEBUGMSG( ZONE_NDISPKTS,(wLineBuf));
                }
                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;
        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

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

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

void CRilNDISTTPCOM::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 CRilNDISTTPCOM::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 CRilNDISTTPCOM::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);

    }