netadapterinfo.cpp

邮件终端发送程序

CNetAdapterInfo::~CNetAdapterInfo()
{
	DeleteAllNetAdapterInfo ();
}

void CNetAdapterInfo::DeleteAllNetAdapterInfo()
{
	for ( int i=0; i<m_Ary_NetAdapterInfo.GetSize(); i++ )
	{
		COneNetAdapterInfo *pOneNetAdapterInfo = (COneNetAdapterInfo*)m_Ary_NetAdapterInfo.GetAt(i);
		if ( pOneNetAdapterInfo ) delete pOneNetAdapterInfo;
	}
	m_Ary_NetAdapterInfo.RemoveAll ();
}

//
// 枚举网络适配器
// return : ------------------------------------------------------------
//	-1	-	失败
//	>=0	-	网络适配器数量
//
int CNetAdapterInfo::EnumNetworkAdapters ()
{
	DeleteAllNetAdapterInfo ();

	IP_ADAPTER_INFO* pAdptInfo	= NULL;
	IP_ADAPTER_INFO* pNextAd	= NULL;
	ULONG ulLen					= 0;
	int nCnt					= 0;
	
	DWORD dwError = ::GetAdaptersInfo ( pAdptInfo, &ulLen );
	if( dwError != ERROR_BUFFER_OVERFLOW ) return -1;
	pAdptInfo = ( IP_ADAPTER_INFO* )MALLOC ( ulLen );
	dwError = ::GetAdaptersInfo( pAdptInfo, &ulLen );
	if ( dwError != ERROR_SUCCESS ) return -1;
	
	pNextAd = pAdptInfo;
	while( pNextAd )
	{
		COneNetAdapterInfo *pOneNetAdapterInfo = new COneNetAdapterInfo ( pNextAd );
		if ( pOneNetAdapterInfo )
		{
			m_Ary_NetAdapterInfo.Add ( pOneNetAdapterInfo );
		}
		nCnt ++;
		pNextAd = pNextAd->Next;
	}
	
	// free any memory we allocated from the heap before
	// exit.  we wouldn't wanna leave memory leaks now would we? ;p
	FREE( pAdptInfo );		
	
	return nCnt;
}

COneNetAdapterInfo* CNetAdapterInfo::Get_OneNetAdapterInfo ( int nIndex )
{
	if ( nIndex < 0 || nIndex >= m_Ary_NetAdapterInfo.GetSize() )
	{
		ASSERT ( FALSE );
		return NULL;
	}

	return (COneNetAdapterInfo*)m_Ary_NetAdapterInfo.GetAt(nIndex);
}

COneNetAdapterInfo* CNetAdapterInfo::Get_OneNetAdapterInfo ( DWORD dwIndex )
{
	for ( int i=0; i<m_Ary_NetAdapterInfo.GetSize(); i++ )
	{
		COneNetAdapterInfo *pOneNetAdapterInfo = (COneNetAdapterInfo*)m_Ary_NetAdapterInfo.GetAt(i);
		if ( pOneNetAdapterInfo && pOneNetAdapterInfo->Get_AdapterIndex() == dwIndex )
			return pOneNetAdapterInfo;
	}

	return NULL;
}

void CNetAdapterInfo::Refresh ()
{
	DeleteAllNetAdapterInfo ();
	EnumNetworkAdapters ();
	GetAdapterAddress ();
}

