/*----------------------------------------------------------------------
| NPT_NetworkInterface::GetNetworkInterfaces
+---------------------------------------------------------------------*/
NPT_Result
NPT_NetworkInterface::GetNetworkInterfaces(NPT_List<NPT_NetworkInterface*>& interfaces)
{
union SceNetApctlInfo info;
int ret = sceNetApctlGetInfo(SCE_NET_APCTL_INFO_IP_ADDRESS, &info);
if (ret < 0) {
return NPT_FAILURE;
}
NPT_IpAddress primary_address;
if (NPT_FAILED(primary_address.Parse(info.ip_address))) {
return NPT_FAILURE;
}
NPT_IpAddress netmask;
if (NPT_FAILED(netmask.Parse(info.netmask))) {
return NPT_FAILURE;
}
NPT_IpAddress broadcast_address;
NPT_Flags flags = 0;
flags |= NPT_NETWORK_INTERFACE_FLAG_BROADCAST;
flags |= NPT_NETWORK_INTERFACE_FLAG_MULTICAST;
// get mac address
SceNetEtherAddr mac_info;
ret = sceNetGetLocalEtherAddr(&mac_info);
if (ret < 0) {
return NPT_FAILURE;
}
NPT_MacAddress mac(TYPE_IEEE_802_11, mac_info.data, SCE_NET_ETHER_ADDR_LEN);
// create an interface object
char iface_name[5];
iface_name[0] = 'i';
iface_name[1] = 'f';
iface_name[2] = '0';
iface_name[3] = '0';
iface_name[4] = '\0';
NPT_NetworkInterface* iface = new NPT_NetworkInterface(iface_name, mac, flags);
// set the interface address
NPT_NetworkInterfaceAddress iface_address(
primary_address,
broadcast_address,
NPT_IpAddress::Any,
netmask);
iface->AddAddress(iface_address);
// add the interface to the list
interfaces.Add(iface);
return NPT_SUCCESS;
}
lisp_addr_t *
vpnapi_control_dp_get_default_addr(oor_ctrl_t *ctrl, int afi)
{
iface_t *iface;
lisp_addr_t *addr = NULL;
iface = get_any_output_iface(afi);
if (iface != NULL){
addr = iface_address(iface, afi);
}
return (addr);
}
/*----------------------------------------------------------------------
| NPT_NetworkInterface::GetNetworkInterfaces
+---------------------------------------------------------------------*/
NPT_Result
NPT_NetworkInterface::GetNetworkInterfaces(NPT_List<NPT_NetworkInterface*>& interfaces)
{
int net = socket(AF_INET, SOCK_DGRAM, 0);
// Try to get the config until we have enough memory for it
// According to "Unix Network Programming", some implementations
// do not return an error when the supplied buffer is too small
// so we need to try, increasing the buffer size every time,
// until we get the same size twice. We cannot assume success when
// the returned size is smaller than the supplied buffer, because
// some implementations can return less that the buffer size if
// another structure does not fit.
unsigned int buffer_size = 4096; // initial guess
unsigned int last_size = 0;
struct ifconf config;
unsigned char* buffer;
for (; buffer_size < 65536;) {
buffer = new unsigned char[buffer_size];
config.ifc_len = buffer_size;
config.ifc_buf = (char*)buffer;
if (ioctl(net, SIOCGIFCONF, &config) < 0) {
if (errno != EINVAL || last_size != 0) {
return NPT_ERROR_BASE_UNIX-errno;
}
} else {
if ((unsigned int)config.ifc_len == last_size) {
// same size, we can use the buffer
break;
}
// different size, we need to reallocate
last_size = config.ifc_len;
}
// supply 4096 more bytes more next time around
buffer_size += 4096;
delete[] buffer;
}
// iterate over all objects
unsigned char *entries;
for (entries = buffer; entries < buffer+config.ifc_len;) {
struct ifreq* entry = (struct ifreq*)entries;
// get the size of the addresses
unsigned int address_length;
#if defined(NPT_CONFIG_HAVE_SOCKADDR_SA_LEN)
address_length = sizeof(struct sockaddr) > entry->ifr_addr.sa_len ?
sizeof(sockaddr) : entry->ifr_addr.sa_len;
#else
switch (entry->ifr_addr.sa_family) {
#if defined(AF_INET6)
case AF_INET6:
address_length = sizeof(struct sockaddr_in6);
break;
#endif // defined(AF_INET6)
default:
address_length = sizeof(struct sockaddr);
break;
}
#endif
// point to the next entry
entries += address_length + sizeof(entry->ifr_name);
// ignore anything except AF_INET and AF_LINK addresses
if (entry->ifr_addr.sa_family != AF_INET
#if defined(AF_LINK)
&& entry->ifr_addr.sa_family != AF_LINK
#endif
) {
continue;
}
// get detailed info about the interface
NPT_Flags flags = 0;
#if defined(SIOCGIFFLAGS)
struct ifreq query = *entry;
if (ioctl(net, SIOCGIFFLAGS, &query) < 0) continue;
// process the flags
if ((query.ifr_flags & IFF_UP) == 0) {
// the interface is not up, ignore it
continue;
}
if (query.ifr_flags & IFF_BROADCAST) {
flags |= NPT_NETWORK_INTERFACE_FLAG_BROADCAST;
}
if (query.ifr_flags & IFF_LOOPBACK) {
flags |= NPT_NETWORK_INTERFACE_FLAG_LOOPBACK;
}
#if defined(IFF_POINTOPOINT)
if (query.ifr_flags & IFF_POINTOPOINT) {
flags |= NPT_NETWORK_INTERFACE_FLAG_POINT_TO_POINT;
}
#endif // defined(IFF_POINTOPOINT)
if (query.ifr_flags & IFF_PROMISC) {
flags |= NPT_NETWORK_INTERFACE_FLAG_PROMISCUOUS;
}
if (query.ifr_flags & IFF_MULTICAST) {
flags |= NPT_NETWORK_INTERFACE_FLAG_MULTICAST;
}
#endif // defined(SIOCGIFFLAGS)
// get a pointer to an interface we've looped over before
// or create a new one
NPT_NetworkInterface* interface = NULL;
for (NPT_List<NPT_NetworkInterface*>::Iterator iface_iter = interfaces.GetFirstItem();
iface_iter;
++iface_iter) {
if ((*iface_iter)->GetName() == (const char*)entry->ifr_name) {
interface = *iface_iter;
break;
}
}
if (interface == NULL) {
// create a new interface object
interface = new NPT_NetworkInterface(entry->ifr_name, flags);
// add the interface to the list
interfaces.Add(interface);
// get the mac address
#if defined(SIOCGIFHWADDR)
if (ioctl(net, SIOCGIFHWADDR, &query) == 0) {
NPT_MacAddress::Type mac_addr_type;
unsigned int mac_addr_length = IFHWADDRLEN;
switch (query.ifr_addr.sa_family) {
#if defined(ARPHRD_ETHER)
case ARPHRD_ETHER:
mac_addr_type = NPT_MacAddress::TYPE_ETHERNET;
break;
#endif
#if defined(ARPHRD_LOOPBACK)
case ARPHRD_LOOPBACK:
mac_addr_type = NPT_MacAddress::TYPE_LOOPBACK;
length = 0;
break;
#endif
#if defined(ARPHRD_PPP)
case ARPHRD_PPP:
mac_addr_type = NPT_MacAddress::TYPE_PPP;
mac_addr_length = 0;
break;
#endif
#if defined(ARPHRD_IEEE80211)
case ARPHRD_IEEE80211:
mac_addr_type = NPT_MacAddress::TYPE_IEEE_802_11;
break;
#endif
default:
mac_addr_type = NPT_MacAddress::TYPE_UNKNOWN;
mac_addr_length = sizeof(query.ifr_addr.sa_data);
break;
}
interface->SetMacAddress(mac_addr_type, (const unsigned char*)query.ifr_addr.sa_data, mac_addr_length);
}
#endif
}
switch (entry->ifr_addr.sa_family) {
case AF_INET: {
// primary address
NPT_IpAddress primary_address(ntohl(((struct sockaddr_in*)&entry->ifr_addr)->sin_addr.s_addr));
// broadcast address
NPT_IpAddress broadcast_address;
#if defined(SIOCGIFBRDADDR)
if (flags & NPT_NETWORK_INTERFACE_FLAG_BROADCAST) {
if (ioctl(net, SIOCGIFBRDADDR, &query) == 0) {
broadcast_address.Set(ntohl(((struct sockaddr_in*)&query.ifr_addr)->sin_addr.s_addr));
}
}
#endif
// point to point address
NPT_IpAddress destination_address;
#if defined(SIOCGIFDSTADDR)
if (flags & NPT_NETWORK_INTERFACE_FLAG_POINT_TO_POINT) {
if (ioctl(net, SIOCGIFDSTADDR, &query) == 0) {
destination_address.Set(ntohl(((struct sockaddr_in*)&query.ifr_addr)->sin_addr.s_addr));
}
}
#endif
// netmask
NPT_IpAddress netmask(0xFFFFFFFF);
#if defined(SIOCGIFNETMASK)
if (ioctl(net, SIOCGIFNETMASK, &query) == 0) {
netmask.Set(ntohl(((struct sockaddr_in*)&query.ifr_addr)->sin_addr.s_addr));
}
#endif
// add the address to the interface
NPT_NetworkInterfaceAddress iface_address(
primary_address,
broadcast_address,
destination_address,
netmask);
interface->AddAddress(iface_address);
break;
}
#if defined(AF_LINK) && defined(NPT_CONFIG_HAVE_SOCKADDR_DL)
case AF_LINK: {
struct sockaddr_dl* mac_addr = (struct sockaddr_dl*)&entry->ifr_addr;
NPT_MacAddress::Type mac_addr_type = NPT_MacAddress::TYPE_UNKNOWN;
switch (mac_addr->sdl_type) {
#if defined(IFT_LOOP)
case IFT_LOOP:
mac_addr_type = NPT_MacAddress::TYPE_LOOPBACK;
break;
#endif
#if defined(IFT_ETHER)
case IFT_ETHER:
mac_addr_type = NPT_MacAddress::TYPE_ETHERNET;
break;
#endif
#if defined(IFT_PPP)
case IFT_PPP:
mac_addr_type = NPT_MacAddress::TYPE_PPP;
break;
#endif
}
interface->SetMacAddress(mac_addr_type,
(const unsigned char*)(&mac_addr->sdl_data[mac_addr->sdl_nlen]),
mac_addr->sdl_alen);
break;
}
#endif
}
}
// free resources
delete[] buffer;
close(net);
return NPT_SUCCESS;
}
int
configure_ms(cfg_t *cfg)
{
char *iface_name;
iface_t *iface;
lisp_site_prefix_t *site;
shash_t *lcaf_ht;
int i;
lisp_ms_t *ms;
mapping_t *mapping;
/* create and configure xtr */
if (ctrl_dev_create(MS_MODE, &ctrl_dev) != GOOD) {
OOR_LOG(LCRIT, "Failed to create MS. Aborting!");
exit_cleanup();
}
ms = CONTAINER_OF(ctrl_dev, lisp_ms_t, super);
/* create lcaf hash table */
lcaf_ht = parse_lcafs(cfg);
/* CONTROL INTERFACE */
/* TODO: should work with all interfaces in the future */
iface_name = cfg_getstr(cfg, "control-iface");
if (iface_name) {
iface = add_interface(iface_name);
if (iface == NULL) {
return(BAD);
}
}
if (iface_address(iface, AF_INET) == NULL){
iface_setup_addr(iface, AF_INET);
data_plane->datap_add_iface_addr(iface,AF_INET);
lctrl->control_data_plane->control_dp_add_iface_addr(lctrl,iface,AF_INET);
}
if (iface_address(iface, AF_INET6) == NULL){
iface_setup_addr(iface, AF_INET6);
data_plane->datap_add_iface_addr(iface,AF_INET6);
lctrl->control_data_plane->control_dp_add_iface_addr(lctrl,iface,AF_INET6);
}
/* LISP-SITE CONFIG */
for (i = 0; i < cfg_size(cfg, "lisp-site"); i++) {
cfg_t *ls = cfg_getnsec(cfg, "lisp-site", i);
site = build_lisp_site_prefix(ms,
cfg_getstr(ls, "eid-prefix"),
cfg_getint(ls, "iid"),
cfg_getint(ls, "key-type"),
cfg_getstr(ls, "key"),
cfg_getbool(ls, "accept-more-specifics") ? 1:0,
cfg_getbool(ls, "proxy-reply") ? 1:0,
cfg_getbool(ls, "merge") ? 1 : 0,
lcaf_ht);
if (site != NULL) {
if (mdb_lookup_entry(ms->lisp_sites_db, site->eid_prefix) != NULL){
OOR_LOG(LDBG_1, "Configuration file: Duplicated lisp-site: %s . Discarding...",
lisp_addr_to_char(site->eid_prefix));
lisp_site_prefix_del(site);
continue;
}
OOR_LOG(LDBG_1, "Adding lisp site prefix %s to the lisp-sites "
"database", lisp_addr_to_char(site->eid_prefix));
ms_add_lisp_site_prefix(ms, site);
}else{
OOR_LOG(LERR, "Can't add lisp-site prefix %s. Discarded ...",
cfg_getstr(ls, "eid-prefix"));
}
}
/* LISP REGISTERED SITES CONFIG */
for (i = 0; i< cfg_size(cfg, "ms-static-registered-site"); i++ ) {
cfg_t *mss = cfg_getnsec(cfg, "ms-static-registered-site", i);
mapping = parse_mapping(mss,&(ms->super),lcaf_ht,FALSE);
if (mapping == NULL){
OOR_LOG(LERR, "Can't create static register site for %s",
cfg_getstr(mss, "eid-prefix"));
continue;
}
/* If the mapping doesn't exist, add it the the database */
if (mdb_lookup_entry_exact(ms->reg_sites_db, mapping_eid(mapping)) == NULL){
if (ms_add_registered_site_prefix(ms, mapping) == GOOD){
OOR_LOG(LDBG_1, "Added static registered site for %s to the registered sites list!",
lisp_addr_to_char(mapping_eid(mapping)));
}else{
OOR_LOG(LERR, "Failed to add static registered site for %s to the registered sites list!",
lisp_addr_to_char(mapping_eid(mapping)));
mapping_del(mapping);
}
}else{
OOR_LOG(LERR, "Configuration file: Duplicated static registered site for %s. Discarded ...",
cfg_getstr(mss, "eid-prefix"));
mapping_del(mapping);
continue;
}
}
/* destroy the hash table */
shash_destroy(lcaf_ht);
return(GOOD);
}
/*----------------------------------------------------------------------
| NPT_NetworkInterface::GetNetworkInterfaces
+---------------------------------------------------------------------*/
NPT_Result
NPT_NetworkInterface::GetNetworkInterfaces(NPT_List<NPT_NetworkInterface*>& interfaces)
{
int result = 0;
struct ifaddrs * ifaddrsList = NULL;
struct ifaddrs * ifaddr = NULL;
NPT_Flags flags = 0;
result = getifaddrs(&ifaddrsList);
if( result != 0 || ifaddrsList == NULL)
return NPT_FAILURE;
for(ifaddr = ifaddrsList; NULL!= ifaddr; ifaddr = ifaddr->ifa_next) {
if(ifaddr->ifa_addr == NULL /*|| ifaddr->ifa_addr->sa_family == AF_INET6*/)
continue;
// process the flags
if ((ifaddr->ifa_flags & IFF_UP) == 0) {
// the interface is not up, ignore it
continue;
}
if (ifaddr->ifa_flags & IFF_BROADCAST) {
flags |= NPT_NETWORK_INTERFACE_FLAG_BROADCAST;
}
if (ifaddr->ifa_flags & IFF_LOOPBACK) {
flags |= NPT_NETWORK_INTERFACE_FLAG_LOOPBACK;
}
#if defined(IFF_POINTOPOINT)
if (ifaddr->ifa_flags & IFF_POINTOPOINT) {
flags |= NPT_NETWORK_INTERFACE_FLAG_POINT_TO_POINT;
}
#endif // defined(IFF_POINTOPOINT)
if (ifaddr->ifa_flags & IFF_PROMISC) {
flags |= NPT_NETWORK_INTERFACE_FLAG_PROMISCUOUS;
}
if (ifaddr->ifa_flags & IFF_MULTICAST) {
flags |= NPT_NETWORK_INTERFACE_FLAG_MULTICAST;
}
NPT_NetworkInterface* interface = NULL;
for (NPT_List<NPT_NetworkInterface*>::Iterator iface_iter = interfaces.GetFirstItem();
iface_iter;
++iface_iter) {
if ((*iface_iter)->GetName() == (const char*)ifaddr->ifa_name) {
interface = *iface_iter;
break;
}
}
// create a new interface object
if(interface == NULL)
interface = new NPT_NetworkInterface(ifaddr->ifa_name, flags);
if (interface == NULL)
continue;
// get the mac address
NPT_MacAddress::Type mac_addr_type;
unsigned int mac_addr_length = IFHWADDRLEN;
switch (ifaddr->ifa_addr->sa_family) {
case AF_LOCAL:
case AF_INET:
#if defined(AF_LINK)
case AF_LINK:
#endif
mac_addr_type = NPT_MacAddress::TYPE_ETHERNET;
#if defined(ARPHRD_LOOPBACK)
mac_addr_type = NPT_MacAddress::TYPE_LOOPBACK;
length = 0;
#endif
break;
#if defined(AF_PPP)
case AF_PPP:
mac_addr_type = NPT_MacAddress::TYPE_PPP;
mac_addr_length = 0;
break;
#endif
#if defined(AF_IEEE80211)
case AF_IEEE80211:
mac_addr_type = NPT_MacAddress::TYPE_IEEE_802_11;
break;
#endif
default:
mac_addr_type = NPT_MacAddress::TYPE_UNKNOWN;
mac_addr_length = sizeof(ifaddr->ifa_addr->sa_data);
break;
}
if(interface->GetMacAddress().GetLength() == 0)
interface->SetMacAddress(mac_addr_type, (const unsigned char*)ifaddr->ifa_addr->sa_data, mac_addr_length);
#if defined(NPT_CONFIG_HAVE_NET_IF_DL_H)
if (ifaddr->ifa_addr->sa_family == AF_LINK) {
//Refer to LLADDR
struct sockaddr_dl * socket_dl = (struct sockaddr_dl *)ifaddr->ifa_addr;
interface->SetMacAddress(mac_addr_type, (const unsigned char*)socket_dl->sdl_data+socket_dl->sdl_nlen, socket_dl->sdl_alen);
}
#endif
switch (ifaddr->ifa_addr->sa_family) {
case AF_INET: {
// primary address
NPT_IpAddress primary_address( ntohl(((struct sockaddr_in *)ifaddr->ifa_addr)->sin_addr.s_addr));
// broadcast address
NPT_IpAddress broadcast_address;
if ((flags & NPT_NETWORK_INTERFACE_FLAG_BROADCAST) && ifaddr->ifa_dstaddr) {
broadcast_address.Set(ntohl(((struct sockaddr_in*)ifaddr->ifa_dstaddr)->sin_addr.s_addr));
}
// point to point address
NPT_IpAddress destination_address;
if ((flags & NPT_NETWORK_INTERFACE_FLAG_POINT_TO_POINT) && ifaddr->ifa_dstaddr) {
destination_address.Set(ntohl(((struct sockaddr_in*)ifaddr->ifa_dstaddr)->sin_addr.s_addr));
}
// netmask
NPT_IpAddress netmask(0xFFFFFFFF);
if(ifaddr->ifa_netmask)
netmask.Set(ntohl(((struct sockaddr_in*)ifaddr->ifa_netmask)->sin_addr.s_addr));
// add the address to the interface
NPT_NetworkInterfaceAddress iface_address(primary_address,
broadcast_address,
destination_address,
netmask);
interface->AddAddress(iface_address);
break;
}
}
// add the interface to the list
interfaces.Add(interface);
}
freeifaddrs(ifaddrsList);
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| NPT_NetworkInterface::GetNetworkInterfaces
+---------------------------------------------------------------------*/
NPT_Result
NPT_NetworkInterface::GetNetworkInterfaces(NPT_List<NPT_NetworkInterface*>& interfaces)
{
IP_ADAPTER_ADDRESSES* iface_list = NULL;
ULONG size = sizeof(IP_ADAPTER_INFO);
// get the interface table
for(;;) {
iface_list = (IP_ADAPTER_ADDRESSES*)malloc(size);
DWORD result = GetAdaptersAddresses(AF_INET,
0,
NULL,
iface_list, &size);
if (result == NO_ERROR) {
break;
} else {
// free and try again
free(iface_list);
if (result != ERROR_BUFFER_OVERFLOW) {
return NPT_FAILURE;
}
}
}
// iterate over the interfaces
for (IP_ADAPTER_ADDRESSES* iface = iface_list; iface; iface = iface->Next) {
// skip this interface if it is not up
if (iface->OperStatus != IfOperStatusUp) continue;
// get the interface type and mac address
NPT_MacAddress::Type mac_type;
switch (iface->IfType) {
case IF_TYPE_ETHERNET_CSMACD: mac_type = NPT_MacAddress::TYPE_ETHERNET; break;
case IF_TYPE_SOFTWARE_LOOPBACK: mac_type = NPT_MacAddress::TYPE_LOOPBACK; break;
case IF_TYPE_PPP: mac_type = NPT_MacAddress::TYPE_PPP; break;
default: mac_type = NPT_MacAddress::TYPE_UNKNOWN; break;
}
NPT_MacAddress mac(mac_type, iface->PhysicalAddress, iface->PhysicalAddressLength);
// compute interface flags
NPT_Flags flags = 0;
if (!(iface->Flags & IP_ADAPTER_NO_MULTICAST)) flags |= NPT_NETWORK_INTERFACE_FLAG_MULTICAST;
if (iface->IfType == IF_TYPE_SOFTWARE_LOOPBACK) flags |= NPT_NETWORK_INTERFACE_FLAG_LOOPBACK;
if (iface->IfType == IF_TYPE_PPP) flags |= NPT_NETWORK_INTERFACE_FLAG_POINT_TO_POINT;
// compute the unicast address (only the first one is supported for now)
NPT_IpAddress primary_address;
if (iface->FirstUnicastAddress) {
if (iface->FirstUnicastAddress->Address.lpSockaddr == NULL) continue;
if (iface->FirstUnicastAddress->Address.iSockaddrLength != sizeof(SOCKADDR_IN)) continue;
SOCKADDR_IN* address = (SOCKADDR_IN*)iface->FirstUnicastAddress->Address.lpSockaddr;
if (address->sin_family != AF_INET) continue;
primary_address.Set(ntohl(address->sin_addr.s_addr));
}
NPT_IpAddress broadcast_address; // not supported yet
NPT_IpAddress netmask; // not supported yet
// convert the interface name to UTF-8
// BUG in Wine: FriendlyName is NULL
unsigned int iface_name_length = (unsigned int)iface->FriendlyName?wcslen(iface->FriendlyName):0;
char* iface_name = new char[4*iface_name_length+1];
int result = WideCharToMultiByte(
CP_UTF8, 0, iface->FriendlyName, iface_name_length,
iface_name, 4*iface_name_length+1,
NULL, NULL);
if (result > 0) {
iface_name[result] = '\0';
} else {
iface_name[0] = '\0';
}
// create an interface descriptor
NPT_NetworkInterface* iface_object = new NPT_NetworkInterface(iface_name, mac, flags);
NPT_NetworkInterfaceAddress iface_address(
primary_address,
broadcast_address,
NPT_IpAddress::Any,
netmask);
iface_object->AddAddress(iface_address);
// cleanup
delete[] iface_name;
// add the interface to the list
interfaces.Add(iface_object);
}
free(iface_list);
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| NPT_NetworkInterface::GetNetworkInterfaces
+---------------------------------------------------------------------*/
NPT_Result
NPT_NetworkInterface::GetNetworkInterfaces(NPT_List<NPT_NetworkInterface*>& interfaces)
{
// create a socket to talk to the TCP/IP stack
SOCKET net;
if((net = WSASocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0)) == INVALID_SOCKET) {
return NPT_FAILURE;
}
// get a list of interfaces
INTERFACE_INFO query[32]; // get up to 32 interfaces
DWORD bytes_returned;
int io_result = WSAIoctl(net,
SIO_GET_INTERFACE_LIST,
NULL, 0,
&query, sizeof(query),
&bytes_returned,
NULL, NULL);
if (io_result == SOCKET_ERROR) {
closesocket(net);
return NPT_FAILURE;
}
// we don't need the socket anymore
closesocket(net);
// Display interface information
int interface_count = (bytes_returned/sizeof(INTERFACE_INFO));
unsigned int iface_index = 0;
for (int i=0; i<interface_count; i++) {
SOCKADDR_IN* address;
NPT_Flags flags = 0;
// primary address
address = (SOCKADDR_IN*)&query[i].iiAddress;
NPT_IpAddress primary_address(ntohl(address->sin_addr.s_addr));
// netmask
address = (SOCKADDR_IN*)&query[i].iiNetmask;
NPT_IpAddress netmask(ntohl(address->sin_addr.s_addr));
// broadcast address
address = (SOCKADDR_IN*)&query[i].iiBroadcastAddress;
NPT_IpAddress broadcast_address(ntohl(address->sin_addr.s_addr));
{
// broadcast address is incorrect
unsigned char addr[4];
for(int i=0; i<4; i++) {
addr[i] = (primary_address.AsBytes()[i] & netmask.AsBytes()[i]) |
~netmask.AsBytes()[i];
}
broadcast_address.Set(addr);
}
// ignore interfaces that are not up
if (!(query[i].iiFlags & IFF_UP)) {
continue;
}
if (query[i].iiFlags & IFF_BROADCAST) {
flags |= NPT_NETWORK_INTERFACE_FLAG_BROADCAST;
}
if (query[i].iiFlags & IFF_MULTICAST) {
flags |= NPT_NETWORK_INTERFACE_FLAG_MULTICAST;
}
if (query[i].iiFlags & IFF_LOOPBACK) {
flags |= NPT_NETWORK_INTERFACE_FLAG_LOOPBACK;
}
if (query[i].iiFlags & IFF_POINTTOPOINT) {
flags |= NPT_NETWORK_INTERFACE_FLAG_POINT_TO_POINT;
}
// mac address (no support for this for now)
NPT_MacAddress mac;
// create an interface object
char iface_name[5];
iface_name[0] = 'i';
iface_name[1] = 'f';
iface_name[2] = '0'+(iface_index/10);
iface_name[3] = '0'+(iface_index%10);
iface_name[4] = '\0';
NPT_NetworkInterface* iface = new NPT_NetworkInterface(iface_name, mac, flags);
// set the interface address
NPT_NetworkInterfaceAddress iface_address(
primary_address,
broadcast_address,
NPT_IpAddress::Any,
netmask);
iface->AddAddress(iface_address);
// add the interface to the list
interfaces.Add(iface);
// increment the index (used for generating the name
iface_index++;
}
return NPT_SUCCESS;
}