netdev_lib.cpp

270的linux说明

/*

Copyright (c) 2008, Intel Corporation. 

All rights reserved.

 

Redistribution and use in source and binary forms, with or without modification, 
are permitted provided that the following conditions are met:


    * Redistributions of source code must retain the above copyright notice, 
this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright notice, 
this list of conditions and the following disclaimer in the documentation and/or 
other materials provided with the distribution.

    * Neither the name of Intel Corporation nor the names of its contributors 
may be used to endorse or promote products derived from this software without 
specific prior written permission.

 

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
OF SUCH DAMAGE.

*/

#include "netdev_lib.h"
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <math.h>
#include <unistd.h>

//linux network headers
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <net/if_arp.h>
#include <arpa/inet.h>
#include <net/if.h> 
#include <sys/types.h>
#include <linux/types.h>
#include "wireless_utility.h"


//internal usage 
#define PROC_NET_DEV "/proc/net/dev"
#define PROC_NET_WIRELESS "/proc/net/wireless"
#define PROC_NET_IGMP "/proc/net/igmp"


netdev_ret _get_proc_net_dev_name(char *buf, char *ifname);
netdev_ret _get_proc_net_dev_stats(char *buf, netdev_statistics &stats);

netdev_ret _get_af_socket(int &sock);

netdev_ret _get_ifreq(char *ifname, int cmd, struct ifreq &ifr); 
netdev_ret _get_iwrange(char *ifname, struct iw_range &range);
netdev_ret _get_iwstats(char *ifname, struct iw_statistics &stats);

bool _is_80211(netdev_dev &dev);
bool _is_bluetooth(netdev_dev &dev);
bool _is_80203(netdev_dev &dev);

bool _compare_hwaddr(char *hwaddr1, char *hwaddr2, int len);
bool _swap_hwaddr(char *hwaddr, int len);
void _print_netdev(netdev_dev &netdev, int tablen);
void _print_btdev(btdev_dev &btdev, int tablen);

bool _compare_hwaddr(char *hwaddr1, char *hwaddr2, int len)
{
	int i = 0;
	for(; i < len; i++)
	{
		if(hwaddr1[i] != hwaddr2[i])
			break;
	}
	if(i < len)
		return false;
	else
		return true;
}

bool _swap_hwaddr(char *hwaddr, int len)
{
	char *temp = (char *)malloc(len);
	if(temp == NULL)
	{
		return false;
	}

	for(int i = 0; i < len; i++)
	{
		temp[i] = hwaddr[(len - 1) - i ];
	}

	memcpy(hwaddr, temp, len);

	return true;
}

netdev_ret _get_proc_net_dev_name(char *buf, char *ifname)
{
	char *start, *end, *p;
	start = buf;

	if(buf == NULL)
	{
		return NETDEV_ERROR;
	}

	while(*start && isspace(*start))
	{
		start++;
	}

	end = strchr(buf, ':');
	if(end == NULL)
	{
		return NETDEV_ERROR;
	}

	p = ifname;
	while(start < end)
	{
		if(isspace(*start))
		{
			start++;
			continue;
		}
		*p++ = *start++;
	}

	*p++ = '\0';

	if(strlen(ifname) <= 0)
	{
		return NETDEV_FAIL;
	}

	return NETDEV_SUCCESS;
}

netdev_ret _get_proc_net_dev_stats(char *buf, netdev_statistics &stats)
{
	char *start;

	if(buf == NULL)
	{
		return NETDEV_ERROR;
	}

	start = strchr(buf, ':');
	if(start == NULL)
	{
		return NETDEV_ERROR;
	}
	//skip the ':'
	start++;

	sscanf(start,
		"%llu %llu %lu %lu %lu %lu %lu %lu %llu %llu %lu %lu %lu %lu %lu %lu",
		&stats.rx_bytes,
		&stats.rx_packets,
		&stats.rx_errors,
		&stats.rx_dropped,
		&stats.rx_fifo_errors,
		&stats.rx_frame_errors,
		&stats.rx_compressed,
		&stats.rx_multicast,
		&stats.tx_bytes,
		&stats.tx_packets,
		&stats.tx_errors,
		&stats.tx_dropped,
		&stats.tx_fifo_errors,
		&stats.tx_frame_errors,
		&stats.tx_compressed,
		&stats.tx_multicast
	);

	return NETDEV_SUCCESS;
}

netdev_ret _get_socket(int &sock)
{
	int ret = socket(AF_INET, SOCK_DGRAM, 0);
	if(ret < 0)
	{
		sock = -1;
		return NETDEV_ERROR;
	}

	sock = ret;
	return NETDEV_SUCCESS;
}

netdev_ret _close_socket(int sock)
{
	int ret = close(sock);
	if(ret < 0)
	{
		return NETDEV_ERROR;
	}

	return NETDEV_SUCCESS;
}

netdev_ret _get_ifreq(char *ifname, int cmd, struct ifreq &ifr)
{
	int sock;

	if(_get_socket(sock) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}	

	strncpy(ifr.ifr_name, ifname, NETDEVNAMSIZ);

	int ret = ioctl(sock, cmd, &ifr);

	if(ret < 0)
	{
		_close_socket(sock);
		return NETDEV_ERROR;
	}

	_close_socket(sock);
	return NETDEV_SUCCESS;
}

netdev_ret _get_iwreq(char *ifname, int cmd, struct iwreq &iwr)
{
	int sock;

	if(_get_socket(sock) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}	

	strncpy(iwr.ifr_name, ifname, NETDEVNAMSIZ);

	int ret = ioctl(sock, cmd, &iwr);

	if(ret < 0)
	{
		_close_socket(sock);
		return NETDEV_ERROR;
	}

	_close_socket(sock);
	return NETDEV_SUCCESS;

}

