netdev_lib.cpp

270的linux说明

	return NETDEV_SUCCESS;
}

netdev_ret wnetdev_get_wep(netdev_dev &dev, wnetdev_wep &wep)
{
	struct iwreq wrq;
	unsigned char key[WNETDEVKEYLENMAX];
	memset(&wep, 0, sizeof(wnetdev_wep));

	wrq.u.data.pointer = (caddr_t)key;
	wrq.u.data.length = WNETDEVKEYLENMAX;
	wrq.u.data.flags = 0;
	if(_get_iwreq(dev.ifname, SIOCGIWENCODE, wrq) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

	if(wrq.u.data.flags & IW_ENCODE_DISABLED)
	{
		return NETDEV_FAIL;
	}

	memcpy(&(wep.key), key, WNETDEVKEYLENMAX);
	wep.key_len = wrq.u.data.length * 8;

	wep.index = wrq.u.data.flags & IW_ENCODE_INDEX;

	if(wrq.u.data.flags & IW_ENCODE_RESTRICTED)
	{
		wep.mode = WEP_RESTRICTED;
	}
	else if(wrq.u.data.flags & IW_ENCODE_OPEN)
	{
		wep.mode = WEP_OPEN;
	}
	else
	{
		wep.mode = WEP_UNKNOWN;
	}

	return NETDEV_SUCCESS;
}

netdev_ret wnetdev_get_txpower(netdev_dev &dev, wnetdev_txpower &txpower)
{
	struct iwreq wrq;

	if(_get_iwreq(dev.ifname, SIOCGIWTXPOW, wrq) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

	if(wrq.u.txpower.disabled)
	{
		return NETDEV_FAIL;
	}

	txpower = wrq.u.txpower.value;
	//convert dBm to mWatt
	if(wrq.u.txpower.flags & IW_TXPOW_DBM)
	{
		txpower = ((wnetdev_txpower) (floor(pow(10.0, (((double) txpower) / 10.0)))));
	}

	return NETDEV_SUCCESS;
}

netdev_ret wnetdev_get_pm_info(netdev_dev &dev, wnetdev_pm_info &pm_info)
{
	struct iwreq wrq;
	
	//try to get the current;
	wrq.u.power.flags = 0;
	if(_get_iwreq(dev.ifname, SIOCGIWPOWER, wrq) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

	if(wrq.u.power.disabled)
	{
		return NETDEV_FAIL;
	}

	if(wrq.u.power.flags & IW_POWER_PERIOD)
	{
		pm_info.current_period = wrq.u.power.value;
	}
	else
	{
		return NETDEV_FAIL;
	}

	switch (wrq.u.power.flags & IW_POWER_MODE)
	{
		case IW_POWER_UNICAST_R:
			pm_info.mode = PM_UNICAST_ONLY;
			break;
		case IW_POWER_MULTICAST_R:
			pm_info.mode = PM_MULTICAST_ONLY;
			break;
		case IW_POWER_ALL_R:
			pm_info.mode = PM_ALL;
			break;
		case IW_POWER_FORCE_S:
			pm_info.mode = PM_FORCE_SEND;
			break;
		case IW_POWER_REPEATER:
			pm_info.mode = PM_REPEAT_MUL;
			break;
		default:
			pm_info.mode = PM_UNKNOWN;
	}

	struct iw_range range;
	if(_get_iwrange(dev.ifname, range) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}
	
	if(!(range.pm_capa & IW_POWER_PERIOD))
	{
		return NETDEV_FAIL;
	}

	pm_info.min_period = range.min_pmp;
	pm_info.max_period = range.max_pmp;

	return NETDEV_SUCCESS;
}


//for testing
inline void _print_tab(int tablen)
{
	for(int i = 0; i < tablen; i++)
		printf("\t");
}

void _print_netdev(netdev_dev &netdev, int tablen)
{
	_print_tab(tablen);
	printf("NetDev:\n");
	_print_tab(tablen);
	printf("\tnetdev.ifname: %s\n", netdev.ifname);
	_print_tab(tablen);
	printf("\tnetdev.index: %d\n", netdev.index);
	_print_tab(tablen);
	printf("\tnetdev.hwaddr: %02X:%02X:%02X:%02X:%02X:%02X\n", 
		netdev.hwaddr[0] & 0377, netdev.hwaddr[1] & 0377, 
		netdev.hwaddr[2] & 0377, netdev.hwaddr[3] & 0377, 
		netdev.hwaddr[4] & 0377, netdev.hwaddr[5] & 0377);
}

void _print_netdev_more(netdev_dev &netdev, int tablen)
{
	char *prototype[4] = {
		"Unknown",
		"802.3",
		"802.11",
		"Bluetooth pan"};

	netdev_type iftype;
	if(netdev_get_type(netdev, iftype) == NETDEV_SUCCESS)	
	{
		_print_tab(tablen);
		printf("\ttype: %s\n", prototype[iftype]);
	}

	int index;
	if(netdev_get_index(netdev, index) == NETDEV_SUCCESS)
	{
		_print_tab(tablen);
		printf("\tindex: %d\n", index);
	}

	netdev_hwaddr hwaddr;
	if(netdev_get_hwaddr(netdev, hwaddr) == NETDEV_SUCCESS)
	{
		_print_tab(tablen);
		printf("\thwaddr: %02X:%02X:%02X:%02X:%02X:%02X\n", 
			hwaddr[0] & 0377, hwaddr[1] & 0377, 
			hwaddr[2] & 0377, hwaddr[3] & 0377, 
			hwaddr[4] & 0377, hwaddr[5] & 0377);
	}

	netdev_ipaddr ipaddr;
	if(netdev_get_ipaddr(netdev, ipaddr) == NETDEV_SUCCESS)
	{
		_print_tab(tablen);
		struct in_addr inaddr;
		inaddr.s_addr = ipaddr;
		printf("\tipaddr: %s\n", inet_ntoa(inaddr));
	}

	netdev_netmask netmask;
	if(netdev_get_netmask(netdev, netmask) == NETDEV_SUCCESS)
	{
		_print_tab(tablen);
		struct in_addr inaddr;
		inaddr.s_addr = netmask;
		printf("\tnetmask: %s\n", inet_ntoa(inaddr));
	}

	netdev_brdaddr brdaddr;
	if(netdev_get_brdaddr(netdev, brdaddr) == NETDEV_SUCCESS)
	{
		_print_tab(tablen);
		struct in_addr inaddr;
		inaddr.s_addr = brdaddr;
		printf("\tbroad: %s\n", inet_ntoa(inaddr));
	}

	vector<netdev_maddr> maddr_list;
	if(netdev_get_multicast(netdev, maddr_list) == NETDEV_SUCCESS)
	{
		_print_tab(tablen);
		printf("\tmulticast:\n");
		vector<netdev_maddr>::iterator itr = maddr_list.begin();
		for(; itr != maddr_list.end(); itr++)
		{
			_print_tab(tablen);
			struct in_addr inaddr;
			inaddr.s_addr = *itr;
			printf("		%s\n", inet_ntoa(inaddr));
		}
	}

	char *enabled_stat[3] = {
		"Unknown",
		"UP",
		"DOWN"
	};

	netdev_enabled enabled;
	if(netdev_get_enabled(netdev, enabled) == NETDEV_SUCCESS)
	{
		_print_tab(tablen);
		printf("	enabled: %s\n", enabled_stat[enabled]);
	}

	char *running_stat[3] = {
		"Unknwon",
		"Running",
		"Stop"
	};

	netdev_running running;
	if(netdev_get_running(netdev, running) == NETDEV_SUCCESS)
	{
		_print_tab(tablen);
		printf("\trunning: %s\n", running_stat[running]);
	}

	netdev_statistics stats;
	if(netdev_get_statistics(netdev, stats) == NETDEV_SUCCESS)
	{
		_print_tab(tablen);
		printf("\tstats:	rx_bytes[%llu], tx_bytes[%llu]\n", stats.rx_bytes, stats.tx_bytes);
		printf("\t\trx_packets[%llu], tx_packets[%llu]\n", stats.rx_packets, stats.tx_packets);
		printf("\t\trx_errors[%lu], tx_errors[%lu]\n", stats.rx_errors, stats.tx_errors);
	}

	if(_is_80211(netdev))
	{
		wnetdev_ssid ssid;
		if(wnetdev_get_ssid(netdev, ssid) == NETDEV_SUCCESS)
		{
			_print_tab(tablen);
			printf("\tssid: %s\n", ssid);
		}

		vector<wnetdev_freq_channel> freq_list;
		if(wnetdev_get_supported_freqs(netdev, freq_list) == NETDEV_SUCCESS)
		{
			_print_tab(tablen);
			vector<wnetdev_freq_channel>::iterator itr = freq_list.begin();
			printf("\tsupported frequency (channel):\n");
			for(; itr != freq_list.end(); itr++)
			{
				_print_tab(tablen);
				printf("\t\t%f (%d)\n", itr->freq, itr->channel);
			}
		}
		
		wnetdev_freq freq;
		if(wnetdev_get_freq(netdev, freq) == NETDEV_SUCCESS)
		{
			_print_tab(tablen);
			printf("\tcurrent frequency: %f\n", freq);
		}

		wnetdev_channel channel;
		if(wnetdev_get_channel(netdev, channel) == NETDEV_SUCCESS)
		{
			_print_tab(tablen);
			printf("\tcurrent channel: %d\n", channel);
		}

		char *opt_mode[4] = {
			"Unknown",
			"Auto",
			"Ad hoc",
			"Infrastracture"
		};

		wnetdev_opt_mode mode;
		if(wnetdev_get_opt_mode(netdev, mode) == NETDEV_SUCCESS)
		{
			_print_tab(tablen);
			printf("\toperation mode: %s\n", opt_mode[mode]);
		}

		vector<wnetdev_bitrate> rates_list;
		if(wnetdev_get_supported_bitrates(netdev, rates_list) == NETDEV_SUCCESS)
		{
			_print_tab(tablen);
			printf("\tsupported bitrates:\n");
			vector<wnetdev_bitrate>::iterator itr = rates_list.begin();
			for(; itr != rates_list.end(); itr++)
			{
				_print_tab(tablen);
				printf("\t\t%d\n", *itr);
			}
		}

		wnetdev_bitrate rate;
		if(wnetdev_get_bitrate(netdev, rate) == NETDEV_SUCCESS)
		{
			_print_tab(tablen);
			printf("\tcurrent bitrate: %d\n", rate);
		}

		wnetdev_bssid bssid;
		if(wnetdev_get_bssid(netdev, bssid) == NETDEV_SUCCESS)
		{
			_print_tab(tablen);
			printf("\tbssid: %02X:%02X:%02X:%02X:%02X:%02X\n", 
				bssid[0] & 0377, bssid[1] & 0377, 
				bssid[2] & 0377, bssid[3] & 0377, 
				bssid[4] & 0377, bssid[5] & 0377);
		}

		wnetdev_quality quality;
		if(wnetdev_get_quality(netdev, quality) == NETDEV_SUCCESS)
		{
			_print_tab(tablen);
			printf("\tquality: %d/100\n", quality);
		}

		wnetdev_error_stats err_stats;
		if(wnetdev_get_error_stats(netdev, err_stats) == NETDEV_SUCCESS)
		{
			_print_tab(tablen);
			printf("\terror statistics:\n");
			_print_tab(tablen);
			printf("\t\tdiscard_essid:[%d] discard_encrypt:[%d] discard_frag:[%d]\n", 
					err_stats.discard_essid, err_stats.discard_encrypt, err_stats.discard_frag);
			_print_tab(tablen);
			printf("\t\tdiscard_retry:[%d] miss_beacon:[%d]\n", err_stats.discard_retry, err_stats.miss_beacon);
		}

		wnetdev_rts_threshold rts;
		if(wnetdev_get_rts_threshold(netdev, rts) == NETDEV_SUCCESS)
		{
			_print_tab(tablen);
			printf("\trts threshold: %d\n", rts);
		}

		wnetdev_frag_threshold frag;
		if(wnetdev_get_frag_threshold(netdev, frag) == NETDEV_SUCCESS)
		{
			_print_tab(tablen);
			printf("\tfrag threshold: %d\n", frag);
		}

		static char *wep_mode[3] = {
			"Unknown",
			"Open",
			"Restricted"};

		wnetdev_wep wep;
		if(wnetdev_get_wep(netdev, wep) == NETDEV_SUCCESS)
		{
			char buffer[256];
			memset(buffer, 0, sizeof(buffer));
			char *p = buffer;
			int size = wep.key_len / 8;
			sprintf(p, "%.2X", wep.key[0]);      /* Size checked */
			p +=2;
			for(int i = 1; i < size; i++)
		    {
		      if((i & 0x1) == 0)
			  {
				  strcpy(p++, "-");
			  }
			  sprintf(p, "%.2X", wep.key[i]);  /* Size checked */
			  p +=2;
			}

			_print_tab(tablen);
			printf("\twep info:\n");
			_print_tab(tablen);
			printf("\t\tindex:[%d] key:[%s] key_len:[%d] mode:[%s]\n",
					wep.index, buffer, wep.key_len, wep_mode[wep.mode]);
		}

		wnetdev_txpower txpower;
		if(wnetdev_get_txpower(netdev, txpower) == NETDEV_SUCCESS)
		{
			_print_tab(tablen);
			printf("\ttx power: %d\n", txpower);
		}

		static char *pm_mode[6] = {
			"Unknown",
			"All",
			"Unicast only",
			"Multicast only",
			"Force sending",
			"Repeat multicast"};

		wnetdev_pm_info pm;
		if(wnetdev_get_pm_info(netdev, pm) == NETDEV_SUCCESS)
		{
			_print_tab(tablen);
			printf("\tpower management:\n");
			_print_tab(tablen);
			printf("\t\t min_period:[%d] max_period:[%d] current_period:[%d] mode:[%s]\n",
					pm.min_period, pm.max_period, pm.current_period, pm_mode[pm.mode]);
		}

		wnetdev_signal signal;
		if(wnetdev_get_signal(netdev, signal) == NETDEV_SUCCESS)
		{
			_print_tab(tablen);
			printf("\tsignal: %d dBm\n", signal);
		}
	}
}

void _print_btdev(btdev_dev &btdev, int tablen)
{
	_print_tab(tablen);
	printf("BtDev:\n");
	_print_tab(tablen);
	printf("\tname: %s\n", btdev.name);
	_print_tab(tablen);
	printf("\tid: %d\n", btdev.dev_id);
	_print_tab(tablen);
	printf("\taddr: %02X:%02X:%02X:%02X:%02X:%02X\n", 
		btdev.addr[0] & 0377, btdev.addr[1] & 0377, 
		btdev.addr[2] & 0377, btdev.addr[3] & 0377, 
		btdev.addr[4] & 0377, btdev.addr[5] & 0377);
}

//unit test
int main(void)
{
	//vector<netdev_dev> netdev_list;

	//if(netdev_get_devices(netdev_list) == NETDEV_SUCCESS)
	//{
	//	vector<netdev_dev>::iterator itr = netdev_list.begin();

	//	for(; itr != netdev_list.end(); itr++)
	//	{
	//		_print_netdev(*itr, 0);
	//			
	//		btdev_dev btdev;
	//		if(netdev_get_btdev(*itr, btdev) == NETDEV_SUCCESS)
	//		{
	//			_print_btdev(btdev, 1);
	//		}
	//		_print_netdev_more(*itr, 0);
	//		printf("\n\n");
	//	}
	//}


}