secgateway/Platform/user/configm/config-server/netconfig/ifconfig.c

595 lines
14 KiB
C
Raw Normal View History

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <netinet/in.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include "rpc.h"
#include "netconfig.h"
#include "parsefile.h"
#ifndef _LINUX_IN6_H
/*
* This is in linux/include/net/ipv6.h.
*/
struct in6_ifreq {
struct in6_addr ifr6_addr;
uint ifr6_prefixlen;
unsigned int ifr6_ifindex;
};
#endif
net_ifnum_t g_if_num = {.wan_num = 2, .lan_num = 4};
/* Display an Ethernet address in readable format. */
static void print_ether(char *buff, unsigned char *ptr)
{
snprintf(buff, 32, "%02X:%02X:%02X:%02X:%02X:%02X",
(ptr[0] & 0377), (ptr[1] & 0377), (ptr[2] & 0377),
(ptr[3] & 0377), (ptr[4] & 0377), (ptr[5] & 0377)
);
}
#if 0
static uint ethtool_cmd_speed(const struct ethtool_cmd *ep)
{
return (ep->speed_hi << 16) | ep->speed;
}
#endif
/* call ioctl system call */
ret_code if_ioctl(int af, unsigned long request, caddr_t ifreq, int *ret)
{
int sock;
int err = 0;
if(ret)
{
*ret = 0;
}
sock = socket(af, SOCK_DGRAM, 0);
if (sock < 0)
{
rpc_log_error("Cannot create UDP socket");
return RET_SYSERR;
}
if ((err = ioctl(sock, request, ifreq)) < 0)
{
rpc_log_error("Ioctl error: %s\n", strerror(errno));
}
close(sock);
if (err < 0)
{
if(ret)
{
*ret = err;
}
return RET_SYSERR;
}
return RET_OK;
}
/* call ioctl system call */
ret_code if_ethctl(char *name, void *cmd, int *ret)
{
struct ifreq ifr = {0};
int sock;
int err = 0;
if(ret)
{
*ret = 0;
}
sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0)
{
rpc_log_error("Cannot create UDP socket");
return RET_SYSERR;
}
strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name) - 1);
ifr.ifr_data = cmd;
if ((err = ioctl(sock, SIOCETHTOOL, &ifr)) < 0)
{
rpc_log_error("Ioctl error: %s\n", strerror(errno));
}
close(sock);
if (err < 0)
{
if(ret)
{
*ret = err;
}
return RET_SYSERR;
}
return RET_OK;
}
ret_code if_get_linksetting(if_info_t *if_info, int *code)
{
ret_code ret = RET_OK;
struct ethtool_link_data ecmd;
unsigned int u32_offs;
/* Handshake with kernel to determine number of words for link
* mode bitmaps. When requested number of bitmap words is not
* the one expected by kernel, the latter returns the integer
* opposite of what it is expecting. We request length 0 below
* (aka. invalid bitmap length) to get this info.
*/
memset(&ecmd, 0, sizeof(ecmd));
ecmd.req.cmd = ETHTOOL_GLINKSETTINGS;
ret = if_ethctl(if_info->ifname, &ecmd, code);
ASSERT_RET(ret);
/* see above: we expect a strictly negative value from kernel.
*/
ASSERT_COND(ecmd.req.link_mode_masks_nwords >= 0
|| ecmd.req.cmd != ETHTOOL_GLINKSETTINGS);
/* got the real ecmd.req.link_mode_masks_nwords,
* now send the real request
*/
ecmd.req.cmd = ETHTOOL_GLINKSETTINGS;
ecmd.req.link_mode_masks_nwords = -ecmd.req.link_mode_masks_nwords;
ret = if_ethctl(if_info->ifname, &ecmd, code);
ASSERT_RET(ret);
ASSERT_COND(ecmd.req.link_mode_masks_nwords <= 0
|| ecmd.req.cmd != ETHTOOL_GLINKSETTINGS);
sprintf(if_info->maxspeed, "%uMb/s", ecmd.req.speed);
return ret;
}
ret_code if_get_setting(if_info_t *if_info, int *code)
{
ret_code ret = RET_OK;
struct ethtool_cmd ecmd;
memset(&ecmd, 0, sizeof(ecmd));
ecmd.cmd = ETHTOOL_GSET;
ret = if_ethctl(if_info->ifname, &ecmd, code);
ASSERT_RET(ret);
sprintf(if_info->maxspeed, "%uMb/s", ethtool_cmd_speed(&ecmd));
return ret;
}
ret_code if_get_linkstat(if_info_t *if_info, int *code)
{
struct ethtool_value edata = {0};
ret_code ret = RET_OK;
edata.cmd = ETHTOOL_GLINK;
ret = if_ethctl(if_info->ifname, &edata, code);
ASSERT_RET(ret);
if(edata.data)
{
strcpy(if_info->state, "up");
}
else
{
strcpy(if_info->state, "down");
}
return ret;
}
ret_code if_get_maxspeed(if_info_t *if_info, int *code)
{
ret_code ret = RET_OK;
ret = if_get_linksetting(if_info, code);
if(ret != RET_OK)
{
ret = if_get_setting(if_info, code);
}
ASSERT_RET(ret);
return ret;
}
ret_code if_get_hwaddr(if_info_t *if_info, int *code)
{
struct ifreq ifr = {0};
ret_code ret = RET_OK;
if_role_file_get(if_info->ifname, if_info->role, INTERFACE_NAMSIZ);
strncpy(ifr.ifr_name, if_info->ifname, sizeof(ifr.ifr_name) - 1);
ret = if_ioctl(AF_INET, SIOCGIFHWADDR, (caddr_t)&ifr, code);
ASSERT_RET(ret);
print_ether(if_info->hwaddr, ifr.ifr_hwaddr.sa_data);
return ret;
}
/* Set a certain interface flag. */
static int if_set_flag(char *ifname, short flag, int *code)
{
struct ifreq ifr = {0};
ret_code ret = RET_OK;
strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name) - 1);
ret = if_ioctl(AF_INET, SIOCGIFFLAGS, (caddr_t)&ifr, code);
ASSERT_RET(ret);
strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name) - 1);
ifr.ifr_flags |= flag;
ret = if_ioctl(AF_INET, SIOCSIFFLAGS, (caddr_t)&ifr, code);
ASSERT_RET(ret);
return ret;
}
/* Clear a certain interface flag. */
static int if_clear_flag(char *ifname, short flag, int *code)
{
struct ifreq ifr = {0};
ret_code ret;
strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name) - 1);
ret = if_ioctl(AF_INET, SIOCGIFFLAGS, (caddr_t)&ifr, code);
ASSERT_RET(ret);
strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name) - 1);
ifr.ifr_flags &= ~flag;
ret = if_ioctl(AF_INET, SIOCSIFFLAGS, (caddr_t)&ifr, code);
ASSERT_RET(ret);
return ret;
}
ret_code if_set_up(char *ifname, int *code)
{
return if_set_flag(ifname, (IFF_UP | IFF_RUNNING), code);
}
ret_code if_set_down(char *ifname, int *code)
{
return if_clear_flag(ifname, IFF_UP, code);
}
int if_get_allport(struct ifreq *ifreq, int max_port)
{
ret_code ret = RET_OK;
struct ifconf ifc;
int if_count;
int code;
if_count = if_read_dev_file(ifreq, max_port);
if(if_count == 0)
{
memset(&ifc, 0, sizeof(struct ifconf));
ifc.ifc_len = max_port * sizeof(struct ifreq);
ifc.ifc_buf = (char *)ifreq;
ret = if_ioctl(AF_INET, SIOCGIFCONF, (caddr_t)&ifc, &code);
ASSERT_RET(ret);
if_count = ifc.ifc_len / (sizeof(struct ifreq));
}
return if_count;
}
ret_code if_set_prefix(ip_config_t *ip_conf, int *code)
{
ret_code ret;
struct ifreq ifreq = {0};
struct sockaddr_in addr;
struct sockaddr_in mask;
strncpy(ifreq.ifr_name, ip_conf->ifname, sizeof(ifreq.ifr_name) - 1);
addr.sin_addr = ip_conf->prefix;
addr.sin_family = ip_conf->family;
memcpy(&ifreq.ifr_addr, &addr, sizeof(struct sockaddr_in));
ret = if_ioctl(AF_INET, SIOCSIFADDR, (caddr_t)&ifreq, code);
ASSERT_RET(ret);
if(ip_conf->prefix.s_addr != 0)
{
masklen2ip(ip_conf->prefixlen, &mask.sin_addr);
mask.sin_family = ip_conf->family;
memcpy(&ifreq.ifr_netmask, &mask, sizeof(struct sockaddr_in));
ret = if_ioctl(AF_INET, SIOCSIFNETMASK, (caddr_t)&ifreq, code);
ASSERT_RET(ret);
}
return RET_OK;
}
ret_code if_set_prefix6(uint config_type, ip_config_t *ip_conf, int *code)
{
ret_code ret = RET_OK;
struct ifreq ifr = {0};
struct in6_ifreq ifr6 = {0};
strncpy(ifr.ifr_name, ip_conf->ifname, sizeof(ifr.ifr_name) - 1);
ret = if_ioctl(AF_INET, SIOGIFINDEX, (caddr_t)&ifr, code);
ASSERT_RET(ret);
ifr6.ifr6_ifindex = ifr.ifr_ifindex;
ifr6.ifr6_prefixlen = ip_conf->prefixlen;
memcpy((char *) &ifr6.ifr6_addr, &(ip_conf->prefix6), sizeof(struct in6_addr));
if(config_type == CM_CONFIG_SET)
{
ret = if_ioctl(AF_INET6, SIOCSIFADDR, (caddr_t)&ifr6, code);
}
else if(config_type == CM_CONFIG_DEL)
{
ret = if_ioctl(AF_INET6, SIOCDIFADDR, (caddr_t)&ifr6, code);
}
ASSERT_RET(ret);
return RET_OK;
}
ret_code if_get_prefix(if_info_t *if_conf, int *code)
{
struct sockaddr_in *addr;
struct ifreq ifreq;
ret_code ret = RET_OK;
int mask_ret;
memset(&ifreq, 0, sizeof(struct ifreq));
rpc_log_info("get interface %s info\n", if_conf->ifname);
strncpy(ifreq.ifr_name, if_conf->ifname, sizeof(ifreq.ifr_name) - 1);
ret = if_ioctl(AF_INET, SIOCGIFADDR, (caddr_t)&ifreq, code);
ASSERT_RET(ret);
strcpy(if_conf->ipv4.addr, inet_ntoa(((struct sockaddr_in *)&(ifreq.ifr_addr))->sin_addr));
memset(&ifreq, 0, sizeof(ifreq));
strncpy(ifreq.ifr_name, if_conf->ifname, sizeof(ifreq.ifr_name) - 1);
ret = if_ioctl(AF_INET, SIOCGIFNETMASK, (caddr_t)&ifreq, &mask_ret);
ASSERT_RET_NO(ret);
addr = ( struct sockaddr_in * )&(ifreq.ifr_netmask);
if_conf->ipv4.prefixlen = ip_masklen(addr->sin_addr);
return ret;
}
int if_get_prefix6(if_info_t *if_conf)
{
FILE *f;
char addr6[40], devname[20];
struct in6_addr in6_addr;
int plen, scope, dad_status, if_idx;
char addr6p[8][5];
int addr_cnt = 0;
f = fopen(PROC_NET_IFINET6, "r");
ASSERT_PTR(f, 0);
while (fscanf(f, "%4s%4s%4s%4s%4s%4s%4s%4s %02x %02x %02x %02x %20s\n",
addr6p[0], addr6p[1], addr6p[2], addr6p[3],
addr6p[4], addr6p[5], addr6p[6], addr6p[7],
&if_idx, &plen, &scope, &dad_status, devname) != EOF)
{
if (0 != strcmp(devname, if_conf->ifname))
{
continue;
}
sprintf(addr6, "%s:%s:%s:%s:%s:%s:%s:%s",
addr6p[0], addr6p[1], addr6p[2], addr6p[3],
addr6p[4], addr6p[5], addr6p[6], addr6p[7]);
inet_pton(AF_INET6, addr6, in6_addr.s6_addr);
inet_ntop(AF_INET6, &in6_addr,
if_conf->ipv6[addr_cnt].addr, DOT_IPV6_STR);
if_conf->ipv6[addr_cnt].prefixlen = plen;
switch (scope) {
case 0:
strncpy(if_conf->ipv6[addr_cnt].scope ,"Global", DOT_IP_STR - 1);
break;
case IPV6_ADDR_LINKLOCAL:
strncpy(if_conf->ipv6[addr_cnt].scope ,"Link", DOT_IP_STR - 1);
break;
case IPV6_ADDR_SITELOCAL:
strncpy(if_conf->ipv6[addr_cnt].scope ,"Site", DOT_IP_STR - 1);
break;
case IPV6_ADDR_COMPATv4:
strncpy(if_conf->ipv6[addr_cnt].scope ,"Compat", DOT_IP_STR - 1);
break;
case IPV6_ADDR_LOOPBACK:
strncpy(if_conf->ipv6[addr_cnt].scope ,"Host", DOT_IP_STR - 1);
break;
default:
strncpy(if_conf->ipv6[addr_cnt].scope ,"Unknown", DOT_IP_STR - 1);
}
addr_cnt++;
if(addr_cnt >= IPV6_ADDR_NUM)
{
break;
}
}
fclose(f);
return addr_cnt;
}
int if_lan_num()
{
return g_if_num.lan_num;
}
int if_wan_num()
{
return g_if_num.wan_num;
}
ret_code if_num_init()
{
char role_str[IF_BUFF_LEN] = {0};
struct ifreq ifreq[MAX_IF_NUM];
int if_count = 0;
int lan_count = 0;
int wan_count = 0;
int i;
/*char ifname[MAX_IF_NUM][INTERFACE_NAMSIZ];*/
memset(&ifreq, 0, MAX_IF_NUM * sizeof(struct ifreq));
if_count = if_read_dev_file(ifreq, MAX_IF_NUM);
for(i = 0; i < if_count; i++)
{
memset(role_str, 0, IF_BUFF_LEN);
if(if_role_file_get(ifreq[i].ifr_name, role_str, IF_BUFF_LEN) != RET_OK)
{
continue;
}
if(strcasecmp(role_str, "lan"))
{
lan_count++;
}
else if(strcasecmp(role_str, "wan"))
{
wan_count++;
}
}
if(lan_count != 0)
{
g_if_num.lan_num = lan_count;
}
if(wan_count != 0)
{
g_if_num.wan_num = wan_count;
}
/*memset(ifname, 0, sizeof(ifname));
wan_count = if_wan_get(ifname, MAX_IF_NUM);
printf("wan get cnt %d\n", wan_count);
for(i = 0; i < wan_count; i++)
{
printf("interface %s\n", ifname[i]);
}*/
return RET_OK;
}
int if_wan_get(char ifname[MAX_IF_NUM][INTERFACE_NAMSIZ], int max_port)
{
char role_str[IF_BUFF_LEN] = {0};
struct ifreq ifreq[MAX_IF_NUM];
int if_count = 0;
int wan_count = 0;
int i;
memset(&ifreq, 0, MAX_IF_NUM * sizeof(struct ifreq));
if_count = if_read_dev_file(ifreq, MAX_IF_NUM);
for(i = 0; i < if_count; i++)
{
memset(role_str, 0, IF_BUFF_LEN);
if(if_role_file_get(ifreq[i].ifr_name, role_str, IF_BUFF_LEN) != RET_OK)
{
continue;
}
if(wan_count >= max_port)
{
break;
}
if(strcasecmp(role_str, "wan"))
{
strncpy(ifname[wan_count], ifreq[i].ifr_name, INTERFACE_NAMSIZ - 1);
wan_count++;
}
}
return wan_count;
}
int if_lan_get(char ifname[MAX_IF_NUM][INTERFACE_NAMSIZ], int max_port)
{
char role_str[IF_BUFF_LEN] = {0};
struct ifreq ifreq[MAX_IF_NUM];
int if_count = 0;
int lan_count = 0;
int i;
memset(&ifreq, 0, MAX_IF_NUM * sizeof(struct ifreq));
if_count = if_read_dev_file(ifreq, MAX_IF_NUM);
for(i = 0; i < if_count; i++)
{
memset(role_str, 0, IF_BUFF_LEN);
if(if_role_file_get(ifreq[i].ifr_name, role_str, IF_BUFF_LEN) != RET_OK)
{
continue;
}
if(lan_count >= max_port)
{
break;
}
if(strcasecmp(role_str, "lan"))
{
strncpy(ifname[lan_count], ifreq[i].ifr_name, INTERFACE_NAMSIZ - 1);
lan_count++;
}
}
return lan_count;
}