netdev_ret _set_iwreq(char *ifname, int cmd, struct iwreq &iwr)
{

	return _get_iwreq(ifname,cmd,iwr);

}


netdev_ret _get_iwrange(char *ifname, struct iw_range &range)
{
	struct iwreq wrq;

	memset(&range, 0, sizeof(struct iw_range));
	wrq.u.data.pointer = (caddr_t)&range;
	wrq.u.data.length = sizeof(struct iw_range);
	wrq.u.data.flags = 0;
	if(_get_iwreq(ifname, SIOCGIWRANGE, wrq) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

	return NETDEV_SUCCESS;
}

netdev_ret _get_iwstats(char *ifname, struct iw_statistics &stats)
{
	struct iwreq wrq;

	wrq.u.data.pointer = (caddr_t)&stats;
	wrq.u.data.length = sizeof(struct iw_statistics);
	wrq.u.data.flags = 1;

	if(_get_iwreq(ifname, SIOCGIWSTATS, wrq) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

	return NETDEV_SUCCESS;
}

bool _is_80211(netdev_dev &dev)
{
	bool is;
	struct iwreq iwr;
	if(_get_iwreq(dev.ifname, SIOCGIWNAME, iwr) != NETDEV_SUCCESS)
	{
		is = false;
	}
	else
	{
		is = true;
	}

	return is;
}

bool _is_bluetooth(netdev_dev &dev)
{
	bool is = false;
	//btdev_dev btdev;
	//if(netdev_get_btdev(dev, btdev) != NETDEV_SUCCESS)
	//{
	//	is = false;
	//}
	//else
	//{
	//	is = true;
	//}

	return is;
}



//enumerate the network devices in /proc/net/dev.
//it will return all network devices including 802.3, 802.11 and bluetoothPan
netdev_ret netdev_get_devices(/*out*/vector<netdev_dev> &dev_list)
{
	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);

	dev_list.clear();
	//enumerate the ETHERNET network device
	while(fgets(buf, sizeof(buf), pf))
	{
		char ifname[NETDEVNAMSIZ];
		if(_get_proc_net_dev_name(buf, ifname) != NETDEV_SUCCESS)
		{
			continue;
		}

		struct ifreq ifr;		
		if(_get_ifreq(ifname, SIOCGIFHWADDR, ifr) != NETDEV_SUCCESS)
		{
			continue;
		}
		
		//we only care ETHERNET
		if(ifr.ifr_hwaddr.sa_family != ARPHRD_ETHER)
		{
			continue;
		}

		netdev_dev dev;
		strncpy(dev.ifname, ifname, NETDEVNAMSIZ);
		
		memcpy(dev.hwaddr, ifr.ifr_hwaddr.sa_data, HWADDRLEN);

		if(_get_ifreq(ifname, SIOCGIFINDEX, ifr) != NETDEV_SUCCESS)
		{
			continue;
		}

		dev.index = ifr.ifr_ifindex;

		dev_list.push_back(dev);
	}

	fclose(pf);
	return NETDEV_SUCCESS;
}

netdev_ret netdev_get_device(const char *ifname, netdev_dev &dev)
{
	if(ifname == NULL)
	{
		return NETDEV_ERROR;
	}

	vector<netdev_dev> dev_list;
	if(netdev_get_devices(dev_list) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}

	vector<netdev_dev>::iterator itr = dev_list.begin();
	for(; itr != dev_list.end(); itr++)
	{
		if(!strcmp(ifname, itr->ifname))
		{
			break;
		}
	}

	if(itr == dev_list.end())
	{
		return NETDEV_FAIL;
	}
	
	memcpy(&dev, &(*itr), sizeof(netdev_dev));

	return NETDEV_SUCCESS;
}

netdev_ret netdev_get_type(/*in*/netdev_dev &dev, /*out*/netdev_type &type)
{
	netdev_ret ret;

	//check the if it is Ethernet first
	struct ifreq ifr;		
	ifr.ifr_ifindex = dev.index;
	if(_get_ifreq(dev.ifname, SIOCGIFNAME, ifr) != NETDEV_SUCCESS)
	{
		type = TYPE_UNKNOWN;
		return NETDEV_ERROR;
	}

	if(_get_ifreq(dev.ifname, SIOCGIFHWADDR, ifr) != NETDEV_SUCCESS)
	{
		type = TYPE_UNKNOWN;
		return NETDEV_ERROR;		
	}
	else if(!_compare_hwaddr(dev.hwaddr, ifr.ifr_hwaddr.sa_data, HWADDRLEN))
	{
		type = TYPE_UNKNOWN;
		return NETDEV_ERROR;
	}
	else if(ifr.ifr_hwaddr.sa_family != ARPHRD_ETHER)
	{
		type = TYPE_UNKNOWN;
		return NETDEV_SUCCESS;
	}

	if(_is_80211(dev))
	{
		type = TYPE_802_11;
	}
	else if(_is_bluetooth(dev))
	{
		type = TYPE_BLUETOOTH;
	}
	else
	{
		type = TYPE_802_3;
	}

	return NETDEV_SUCCESS;
}

netdev_ret netdev_get_index(/*in*/netdev_dev &dev, /*out*/int &index)
{
	struct ifreq ifr;
	if(_get_ifreq(dev.ifname, SIOCGIFINDEX, ifr) != NETDEV_SUCCESS)
	{
		return NETDEV_ERROR;
	}