netdev_lib.cpp

270的linux说明

	dev.index = ifr.ifr_ifindex;
	index = dev.index;
	return NETDEV_SUCCESS;
}

netdev_ret netdev_get_hwaddr(/*in*/netdev_dev &dev, /*out*/netdev_hwaddr &hwaddr)
{
	struct ifreq ifr;
	if(_get_ifreq(dev.ifname, SIOCGIFHWADDR, ifr) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

	memcpy(dev.hwaddr, ifr.ifr_hwaddr.sa_data, HWADDRLEN);
	memcpy(hwaddr, dev.hwaddr, HWADDRLEN);
	return NETDEV_SUCCESS;
}

netdev_ret netdev_get_ipaddr(/*in*/netdev_dev &dev, /*out*/netdev_ipaddr &ipaddr)
{
	struct ifreq ifr;
	if(_get_ifreq(dev.ifname, SIOCGIFADDR, ifr) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

	struct sockaddr_in *inaddr = (struct sockaddr_in *) &ifr.ifr_addr;
	memcpy(&ipaddr, &((inaddr->sin_addr).s_addr), IPV4ADDRLEN);
	return NETDEV_SUCCESS;	
}

netdev_ret netdev_get_netmask(/*in*/netdev_dev &dev, /*out*/netdev_netmask &netmask)
{
	struct ifreq ifr;
	if(_get_ifreq(dev.ifname, SIOCGIFNETMASK, ifr) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

	struct sockaddr_in *inaddr = (struct sockaddr_in *) &ifr.ifr_netmask;
	memcpy(&netmask, &((inaddr->sin_addr).s_addr), IPV4ADDRLEN);
	return NETDEV_SUCCESS;
}

netdev_ret netdev_get_brdaddr(/*in*/netdev_dev &dev, /*out*/netdev_brdaddr &brdaddr)
{
	struct ifreq ifr;
	if(_get_ifreq(dev.ifname, SIOCGIFBRDADDR, ifr) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

	struct sockaddr_in *inaddr = (struct sockaddr_in *) &ifr.ifr_broadaddr;
	memcpy(&brdaddr, &((inaddr->sin_addr).s_addr), IPV4ADDRLEN);
	return NETDEV_SUCCESS;
}

netdev_ret netdev_get_enabled(/*in*/netdev_dev &dev, /*out*/netdev_enabled &enabled)
{
	struct ifreq ifr;
	if(_get_ifreq(dev.ifname, SIOCGIFFLAGS, ifr) != NETDEV_SUCCESS)
	{
		enabled = ENABLED_UNKNOWN;
		return NETDEV_ERROR;
	}

	short flags = ifr.ifr_flags;
	if(flags & IFF_UP)
	{
		enabled = ENABLED_UP;
	}
	else
	{
		enabled = ENABLED_DOWN;
	}

	return NETDEV_SUCCESS;
}

netdev_ret netdev_get_running(/*in*/netdev_dev &dev, /*out*/netdev_running &running)
{
	struct ifreq ifr;
	if(_get_ifreq(dev.ifname, SIOCGIFFLAGS, ifr) != NETDEV_SUCCESS)
	{
		running = RUNNING_UNKNOWN;
		return NETDEV_ERROR;
	}

	short flags = ifr.ifr_flags;
	if(flags & IFF_RUNNING)
	{
		running = RUNNING_RUN;
	}
	else
	{
		running = RUNNING_STOP;
	}

	return NETDEV_SUCCESS;

}

netdev_ret netdev_get_statistics(/*in*/netdev_dev &dev, /*out*/netdev_statistics &stat)
{
	netdev_ret ret;
	FILE *pf;
	pf = fopen(PROC_NET_DEV, "r");
	if(pf == NULL)
	{
		return NETDEV_ERROR;
	}

	char buf[512];
	//eat lines
	fgets(buf, sizeof(buf), pf);
	fgets(buf, sizeof(buf), pf);

	//enumerate the ETHERNET network device
	bool found = false;
	while(fgets(buf, sizeof(buf), pf))
	{
		char ifname[NETDEVNAMSIZ];
		if(_get_proc_net_dev_name(buf, ifname) != NETDEV_SUCCESS)
		{
			continue;
		}
		if(!strcmp(dev.ifname, ifname))
		{
			found = true;
		}
		else
		{
			continue;
		}

		if(_get_proc_net_dev_stats(buf, stat) != NETDEV_SUCCESS)
		{
			fclose(pf);
			return NETDEV_ERROR;
		}
	}
	if(!found)
	{
		fclose(pf);
		return NETDEV_FAIL;
	}

	fclose(pf);
	return NETDEV_SUCCESS;
}

netdev_ret netdev_get_multicast(/*in*/netdev_dev &dev, /*out*/vector<netdev_maddr> &maddr_list)
{
	netdev_ret ret;
	FILE *pf;
	pf = fopen(PROC_NET_IGMP, "r");
	if(pf == NULL)
	{
		return NETDEV_ERROR;
	}

	char buf[512];
	//eat line
	fgets(buf, sizeof(buf), pf);

	maddr_list.clear();
	bool found = false;
	while(fgets(buf, sizeof(buf), pf))
	{
		char ifname[NETDEVNAMSIZ];
		int	index;
		if(buf[0] != '\t')
		{
			sscanf(buf, "%d %s", &index, ifname);
			if(!strcmp(ifname, dev.ifname) && dev.index == index)
			{
				found = true;
			}
			else
			{
				found = false;
			}
		}
		else
		{
			netdev_maddr maddr;
			int users;
			if(found)
			{
				sscanf(buf, "%08x %d", &maddr, &users); 
				maddr_list.push_back(maddr);
			}
			else
			{
				continue;
			}	
		}
	}

	fclose(pf);
	return NETDEV_SUCCESS;
}

netdev_ret wnetdev_get_ssid(netdev_dev &dev, wnetdev_ssid &ssid)
{
	struct iwreq wrq;
	wrq.u.essid.pointer = (caddr_t) ssid;
	wrq.u.essid.length = WNETDEVESSIDMAXSIZ;
	wrq.u.essid.flags = 0;

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

	if(wrq.u.essid.flags == 0)
	{
		return NETDEV_FAIL;
	}
	
	return NETDEV_SUCCESS;
}

netdev_ret wnetdev_get_freq(netdev_dev &dev, wnetdev_freq &freq)
{
	struct iwreq wrq;
	if(_get_iwreq(dev.ifname, SIOCGIWFREQ, wrq) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

	struct iw_freq *pfreq = &(wrq.u.freq);
	freq = ((double)pfreq->m)*pow(10, pfreq->e);

	return NETDEV_SUCCESS;
}

netdev_ret wnetdev_get_channel(netdev_dev &dev, wnetdev_channel &channel)
{
	vector<wnetdev_freq_channel> freq_list;
	wnetdev_freq freq;

	if(wnetdev_get_supported_freqs(dev, freq_list) != NETDEV_SUCCESS)
	{
		return NETDEV_FAIL;
	}
	if(wnetdev_get_freq(dev, freq) != NETDEV_SUCCESS)
	{
		return NETDEV_FAIL;
	}
	
	vector<wnetdev_freq_channel>::iterator itr = freq_list.begin();
	for(; itr != freq_list.end(); itr++)
	{
		if(itr->freq == freq)
		{
			channel = itr->channel;
			break;
		}
	}

	if(itr == freq_list.end())
	{
		return NETDEV_FAIL;
	}
	else
	{
		return NETDEV_SUCCESS;
	}
}

netdev_ret wnetdev_get_supported_freqs(netdev_dev &dev, vector<wnetdev_freq_channel> &freq_list)
{
	struct iw_range range;
	if(_get_iwrange(dev.ifname, range) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

	if(range.num_frequency <= 0)
	{
		return NETDEV_FAIL;
	}

	freq_list.clear();
	for(int i = 0; i < range.num_frequency; i++)
	{
		wnetdev_freq_channel freq_channel;
		struct iw_freq *pfreq = &(range.freq[i]);
		freq_channel.freq = ((double)pfreq->m)*pow(10, pfreq->e);
		freq_channel.channel = pfreq->i;
		freq_list.push_back(freq_channel);
	}

	return NETDEV_SUCCESS;
}

netdev_ret wnetdev_get_opt_mode(netdev_dev &dev, wnetdev_opt_mode &mode)
{
	struct iwreq wrq;
	if(_get_iwreq(dev.ifname, SIOCGIWMODE, wrq) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

	if(wrq.u.mode == IW_MODE_AUTO)
	{
		mode = OPTMODE_AUTO;
	}
	else if(wrq.u.mode == IW_MODE_ADHOC)
	{
		mode = OPTMODE_ADHOC;
	}
	else if(wrq.u.mode == IW_MODE_INFRA)
	{
		mode = OPTMODE_INFRASTRUCTURE;
	}
	else
	{
		mode = OPTMODE_UNKNOWN;
	}

	return NETDEV_SUCCESS;
}

netdev_ret wnetdev_get_bitrate(netdev_dev &dev, wnetdev_bitrate &rate)
{
	struct iwreq wrq;
	if(_get_iwreq(dev.ifname, SIOCGIWRATE, wrq) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

	rate = wrq.u.bitrate.value; 
	return NETDEV_SUCCESS;
}

netdev_ret wnetdev_get_supported_bitrates(netdev_dev &dev, vector<wnetdev_bitrate> &rates_list)
{
	struct iw_range range;
	if(_get_iwrange(dev.ifname, range) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

	rates_list.clear();
	if((range.num_bitrates <=0) || (range.num_bitrates > IW_MAX_BITRATES))
	{
		return NETDEV_FAIL;
	}

	for(int i = 0; i < range.num_bitrates; i++)
	{
		wnetdev_bitrate rate;
		rate = range.bitrate[i];
		rates_list.push_back(rate);
	}

	return NETDEV_SUCCESS;
}

netdev_ret wnetdev_get_bssid(netdev_dev &dev, wnetdev_bssid &bssid)
{
	struct iwreq wrq;
	if(_get_iwreq(dev.ifname, SIOCGIWAP, wrq) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

	memcpy(&bssid, &(wrq.u.ap_addr.sa_data), WNETDEVBSSIDLEN);

	return NETDEV_SUCCESS;
}

netdev_ret wnetdev_get_quality(netdev_dev &dev, wnetdev_quality &quality)
{
	struct iw_range range;
	if(_get_iwrange(dev.ifname, range) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}	

	struct iw_statistics stats;
	if(_get_iwstats(dev.ifname, stats) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

	//check the valid flag
	if(stats.qual.updated & WNETDEVINVALIDQUAL)
	{
		return NETDEV_FAIL;
	}

	quality =(unsigned long)( ((double)stats.qual.qual /(double) range.max_qual.qual) * 100);
	if(quality > 100)
	{
		quality = 100;
	}

	return NETDEV_SUCCESS;
}

netdev_ret wnetdev_get_signal(netdev_dev &dev, wnetdev_signal &signal)
{
	struct iw_range range;
	if(_get_iwrange(dev.ifname, range) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}	

	struct iw_statistics stats;
	if(_get_iwstats(dev.ifname, stats) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

	//check the valid flag
	if(stats.qual.updated & WNETDEVINVALIDSIG)
	{
		return NETDEV_FAIL;
	}

	//noly return dBm
	if(stats.qual.level == 0 || 
			stats.qual.level > range.max_qual.level)
	{
		return NETDEV_FAIL; 
	}

	signal = stats.qual.level - 0x100;

	return NETDEV_SUCCESS;
}

netdev_ret wnetdev_get_error_stats(netdev_dev &dev, wnetdev_error_stats &error_stats)
{
	struct iw_statistics stats;
	if(_get_iwstats(dev.ifname, stats) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

	error_stats.discard_essid = stats.discard.nwid;
	error_stats.discard_encrypt = stats.discard.code;
	error_stats.discard_frag = stats.discard.fragment;
	error_stats.discard_retry = stats.discard.retries;
	error_stats.miss_beacon = stats.miss.beacon;

	return NETDEV_SUCCESS;
}

netdev_ret wnetdev_get_rts_threshold(netdev_dev &dev, wnetdev_rts_threshold &rts)
{
	struct iwreq wrq;
	if(_get_iwreq(dev.ifname, SIOCGIWRTS, wrq) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

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

	rts = wrq.u.rts.value;
	return NETDEV_SUCCESS;
}

netdev_ret wnetdev_get_frag_threshold(netdev_dev &dev, wnetdev_frag_threshold &frag)
{
	struct iwreq wrq;
	if(_get_iwreq(dev.ifname, SIOCGIWFRAG, wrq) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

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

	frag = wrq.u.frag.value;