// OIMachineMgr.cpp : implementation file
//
#include <QByteArray>

#include "stdafx.h"
#include "OIMachineMgr.h"

#include "OICommFun.h"

#include <string.h> 
#include <stdio.h>
#ifdef _WIN32
#include <WinSock2.h>
#include <IPTypes.h>
#include <IPHlpApi.h>
#pragma comment(lib,"Ole32.lib")
#pragma comment(lib,"Iphlpapi.lib")
#pragma comment(lib,"WS2_32.lib")
#else
//#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <ifaddrs.h>
#include <sys/ioctl.h> 
#include <net/if.h> 
#include <unistd.h>
#include <netdb.h>
#include <sys/socket.h>
//#include <netinet/in.h>
#include <arpa/inet.h>
#endif

namespace OIComm {

/////////////////////////////////////////////////////////////////////////////
// COIMachineMgr

COIMachineMgr::COIMachineMgr()
{
}

COIMachineMgr::~COIMachineMgr()
{
}

/////////////////////////////////////////////////////////////////////////////
// COIMachineMgr message handlers

wstring COIMachineMgr::GetMachineName()
{
	wstring			strMachineName;
	char			szHostName[128];
	struct hostent	*pHostEnt;

	gethostname( szHostName, 128 );
	pHostEnt	= gethostbyname( szHostName );

	strMachineName	= COICommFun::MultiByte2WideChar( pHostEnt->h_name, true );
	return	strMachineName;
}

wstring COIMachineMgr::GetMAC()
{
	wstring			strMac;
	vector<string>	asMac, asIP;
	int				nCount;
	string			strItem;

	GetAllMAC( asMac, asIP );
	nCount	= asMac.size();
	if ( 0 == nCount )
		return	L"";

	strItem	= asMac[0];
	asMac.clear();
	asIP.clear();

	strMac	= COICommFun::MultiByte2WideChar( strItem.c_str() );
	return	strMac;
}

bool COIMachineMgr::HaveMAC( const wstring &strMAC )
{
	if ( strMAC.empty() )
		return	false;

	vector<string>	asMAC, asIP;
	int				nIndex, nCount;
	bool			bHave	= false;
	string			strByteMAC;

	strByteMAC	= COICommFun::WideChar2MultiByte( strMAC.c_str() );

	GetAllMAC( asMAC, asIP );
	nCount	= asMAC.size();
	for ( nIndex = 0 ; nIndex < nCount ; nIndex++ )
	{
        if ( qstricmp( asMAC[nIndex].c_str(), strByteMAC.c_str() ) == 0 )
		{
			bHave	= true;
			break;
		}
	}
	asMAC.clear();
	asIP.clear();

	return bHave;
}

#ifdef _WIN32

void COIMachineMgr::GetAllMAC( vector<string> &asMAC, vector<string> &asIP )
{
	IP_ADAPTER_INFO	*pAdptInfo	= NULL;
	IP_ADAPTER_INFO	*pNextAd	= NULL; 
	ULONG			ulLen		= 0;
	DWORD			dwError;
	char			szItem[3];
	string			strMac, strIP;

	asMAC.clear();
	// 得到总数
	dwError	= ::GetAdaptersInfo( pAdptInfo, &ulLen );
	if( dwError == ERROR_BUFFER_OVERFLOW )
	{
		pAdptInfo	= (IP_ADAPTER_INFO *)malloc( ulLen );
		dwError		= ::GetAdaptersInfo( pAdptInfo, &ulLen );  
	}

	// 第一张网卡就是当前活动网卡
	pNextAd	= pAdptInfo;
	while ( NULL != pNextAd )
	{
		// 非虚拟网卡
		if ( (MIB_IF_TYPE_ETHERNET == pNextAd->Type
				|| IF_TYPE_IEEE80212 == pNextAd->Type
				|| IF_TYPE_IEEE80211 == pNextAd->Type)
			&& strstr( pNextAd->Description, "Virtual" ) == NULL )
		{
			for ( int i = 0; i < pNextAd->AddressLength; i++ )
			{
				sprintf_s( szItem, 3, "%02X", pNextAd->Address[i] );
				strMac	+= szItem;
			}
			asMAC.push_back( strMac );
			strMac.clear();

			strIP	= pNextAd->IpAddressList.IpAddress.String;
			asIP.push_back( strIP );
		}

		pNextAd	= pNextAd->Next;
	}
	free( pAdptInfo );
}

#else

void COIMachineMgr::GetAllMAC( vector<string> &asMAC, vector<string> &asIP )
{
	char	szMac[30];
	void	*pTempAddr	= NULL;
	struct	ifaddrs		*pifap0	= NULL;
	struct	ifaddrs		*pifap	= NULL;
	string	strMac;

	asMAC.clear();

	getifaddrs( &pifap0 );
	pifap	= pifap0;
	while ( pifap != NULL )
	{
		// check it is IP4
		if ( AF_INET == pifap->ifa_addr->sa_family )
		{
			char	szAddrBuff[INET_ADDRSTRLEN];

			// is a valid IP4 Address
			pTempAddr	= &((struct sockaddr_in *)pifap->ifa_addr)->sin_addr;
			inet_ntop( AF_INET, pTempAddr, szAddrBuff, INET_ADDRSTRLEN );
			if ( strcmp( szAddrBuff, "127.0.0.1" ) != 0 )
			{
                printf( "%s IPv4: %s\n", pifap->ifa_name, szAddrBuff);

				// MAC
                strMac	= GetMAC( pifap->ifa_name );
				if ( !strMac.empty() )
				{
					asMAC.push_back( strMac );
					asIP.push_back( string( szAddrBuff ) );
				}
			}
		}
/*		// check it is IP6
		else if ( AF_INET6 == pifap->ifa_addr->sa_family  )
		{
			char	szAddrBuff[INET6_ADDRSTRLEN];

			// is a valid IP6 Address
			pTempAddr	= &((struct sockaddr_in *)ifap->ifa_addr)->sin_addr;
			inet_ntop( AF_INET6, pTempAddr, szAddrBuff, INET6_ADDRSTRLEN );
			if ( strcmp( szAddrBuff, "::" ) != 0 )
			{
				printf( "%s IPv6: %s\n", ifap->ifa_name, szAddrBuff );
				printf( "MAC: %s\n\n", getMac( mac, ifap->ifa_name ) );
			}
		}
*/
		pifap	= pifap->ifa_next;
	} // End of while ( pifap != NULL )

	if ( pifap0 )
	{
		freeifaddrs( pifap0 );
		pifap0	= NULL;
	}
}

string COIMachineMgr::GetMAC( char *pszAdptName )
{
	if ( !pszAdptName )
		return	"";

	struct ifreq	ifreq;
	int				sock;

	sock	= socket( AF_INET, SOCK_STREAM, 0 );
	if ( sock < 0 )
		return	"";

	strcpy( ifreq.ifr_name, pszAdptName ); 
	if ( ioctl( sock, SIOCGIFHWADDR, &ifreq ) < 0 ) 
	{
        close( sock );
		return	"";
	}
    close( sock );

	// Gen MAC
	char	szBuff[13];
	string	strMac;

#ifdef _WIN32
    sprintf_s( szBuff, 13, "%02X%02X%02X%02X%02X%02X",
				(unsigned char)ifreq.ifr_hwaddr.sa_data[0], 
				(unsigned char)ifreq.ifr_hwaddr.sa_data[1], 
				(unsigned char)ifreq.ifr_hwaddr.sa_data[2], 
				(unsigned char)ifreq.ifr_hwaddr.sa_data[3], 
				(unsigned char)ifreq.ifr_hwaddr.sa_data[4], 
				(unsigned char)ifreq.ifr_hwaddr.sa_data[5] );
#else
    snprintf( szBuff, 13, "%02X%02X%02X%02X%02X%02X",
                (unsigned char)ifreq.ifr_hwaddr.sa_data[0],
                (unsigned char)ifreq.ifr_hwaddr.sa_data[1],
                (unsigned char)ifreq.ifr_hwaddr.sa_data[2],
                (unsigned char)ifreq.ifr_hwaddr.sa_data[3],
                (unsigned char)ifreq.ifr_hwaddr.sa_data[4],
                (unsigned char)ifreq.ifr_hwaddr.sa_data[5] );
#endif

	strMac	= szBuff;
	return	strMac;
}

#endif // End of #ifdef _WIN32 else ...

} // End of namespace OIComm