void GetMACaddress(char *mac_address)
{
IP_ADAPTER_INFO AdapterInfo[16]; // Allocate information for up to 16 NICs
DWORD dwBufLen = sizeof(AdapterInfo); // Save the memory size of buffer
DWORD dwStatus = GetAdaptersInfo( // Call GetAdapterInfo
AdapterInfo, // [out] buffer to receive data
&dwBufLen); // [in] size of receive data buffer
assert(dwStatus == ERROR_SUCCESS); // Verify return value is valid, no buffer overflow
PIP_ADAPTER_INFO pAdapterInfo = AdapterInfo;// Contains pointer to current adapter info
sprintf(mac_address,"%02X:%02X:%02X:%02X:%02X:%02X", pAdapterInfo->Address[0],pAdapterInfo->Address[1],pAdapterInfo->Address[2],pAdapterInfo->Address[3],pAdapterInfo->Address[4],pAdapterInfo->Address[5]);
}
int main(int argc, char** argv)
{
WSADATA wsaData;
PIP_ADAPTER_INFO pAdapterInfo = NULL, pAdapter = NULL;
ULONG ulOutBufLen;
u_char p[6];
WSAStartup(MAKEWORD(2,2), &wsaData);
if (GetAdaptersInfo(pAdapterInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW) {
free(pAdapterInfo);
pAdapterInfo = (PIP_ADAPTER_INFO) malloc(ulOutBufLen);
}
GetAdaptersInfo(pAdapterInfo, &ulOutBufLen);
pAdapter = pAdapterInfo;
while(pAdapter) {
printf("\tAdapter Name: \t%s\n", pAdapter->AdapterName);
printf("\tAdapter Desc: \t%s\n", pAdapter->Description);
memcpy(p, pAdapter->Address, 6);
printf("\tAdapter Addr: \t%02X:%02X:%02X:%02X:%02X:%02X\n",
p[0],p[1],p[2],p[3],p[4],p[5]);
printf("\tIP Addr: \t%s\n", pAdapter->IpAddressList.IpAddress.String);
printf("\tIP Mask: \t%s\n", pAdapter->IpAddressList.IpMask.String);
printf("\tIP Gateway: \t%s\n", pAdapter->GatewayList.IpAddress.String);
if (pAdapter->DhcpEnabled) {
printf("\tDHCP Enable: Yes\n");
printf("\tLease Obtained: %ld\n", pAdapter->LeaseObtained);
} else {
printf("\tDHCP Enable: No\n");
}
if (pAdapter->HaveWins) {
printf("\tHave Wins: Yes\n");
printf("\t\tPrimary Wins Server: \t%s\n", pAdapter->PrimaryWinsServer.IpAddress.String);
printf("\t\tSecondary Wins Server: \t%s\n", pAdapter->SecondaryWinsServer.IpAddress.String);
} else {
printf("\tHave Wins: No\n");
}
pAdapter = pAdapter->Next;
}
return 0;
}
DWORD WINAPI CLuzj_ZTEDlg::GetMacIP(const char *adaptername, char *ip, unsigned char *mac)
{
PIP_ADAPTER_INFO AdapterInfo = NULL;
DWORD dwBufLen = sizeof(IP_ADAPTER_INFO);
DWORD dwStatus;
AdapterInfo = (PIP_ADAPTER_INFO)malloc(dwBufLen);
if(AdapterInfo == NULL) return -1;
dwStatus = GetAdaptersInfo(AdapterInfo,&dwBufLen);
if(dwStatus == ERROR_BUFFER_OVERFLOW) {
free(AdapterInfo);
AdapterInfo = (PIP_ADAPTER_INFO)malloc(dwBufLen);
dwStatus = GetAdaptersInfo(AdapterInfo,&dwBufLen);
if(AdapterInfo == NULL) return -1;
}
if(dwStatus != NO_ERROR) {
if(AdapterInfo != NULL) free(AdapterInfo);
return -2;
}
if(ip) memset(ip, 0, 16);
if(mac) memset(mac, 0, 6);
PIP_ADAPTER_INFO pAdapterInfo = AdapterInfo;
if(adaptername != NULL) {
while(pAdapterInfo) {
if (stricmp(adaptername,pAdapterInfo->AdapterName) == 0) {
if(mac) memcpy(mac, pAdapterInfo->Address, 6);
if(ip) strncpy(ip, pAdapterInfo->IpAddressList.IpAddress.String, 16);
break;
}
pAdapterInfo = pAdapterInfo->Next;
};
}
free(AdapterInfo);
if(pAdapterInfo == NULL) return -3;
return 0;
}
//////////////////////////////////////////////////////
//Anti Cheat
char* getMAC(){// By Yuri-BR
PIP_ADAPTER_INFO AdapterInfo;
DWORD dwBufLen = sizeof(AdapterInfo);
char *mac_addr = (char*)malloc(17);
AdapterInfo = (IP_ADAPTER_INFO *) malloc(sizeof(IP_ADAPTER_INFO));
if (AdapterInfo == NULL)
{
printf("Error allocating memory needed to call GetAdaptersinfo\n");
}
// Make an initial call to GetAdaptersInfo to get the necessary size into the dwBufLen variable
if (GetAdaptersInfo(AdapterInfo, &dwBufLen) == ERROR_BUFFER_OVERFLOW)
{
AdapterInfo = (IP_ADAPTER_INFO *) malloc(dwBufLen);
if (AdapterInfo == NULL)
{
printf("Error allocating memory needed to call GetAdaptersinfo\n");
}
}
if (GetAdaptersInfo(AdapterInfo, &dwBufLen) == NO_ERROR)
{
PIP_ADAPTER_INFO pAdapterInfo = AdapterInfo;// Contains pointer to current adapter info
do
{
sprintf(mac_addr, "%02X:%02X:%02X:%02X:%02X:%02X", // By Yuri-BR
pAdapterInfo->Address[0], pAdapterInfo->Address[1],
pAdapterInfo->Address[2], pAdapterInfo->Address[3],
pAdapterInfo->Address[4], pAdapterInfo->Address[5]);
return mac_addr;
printf("\n");
pAdapterInfo = pAdapterInfo->Next;
}
while(pAdapterInfo);
}
free(AdapterInfo);
}
static TinyRet udp_join_multicast_group_with_all_ip(int fd, const char *group)
{
IP_ADAPTER_INFO * pNextAdapter = NULL;
IP_ADAPTER_INFO * ipAdaptersInfo = NULL;
ULONG infolen = sizeof(IP_ADAPTER_INFO);
ipAdaptersInfo = (IP_ADAPTER_INFO *)tiny_malloc(infolen);
if (GetAdaptersInfo(ipAdaptersInfo, &infolen) == ERROR_BUFFER_OVERFLOW)
{
tiny_free(ipAdaptersInfo);
ipAdaptersInfo = (IP_ADAPTER_INFO *)tiny_malloc(infolen);
}
if (GetAdaptersInfo(ipAdaptersInfo, &infolen))
{
tiny_free(ipAdaptersInfo);
return TINY_RET_E_INTERNAL;
}
for (pNextAdapter = ipAdaptersInfo; pNextAdapter; pNextAdapter = pNextAdapter->Next)
{
IP_ADDR_STRING *pNextIp = NULL;
for (pNextIp = &(pNextAdapter->IpAddressList); pNextIp; pNextIp = pNextIp->Next)
{
unsigned long ip = inet_addr(pNextIp->IpAddress.String);
if (ip == 0)
{
break;
}
LOG_D(TAG, "join MultiGroup ip: %s", pNextIp->IpAddress.String);
udp_join_multicast_group_with_ip(fd, group, ip);
}
}
tiny_free(ipAdaptersInfo);
return TINY_RET_OK;
}
// 是否存在网关
STDMETHODIMP_(BOOL) CStatistic::IsNetGatewayExists(void)
{
PIP_ADAPTER_INFO pAdapterInfo;
PIP_ADAPTER_INFO pAdapter = NULL;
BOOL bExists = FALSE;
DWORD dwRetVal = 0;
ULONG ulOutBufLen = sizeof(IP_ADAPTER_INFO);
pAdapterInfo = (IP_ADAPTER_INFO *) malloc(ulOutBufLen);
if(pAdapterInfo)
{
dwRetVal = GetAdaptersInfo( pAdapterInfo, &ulOutBufLen);
if(dwRetVal == ERROR_BUFFER_OVERFLOW )
{
free(pAdapterInfo);
pAdapterInfo = (IP_ADAPTER_INFO *) malloc (ulOutBufLen);
if(pAdapterInfo)
dwRetVal = GetAdaptersInfo( pAdapterInfo, &ulOutBufLen);
}
if( dwRetVal == NO_ERROR)
{
pAdapter = pAdapterInfo;
while (pAdapter)
{
if(pAdapter->GatewayList.IpAddress.String[0])
{
bExists = TRUE;
break;
}
pAdapter = pAdapter->Next;
}
}
free(pAdapterInfo);
}
return bExists;
}
char *macAddress(void)
{
IP_ADAPTER_INFO *adapterInfo;
ULONG adapterInfoSize = 0;
if (GetAdaptersInfo(NULL, &adapterInfoSize) != ERROR_SUCCESS)
{
adapterInfo = (IP_ADAPTER_INFO *) malloc(adapterInfoSize);
}
if (GetAdaptersInfo(adapterInfo, &adapterInfoSize) != ERROR_SUCCESS)
{
return NULL;
}
{
char *mac = String_asHex(adapterInfo->Address, adapterInfo->AddressLength);
free(adapterInfo);
return mac;
}
}
int getAdaptersInfo()
{
char MacAddressStr[256]; //mac address converted to a string
char MacOneByteStr[10]; //used to hold one byte of mac address
int retval = 0; //return -1 if no adapters found
if (isIPHLPAvail()) //inits iphlpapi and returns true if dll loaded
{
//just return count if we already did this before
if (AdapterCount)
return AdapterCount;
IP_ADAPTER_INFO *pAdapterInfo; //points to buffer hold linked list adapter info
DWORD dwSize = (sizeof(IP_ADAPTER_INFO) * MAX_ADAPTERS) + sizeof(DWORD); //size for lots of adapters
char *buffer = new char[dwSize]; //allocate space for lots of adapters
if (buffer)
{
pAdapterInfo = (IP_ADAPTER_INFO *)buffer; //point to buffer
if (GetAdaptersInfo(
pAdapterInfo, // buffer for mapping table
&dwSize) == NO_ERROR) // sort the table
{
while (pAdapterInfo)
{
strcpy(adapters[AdapterCount].AdapterName, pAdapterInfo->Description);
strcpy(adapters[AdapterCount].IpAddress, (const char *)pAdapterInfo->IpAddressList.IpAddress.String);
//build mac address as a string
*MacAddressStr = '\0';
for (unsigned int loop = 0; loop < pAdapterInfo->AddressLength; loop++)
{
if (strlen(MacAddressStr))
strcat(MacAddressStr,"-");
sprintf(MacOneByteStr,"%02X",pAdapterInfo->Address[loop]);
strcat(MacAddressStr,MacOneByteStr);
}
strcpy((char *)adapters[AdapterCount].MacAddress, MacAddressStr);
AdapterCount++;
pAdapterInfo = pAdapterInfo->Next;
}
retval = AdapterCount;
}
delete [] buffer;
}
}
return retval;
}
const char* wyDevice::getDeviceId() {
// Get the buffer length required for IP_ADAPTER_INFO.
ULONG bufLen = 0;
BYTE* buffer = 0;
if(GetAdaptersInfo(0, &bufLen) == ERROR_BUFFER_OVERFLOW) {
// Now the BufferLength contain the required buffer length.
// Allocate necessary buffer.
buffer = new BYTE[bufLen];
// Get the Adapter Information.
PIP_ADAPTER_INFO adapterInfo = reinterpret_cast<PIP_ADAPTER_INFO>(buffer);
GetAdaptersInfo(adapterInfo, &bufLen);
// Iterate the network adapters and print their MAC address.
if(adapterInfo) {
// Assuming pAdapterInfo->AddressLength is 6.
sprintf(sIMEI, "%02x:%02x:%02x:%02x:%02x:%02x",
adapterInfo->Address[0],
adapterInfo->Address[1],
adapterInfo->Address[2],
adapterInfo->Address[3],
adapterInfo->Address[4],
adapterInfo->Address[5]);
}
// make md5 for mac address
const char* md5 = wyMD5::md5(sIMEI);
memcpy(sIMEI, md5, strlen(md5));
wyFree((void*)md5);
// release buffer
delete[] buffer;
// return
return sIMEI;
} else {
return NULL;
}
}
void CIPFindDlg::OnCbnSelchangeCmbDevice()
{
UpdateData(FALSE);
int nCurSel = m_Device.GetCurSel();
ULONG len = 0;
GetAdaptersInfo(NULL, &len);
PIP_ADAPTER_INFO p = static_cast<PIP_ADAPTER_INFO>(malloc(len));
GetAdaptersInfo(p, &len);
int i=0;
for (PIP_ADAPTER_INFO q = p; q != NULL; q = q->Next)
{
if (i++ == nCurSel)
{
GetCurSelIPMask(q->IpAddressList.IpAddress.String, q->IpAddressList.IpMask.String);
}
}
free(p);
}
bool mapport(short port)
{
UPnP UPnPvar;
PIP_ADAPTER_INFO pAdapterInfo = NULL;
DWORD dwRetVal = 0;
char strLocalIP[256];
pAdapterInfo = (IP_ADAPTER_INFO *) malloc( sizeof(IP_ADAPTER_INFO) );
ULONG ulOutBufLen = sizeof(IP_ADAPTER_INFO);
// Make an initial call to GetAdaptersInfo to get
// the necessary size into the ulOutBufLen variable
if (GetAdaptersInfo( pAdapterInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW)
{
free(pAdapterInfo);
pAdapterInfo = (IP_ADAPTER_INFO *) malloc (ulOutBufLen);
}
if ((dwRetVal = GetAdaptersInfo( pAdapterInfo, &ulOutBufLen)) == NO_ERROR)
{
strcpy(strLocalIP,pAdapterInfo->IpAddressList.IpAddress.String);
}
else
{
strcpy(strLocalIP,"");
}
free(pAdapterInfo);
UPnPvar.Set_UPnP(strLocalIP,"TCP","UVNC",port);
UPnPvar.OpenPorts(true);
char testchar[256];
strcpy(testchar,UPnPvar.GetExternalIP());
UPnPvar.ClosePorts(true);
return 0;
}
// 取得所有网卡的信息 David 2010.6.2 add
PIP_ADAPTER_INFO GetAllAdaptersInfo()
{
PIP_ADAPTER_INFO pAdapterInfo = (IP_ADAPTER_INFO *) malloc( sizeof(IP_ADAPTER_INFO) );
ASSERT(NULL != pAdapterInfo);
ULONG ulOutBufLen = sizeof(IP_ADAPTER_INFO);
// 空间不够则重新分配空间
if (GetAdaptersInfo(pAdapterInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW)
{
free(pAdapterInfo);
pAdapterInfo = (IP_ADAPTER_INFO *) malloc (ulOutBufLen);
}
if (GetAdaptersInfo(pAdapterInfo, &ulOutBufLen) == NO_ERROR){
return pAdapterInfo;
}
else
{
free(pAdapterInfo);
return NULL;
}
}
vector<ULONG>* SocketExtension::LocalIPs()
{
PIP_ADAPTER_INFO pIpAdapterInfo = new IP_ADAPTER_INFO();
unsigned long stSize = sizeof(IP_ADAPTER_INFO);
int nRel = GetAdaptersInfo(pIpAdapterInfo, &stSize);
if (ERROR_BUFFER_OVERFLOW == nRel)
{
delete pIpAdapterInfo;
pIpAdapterInfo = (PIP_ADAPTER_INFO)new BYTE[stSize];
nRel = GetAdaptersInfo(pIpAdapterInfo, &stSize);
}
vector<ULONG>* address = NULL;
if (ERROR_SUCCESS == nRel)
{
while (pIpAdapterInfo)
{
IP_ADDR_STRING *pIpAddrString = &(pIpAdapterInfo->IpAddressList);
do
{
ULONG addrnum = inet_addr(pIpAddrString->IpAddress.String);
if (addrnum != 0)
{
if (address == NULL)
{
address = new vector<ULONG>;
}
address->push_back(addrnum);
}
pIpAddrString = pIpAddrString->Next;
} while (pIpAddrString);
pIpAdapterInfo = pIpAdapterInfo->Next;
}
}
if (pIpAdapterInfo)
delete pIpAdapterInfo;
return address;
}
int ipaddr_mac_cmp(const char *input_addr)
{
PIP_ADAPTER_INFO pAdapterInfo;
PIP_ADAPTER_INFO pAdapter = NULL;
DWORD dwRetVal = 0;
pAdapterInfo = (IP_ADAPTER_INFO *) malloc( sizeof(IP_ADAPTER_INFO) );
ULONG ulOutBufLen = sizeof(IP_ADAPTER_INFO);
dwRetVal = GetAdaptersInfo( pAdapterInfo, &ulOutBufLen) ;
if ( dwRetVal != ERROR_SUCCESS) {
free (pAdapterInfo);
pAdapterInfo = (IP_ADAPTER_INFO *) malloc (ulOutBufLen);
}
if((dwRetVal=GetAdaptersInfo(pAdapterInfo ,&ulOutBufLen))==NO_ERROR){
pAdapter= pAdapterInfo;
while(pAdapter) {
char mac_buf[128] ;
char *p = mac_buf ;
for(UINT i=0;i<pAdapter->AddressLength;i++) {
p +=snprintf(p,128 , "%02x-" , pAdapter->Address[i]) ;
}
--p ;
*p = 0 ;
if (0==ndstricmp((char*)mac_buf,(char*) input_addr)){
return 0 ;
}
pAdapter=pAdapter->Next;
}
}
else {
nd_logerror("last error :%s\n" AND nd_last_error()) ;
}
free (pAdapterInfo);
return -1;
}
void EnvironmentImpl::nodeIdImpl(NodeId& id)
{
std::memset(&id, 0, sizeof(id));
PIP_ADAPTER_INFO pAdapterInfo;
PIP_ADAPTER_INFO pAdapter = 0;
ULONG len = sizeof(IP_ADAPTER_INFO);
pAdapterInfo = reinterpret_cast<IP_ADAPTER_INFO*>(new char[len]);
// Make an initial call to GetAdaptersInfo to get
// the necessary size into len
DWORD rc = GetAdaptersInfo(pAdapterInfo, &len);
if (rc == ERROR_BUFFER_OVERFLOW)
{
delete [] reinterpret_cast<char*>(pAdapterInfo);
pAdapterInfo = reinterpret_cast<IP_ADAPTER_INFO*>(new char[len]);
}
else if (rc != ERROR_SUCCESS)
{
return;
}
if (GetAdaptersInfo(pAdapterInfo, &len) == NO_ERROR)
{
pAdapter = pAdapterInfo;
bool found = false;
while (pAdapter && !found)
{
if (pAdapter->Type == MIB_IF_TYPE_ETHERNET && pAdapter->AddressLength == sizeof(id))
{
found = true;
std::memcpy(&id, pAdapter->Address, pAdapter->AddressLength);
}
pAdapter = pAdapter->Next;
}
}
delete [] reinterpret_cast<char*>(pAdapterInfo);
}
unsigned __int64 FillAdaptersInfo(unsigned int *pRet2)
{
IP_ADAPTER_INFO AdapterInfo[16], *pAdapter;
ULONG uBufLen = sizeof(AdapterInfo);
__int64 ret = 0;
if (GetAdaptersInfo(AdapterInfo, &uBufLen) == ERROR_SUCCESS)
{
for (pAdapter = AdapterInfo; pAdapter; pAdapter = pAdapter->Next)
{
if (pAdapter->AddressLength == 6 && pAdapter->Type == MIB_IF_TYPE_ETHERNET)
ret ^= BytesSHA1I64(pAdapter->Address, pAdapter->AddressLength);
}
}
return ret;
}
int NetUtils::FindNumberOfLocalNetworkInterfaces( void )
{
PIP_ADAPTER_INFO pAdapterInfo = new IP_ADAPTER_INFO;
unsigned long output_buffer_len = sizeof(IP_ADAPTER_INFO);
// Make call to GetAdaptersInfo to get number of addapters
DWORD ret = GetAdaptersInfo( pAdapterInfo, &output_buffer_len );
delete pAdapterInfo;
if( (ret == ERROR_BUFFER_OVERFLOW) || (ret == ERROR_SUCCESS) ) {
int nif = output_buffer_len / sizeof(IP_ADAPTER_INFO);
if( output_buffer_len > (nif * sizeof(IP_ADAPTER_INFO)) )
nif++;
return nif;
}
fprintf( stderr, "FindNumberOfLocalNetworkInterfaces() failed\n" );
return -1;
}
bool GetMac(std::vector<unsigned char>& mac)
{
IP_ADAPTER_INFO AdapterInfo[16]; // Allocate information for 16 cards
DWORD dwBufLen = sizeof(AdapterInfo); // Save memory size of buffer
DWORD dwStatus = GetAdaptersInfo ( AdapterInfo, &dwBufLen); // Get info
if (dwStatus != NO_ERROR) return wxEmptyString; // Check status
for(size_t i = 0; i<sizeof(AdapterInfo); i++) {
mac.resize(AdapterInfo[i].AddressLength);
mac.assign(AdapterInfo[i].Address, AdapterInfo[i].Address + AdapterInfo[i].AddressLength);
for (size_t j=0; j< mac.size(); j++) {
if (mac[j] != 0) {
return true;
}
}
}
return false;
}
inline long MACAddressUtility::GetMACAddressMSW(unsigned char * result)
{
#if defined(UNDER_CE)
IP_ADAPTER_INFO AdapterInfo[16]; // Allocate information
DWORD dwBufLen = sizeof(AdapterInfo); // Save memory size of buffer
if(GetAdaptersInfo(AdapterInfo, &dwBufLen) == ERROR_SUCCESS)
{
memcpy(result, AdapterInfo->Address, 6);
}
else return -1;
#else
UUID uuid;
if(UuidCreateSequential(&uuid) == RPC_S_UUID_NO_ADDRESS) return -1;
memcpy(result, (char*)(uuid.Data4+2), 6);
#endif
return 0;
}
/**
* Retrieve the MAC address of the system
*/
unsigned pixie_get_mac_address(unsigned char macaddr[6])
{
memset(macaddr, 0, 6);
#ifdef WIN32
{
DWORD dwStatus;
IP_ADAPTER_INFO *p;
IP_ADAPTER_INFO AdapterInfo[16];
DWORD dwBufLen = sizeof(AdapterInfo);
DWORD interface_index = -1;
GetBestInterface(0x01010101, &interface_index);
dwStatus = GetAdaptersInfo(AdapterInfo, &dwBufLen);
if (dwStatus != ERROR_SUCCESS)
return 1;
for (p=AdapterInfo; p; p = p->Next) {
if (p->Index == interface_index || interface_index == -1) {
memcpy(macaddr, p->Address, 6);
return 0;
}
/*(
printf("[%02x:%02x:%02x:%02x:%02x:%02x]\n",
mac_address[0], mac_address[1], mac_address[2],
mac_address[3], mac_address[4], mac_address[5]
);
printf(" %s\n", p->AdapterName);
printf(" %s\n", p->Description);
printf(" IP: ");
for (a = &p->IpAddressList; a; a = a->Next) {
printf("%s ", a->IpAddress.String);
}
printf("\n");
*/
}
}
#else
return -1;
#endif
return -1;
}
//
// Function: Iterate through all network adapters, for call the callback routine with adapter information
//
void enumAdapters( std::function<bool(IP_ADAPTER_INFO&)> callback )
{
// 20 adapaters on one machine is enough!
IP_ADAPTER_INFO rgInfo[20];
DWORD size = sizeof(rgInfo);
DWORD result;
result = GetAdaptersInfo( rgInfo, &size );
if( result != ERROR_SUCCESS ) {
throw Win32Exception(result, "GetAdaptersInfo");
}
bool totalOption15 = false;
for( IP_ADAPTER_INFO* pinfo = rgInfo; pinfo && !totalOption15; pinfo = pinfo->Next ) {
bool cont = callback( *pinfo );
if( !cont )
break;
}
}
/* returns the subnet mask in network byte order */
static uint32_t getIpMaskForIpAddress(
uint32_t ipAddress)
{
/* Allocate information for up to 16 NICs */
IP_ADAPTER_INFO AdapterInfo[16];
/* Save memory size of buffer */
DWORD dwBufLen = sizeof(AdapterInfo);
uint32_t ipMask = INADDR_BROADCAST;
bool found = false;
PIP_ADAPTER_INFO pAdapterInfo;
/* GetAdapterInfo:
[out] buffer to receive data
[in] size of receive data buffer */
DWORD dwStatus = GetAdaptersInfo(AdapterInfo,
&dwBufLen);
if (dwStatus == ERROR_SUCCESS) {
/* Verify return value is valid, no buffer overflow
Contains pointer to current adapter info */
pAdapterInfo = AdapterInfo;
do {
IP_ADDR_STRING *pIpAddressInfo = &pAdapterInfo->IpAddressList;
do {
unsigned long adapterAddress =
inet_addr(pIpAddressInfo->IpAddress.String);
unsigned long adapterMask =
inet_addr(pIpAddressInfo->IpMask.String);
if (adapterAddress == ipAddress) {
ipMask = adapterMask;
found = true;
}
pIpAddressInfo = pIpAddressInfo->Next;
} while (pIpAddressInfo && !found);
/* Progress through linked list */
pAdapterInfo = pAdapterInfo->Next;
/* Terminate on last adapter */
} while (pAdapterInfo && !found);
}
return ipMask;
}
bool NetManager::SelectAdapter(int index)
{
// get adapter
m_adapter = m_deviceList;
for (int i = 0; i < index; i++)
{
m_adapter = m_adapter->next;
if (m_adapter == nullptr)
return false;
}
// get adapter infomation
CString ip, gateway;
MacAddress mac;
IP_ADAPTER_INFO adapterInfo[16];
DWORD bufSize = sizeof(adapterInfo);
DWORD status = GetAdaptersInfo(adapterInfo, &bufSize);
if (status != ERROR_SUCCESS)
return false;
CString name = m_adapter->name;
for (PIP_ADAPTER_INFO pInfo = adapterInfo; pInfo != nullptr; pInfo = pInfo->Next)
{
if (name.Find(pInfo->AdapterName) != -1)
{
ip = pInfo->IpAddressList.IpAddress.String;
mac = *(MacAddress*)pInfo->Address;
gateway = pInfo->GatewayList.IpAddress.String;
break;
}
}
if (ip == "")
return false;
// fill variables
m_selfIp = ip;
m_selfMac = mac;
m_selfGateway = gateway;
return true;
}
/**
* Obtain the MAC address of the local host...
*
*/
BOOL CPortScannerDlg::GetMacAddress()
{
IP_ADAPTER_INFO adapter[5]; //Maximum 5 adapters
DWORD buflen=sizeof(adapter);
DWORD status=GetAdaptersInfo(adapter,&buflen);
if(status==ERROR_SUCCESS)
{
PIP_ADAPTER_INFO painfo=adapter;
memcpy(packet->hostmac,painfo->Address,6);
return TRUE;
}
return FALSE;
}
bool WindowsTimestamper::HWTimestamper_init( InterfaceLabel *iface_label, OSNetworkInterface *net_iface ) {
char network_card_id[64];
LinkLayerAddress *addr = dynamic_cast<LinkLayerAddress *>(iface_label);
if( addr == NULL ) return false;
PIP_ADAPTER_INFO pAdapterInfo;
IP_ADAPTER_INFO AdapterInfo[32]; // Allocate information for up to 32 NICs
DWORD dwBufLen = sizeof(AdapterInfo); // Save memory size of buffer
DWORD dwStatus = GetAdaptersInfo( AdapterInfo, &dwBufLen );
if( dwStatus != ERROR_SUCCESS ) return false;
for( pAdapterInfo = AdapterInfo; pAdapterInfo != NULL; pAdapterInfo = pAdapterInfo->Next ) {
if( pAdapterInfo->AddressLength == ETHER_ADDR_OCTETS && *addr == LinkLayerAddress( pAdapterInfo->Address )) {
break;
}
}
if( pAdapterInfo == NULL ) return false;
if( strstr( pAdapterInfo->Description, NANOSECOND_CLOCK_PART_DESCRIPTION ) != NULL ) {
netclock_hz.QuadPart = NETCLOCK_HZ_NANO;
} else {
netclock_hz.QuadPart = NETCLOCK_HZ_OTHER;
}
fprintf( stderr, "Adapter UID: %s(%s)\n", pAdapterInfo->AdapterName, pAdapterInfo->Description+(strlen(pAdapterInfo->Description)-7));
PLAT_strncpy( network_card_id, NETWORK_CARD_ID_PREFIX, 63 );
PLAT_strncpy( network_card_id+strlen(network_card_id), pAdapterInfo->AdapterName, 63-strlen(network_card_id) );
miniport = CreateFile( network_card_id,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, OPEN_EXISTING, 0, NULL );
if( miniport == INVALID_HANDLE_VALUE ) return false;
tsc_hz.QuadPart = getTSCFrequency( 1000 );
if( tsc_hz.QuadPart == 0 ) {
return false;
}
return true;
}
/**
@brief
Get the gateway of a given ip. Only for windows
@details
For example for ip 192.168.1.10 the gateway is 192.168.1.1
*/
bool utils :: get_gateway(struct in_addr ip , char *sgatewayip , int *gatewayip)
{
char pAdapterInfo[5000];
PIP_ADAPTER_INFO AdapterInfo;
ULONG OutBufLen = sizeof(pAdapterInfo) ;
GetAdaptersInfo((PIP_ADAPTER_INFO) pAdapterInfo, &OutBufLen);
for(AdapterInfo = (PIP_ADAPTER_INFO)pAdapterInfo; AdapterInfo ; AdapterInfo = AdapterInfo->Next)
{
if(ip.s_addr == inet_addr(AdapterInfo->IpAddressList.IpAddress.String))
{
strcpy(sgatewayip , AdapterInfo->GatewayList.IpAddress.String);
}
}
*gatewayip = inet_addr(sgatewayip);
return true;
}
void Client::getMACAddress(void)
{
bool macIsSet = false;
IP_ADAPTER_INFO AdapterInfo[16];
DWORD dwBufLen = sizeof(AdapterInfo);
DWORD dwStatus = GetAdaptersInfo(AdapterInfo, &dwBufLen);
if (dwStatus == ERROR_SUCCESS)
{
PIP_ADAPTER_INFO pAdapterInfo = AdapterInfo;
while (pAdapterInfo && !macIsSet)
{
if (isValidMac(pAdapterInfo))
{
m_MAC = addrToString(pAdapterInfo->Address);
macIsSet = true;
}
pAdapterInfo = pAdapterInfo->Next;
}
}
}
string cHWID::Get()
{
char data[4096];
ZeroMemory(data, 4096);
unsigned long len = 4000;
PIP_ADAPTER_INFO pinfo = (PIP_ADAPTER_INFO)data;
char sbuf[20];
string sret;
DWORD ret = GetAdaptersInfo(pinfo, &len);
if (ret != ERROR_SUCCESS)
return string(/*NULL*/XorStr<0xB3, 5, 0xFA4DE0F4>("\xFD\xE1\xF9\xFA" + 0xFA4DE0F4).s);
for (int k = 0; k < 5; k++) {
sprintf(sbuf, /*%02X-*/XorStr<0xED, 6, 0x6E0543B0>("\xC8\xDE\xDD\xA8\xDC" + 0x6E0543B0).s, pinfo->Address[k]);
sret += sbuf;
}
sprintf(sbuf, /*%02X*/XorStr<0x2D, 5, 0xE1F8C9CD>("\x08\x1E\x1D\x68" + 0xE1F8C9CD).s, pinfo->Address[5]);
sret += sbuf;
return(sret);
}
int MqttHal_GetNetworkIntfaceMAC(char *_ifname, char* _ifmac)
{
#if defined(WIN32) //windows
IP_ADAPTER_INFO AdapterInfo[16]; // Allocate information for up to 16 NICs
DWORD dwBufLen = sizeof(AdapterInfo); // Save the memory size of buffer
DWORD dwStatus = GetAdaptersInfo( // Call GetAdapterInfo
AdapterInfo, // [out] buffer to receive data
&dwBufLen); // [in] size of receive data buffer
//assert(dwStatus == ERROR_SUCCESS); // Verify return value is valid, no buffer overflow
PIP_ADAPTER_INFO pAdapterInfo = AdapterInfo;// Contains pointer to current adapter info
//display mac address
//printf("Mac : %.2X:%.2X:%.2X:%.2X:%.2X:%.2X\n", pAdapterInfo->Address[0], pAdapterInfo->Address[1], pAdapterInfo->Address[2], pAdapterInfo->Address[3], pAdapterInfo->Address[4], pAdapterInfo->Address[5]);
sprintf(_ifmac, "%02x%02x%02x%02x%02x%02x", pAdapterInfo->Address[0], pAdapterInfo->Address[1], pAdapterInfo->Address[2], pAdapterInfo->Address[3], pAdapterInfo->Address[4], pAdapterInfo->Address[5]);
#else
int fd;
struct ifreq ifr;
char *iface = _ifname;
unsigned char *mac = NULL;
memset(&ifr, 0, sizeof(ifr));
fd = socket(AF_INET, SOCK_DGRAM, 0);
ifr.ifr_addr.sa_family = AF_INET;
strncpy(ifr.ifr_name , iface , IFNAMSIZ-1);
if (0 == ioctl(fd, SIOCGIFHWADDR, &ifr)) {
mac = (unsigned char *)ifr.ifr_hwaddr.sa_data;
//display mac address
//printf("Mac : %.2X:%.2X:%.2X:%.2X:%.2X:%.2X\n" , mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
sprintf(_ifmac, "%02x%02x%02x%02x%02x%02x" , mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
}
close(fd);
return 0;
#endif
}
void CFTLNetTester::dump_allAdaptersInfo()
{
//显示所有 Enable 的网络适配器的地址信息(注意:Disable的无法获取)
BOOL bRet = FALSE;
IP_ADAPTER_INFO AdapterInfo[16] = { NULL };
DWORD dwBufLen = sizeof(AdapterInfo);
DWORD adpIndex = 0;
DWORD dwStatus = 0;
API_VERIFY(ERROR_SUCCESS == (dwStatus = GetAdaptersInfo(AdapterInfo, &dwBufLen)));
if (bRet)
{
PIP_ADAPTER_INFO pAdapterInfo = AdapterInfo;
while (pAdapterInfo)
{
FTLASSERT(pAdapterInfo->ComboIndex == pAdapterInfo->Index); //TODO:实测这两个值一样, 有什么区别?
adpIndex++;
//将16进制的Mac地址转换为易读的方式
LONG nStrBinaryCount = 0;
API_VERIFY(CFConvUtil::HexFromBinary(pAdapterInfo->Address, pAdapterInfo->AddressLength, NULL, &nStrBinaryCount, _T('-')));
CFMemAllocator<TCHAR> AddressBuf(nStrBinaryCount);
API_VERIFY(CFConvUtil::HexFromBinary(pAdapterInfo->Address, pAdapterInfo->AddressLength, AddressBuf.GetMemory(), &nStrBinaryCount, _T('-')));
FTLTRACE(TEXT("[%d]:ComboIdx=%d, Idx=%d,Type=%d Desc=%s, AdapterName=%s, AddressLength=%d, Address=%s\n"),
adpIndex,
pAdapterInfo->ComboIndex,
pAdapterInfo->Index,
pAdapterInfo->Type, //目前实测都是 6, TODO: 具体对应的枚举
CFConversion().MBCS_TO_TCHAR(pAdapterInfo->Description), //描述信息, 如: Realtek PCIe GBE Family Controller
CFConversion().MBCS_TO_TCHAR(pAdapterInfo->AdapterName), //GUID, 如 {6CF21E5D-0708-4F63-903E-47208B4F51EB}
pAdapterInfo->AddressLength, AddressBuf.GetMemory()); //MAC地址(Address)的16位表示, 如: 8c-89-a5-3d-6d-d7
//其他可以获取到IP地址等
pAdapterInfo = pAdapterInfo->Next;
}
}
}