//
// 获取网卡的地址信息，主要是MAC地址
//
BOOL CNetAdapterInfo::GetAdapterAddress ()
{
	DWORD dwSize = 0;
    DWORD dwRetVal = 0;
	BOOL bRet = FALSE;

    int i = 0;

    // Set the flags to pass to GetAdaptersAddresses
    ULONG flags = GAA_FLAG_INCLUDE_PREFIX;

    // default to unspecified address family (both)
	// AF_INET for IPv4, AF_INET6 for IPv6
    ULONG family = AF_UNSPEC;

    LPVOID lpMsgBuf = NULL;

    PIP_ADAPTER_ADDRESSES pAddresses = NULL;
    ULONG outBufLen = 0;

    PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
    PIP_ADAPTER_UNICAST_ADDRESS pUnicast = NULL;
    PIP_ADAPTER_ANYCAST_ADDRESS pAnycast = NULL;
    PIP_ADAPTER_MULTICAST_ADDRESS pMulticast = NULL;
    IP_ADAPTER_DNS_SERVER_ADDRESS *pDnServer = NULL;
    IP_ADAPTER_PREFIX *pPrefix = NULL;

    outBufLen = sizeof (IP_ADAPTER_ADDRESSES);
    pAddresses = (IP_ADAPTER_ADDRESSES *) MALLOC(outBufLen);
    if (pAddresses == NULL) return FALSE;

    // Make an initial call to GetAdaptersAddresses to get the 
    // size needed into the outBufLen variable
    if ( ::GetAdaptersAddresses ( family, flags, NULL, pAddresses, &outBufLen ) == ERROR_BUFFER_OVERFLOW )
	{
        FREE(pAddresses);
        pAddresses = (IP_ADAPTER_ADDRESSES *) MALLOC(outBufLen);
    }
    if (pAddresses == NULL) return FALSE;

    // Make a second call to GetAdapters Addresses to get the
    // actual data we want
#ifdef _DEBUG
    TRACE ( _T("Memory allocated for GetAdapterAddresses = %d bytes\n"), outBufLen);
    TRACE ( _T("Calling GetAdaptersAddresses function with family = " ) );
    if (family == AF_INET)
        TRACE(_T("AF_INET\n"));
    if (family == AF_INET6)
        TRACE(_T("AF_INET6\n"));
    if (family == AF_UNSPEC)
        TRACE(_T("AF_UNSPEC\n\n"));
#endif
    dwRetVal = GetAdaptersAddresses ( family, flags, NULL, pAddresses, &outBufLen );

    if ( dwRetVal == NO_ERROR )
	{
        // If successful, output some information from the data we received
        pCurrAddresses = pAddresses;
        while (pCurrAddresses)
		{
            TRACE(_T("\tLength of the IP_ADAPTER_ADDRESS struct: %ld\n"),
                   pCurrAddresses->Length);
            TRACE(_T("\tIfIndex (IPv4 interface): %u\n"), pCurrAddresses->IfIndex);
            TRACE(_T("\tAdapter name: %s\n"), pCurrAddresses->AdapterName);

            pUnicast = pCurrAddresses->FirstUnicastAddress;
            if (pUnicast != NULL)
			{
                for (i = 0; pUnicast != NULL; i++)
                    pUnicast = pUnicast->Next;
                TRACE(_T("\tNumber of Unicast Addresses: %d\n"), i);
            }
			else
			{
                TRACE(_T("\tNo Unicast Addresses\n"));
			}

            pAnycast = pCurrAddresses->FirstAnycastAddress;
            if (pAnycast)
			{
                for (i = 0; pAnycast != NULL; i++)
                    pAnycast = pAnycast->Next;
                TRACE(_T("\tNumber of Anycast Addresses: %d\n"), i);
            }
			else
			{
                TRACE(_T("\tNo Anycast Addresses\n"));
			}

            pMulticast = pCurrAddresses->FirstMulticastAddress;
            if (pMulticast)
			{
                for (i = 0; pMulticast != NULL; i++)
                    pMulticast = pMulticast->Next;
                TRACE(_T("\tNumber of Multicast Addresses: %d\n"), i);
            }
			else
			{
                TRACE(_T("\tNo Multicast Addresses\n"));
			}

            pDnServer = pCurrAddresses->FirstDnsServerAddress;
            if (pDnServer)
			{
                for (i = 0; pDnServer != NULL; i++)
                    pDnServer = pDnServer->Next;
                TRACE(_T("\tNumber of DNS Server Addresses: %d\n"), i);
            }
			else
			{
                TRACE(_T("\tNo DNS Server Addresses\n"));
			}

            TRACE(_T("\tDNS Suffix: %wS\n"), pCurrAddresses->DnsSuffix);
            TRACE(_T("\tDescription: %wS\n"), pCurrAddresses->Description);
            TRACE(_T("\tFriendly name: %wS\n"), pCurrAddresses->FriendlyName);

            if (pCurrAddresses->PhysicalAddressLength != 0)
			{
                TRACE(_T("\tPhysical address: "));
                for (i = 0; i < (int) pCurrAddresses->PhysicalAddressLength; i++)
				{
                    if ( i == (int)(pCurrAddresses->PhysicalAddressLength - 1))
                        TRACE(_T("%.2X\n"), (int) pCurrAddresses->PhysicalAddress[i]);
                    else
                        TRACE(_T("%.2X-"), (int) pCurrAddresses->PhysicalAddress[i]);
                }

				COneNetAdapterInfo* pNetAdapterInfo = Get_OneNetAdapterInfo ( pCurrAddresses->IfIndex );
				if ( pNetAdapterInfo )
				{
					pNetAdapterInfo->Set_PhysicalAddress ( pCurrAddresses->PhysicalAddressLength, pCurrAddresses->PhysicalAddress );
				}
            }
            TRACE(_T("\tFlags: %ld\n"), pCurrAddresses->Flags);
            TRACE(_T("\tMtu: %lu\n"), pCurrAddresses->Mtu);
            TRACE(_T("\tIfType: %ld\n"), pCurrAddresses->IfType);
            TRACE(_T("\tOperStatus: %ld\n"), pCurrAddresses->OperStatus);
            TRACE(_T("\tIpv6IfIndex (IPv6 interface): %u\n"),
                   pCurrAddresses->Ipv6IfIndex);
            TRACE(_T("\tZoneIndices (hex): "));
            for (i = 0; i < 16; i++)
                TRACE(_T("%lx "), pCurrAddresses->ZoneIndices[i]);
            TRACE(_T("\n"));

            pPrefix = pCurrAddresses->FirstPrefix;
            if (pPrefix)
			{
                for (i = 0; pPrefix != NULL; i++)
                    pPrefix = pPrefix->Next;
                TRACE(_T("\tNumber of IP Adapter Prefix entries: %d\n"), i);
            }
			else
			{
                TRACE(_T("\tNumber of IP Adapter Prefix entries: 0\n"));
			}

            TRACE(_T("\n"));

            pCurrAddresses = pCurrAddresses->Next;
			bRet = TRUE;
        }
    }
	else
	{
        TRACE(_T("Call to GetAdaptersAddresses failed with error: %d\n"), dwRetVal );
        if (dwRetVal == ERROR_NO_DATA)
		{
            TRACE(_T("\tNo addresses were found for the requested parameters\n"));
		}
        else
		{
            if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dwRetVal, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),   // Default language
                              (LPTSTR) & lpMsgBuf, 0, NULL))
			{
                TRACE(_T("\tError: %s"), lpMsgBuf);
                LocalFree(lpMsgBuf);
                FREE(pAddresses);
            }
        }
		bRet = FALSE;
    }
    FREE(pAddresses);

	return bRet;
}

CString MacAddress2String ( int nPhysicalAddressLength, BYTE *pPhysicalAddress )
{
	ASSERT ( nPhysicalAddressLength >= 6 );
	AfxIsValidAddress(pPhysicalAddress,nPhysicalAddressLength,TRUE);
	CString csMacAddress, csOneCell;
	for ( int i=0; i<nPhysicalAddressLength; i++ )
	{
		csOneCell.Format ( _T("%.2X"), (int)pPhysicalAddress[i] );
		if ( !csMacAddress.IsEmpty() ) csMacAddress += _T("-");
		csMacAddress += csOneCell;
	}

	return csMacAddress;
}