自学教程：C++ GetAdaptersInfo函数代码示例

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

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

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]);}

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

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

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