Adapter.cpp

#if !defined( EMSCRIPTEN )
 
#include "Adapter.h"
 
#include "../Logging/Logger.h"
#include "../Platform/Unicode.h"
 
#ifdef _WIN32
#include <winsock2.h>
#include <iphlpapi.h>
#pragma comment(lib, "IPHLPAPI.lib")
#else
#include <arpa/inet.h>
#include <ifaddrs.h>
#include <net/if.h>
#endif
 
#include <cassert>
#include <vector>
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Connection");
}
 
namespace Cogs::Network{
 
static std::vector<NetworkAdapter> adapters;
 
void UpdateAdapters(AdapterFlags adapter_flags)
{
  adapters.clear();
  if(adapter_flags & AdapterFlags::IncludeAny)
    adapters.push_back({"Any", AddrIn(0, 0, 0, 0), AddrIn(255, 255, 255, 255), AddrIn(0, 0, 0, 0)});
  if(adapter_flags & AdapterFlags::IncludeLocalhost)
    adapters.push_back({"Localhost", AddrIn(127, 0, 0, 1), AddrIn(255, 0, 0, 0), AddrIn(127, 255, 255, 255)});
#ifdef _WIN32
  ULONG             family = AF_INET; // TODO AF_UNSPEC
  ULONG             flags = 0;
  ULONG             bufferSize = 16384;
  std::vector<char> buffer(bufferSize);
  ULONG             ret = GetAdaptersAddresses(family, flags, nullptr, reinterpret_cast<IP_ADAPTER_ADDRESSES*>(buffer.data()), &bufferSize);
 
  if (ret == ERROR_BUFFER_OVERFLOW) {
    buffer.resize(bufferSize);
    ret = GetAdaptersAddresses(family, flags, nullptr, reinterpret_cast<IP_ADAPTER_ADDRESSES*>(buffer.data()), &bufferSize);
  }
  if (ret == ERROR_SUCCESS) {
    IP_ADAPTER_ADDRESSES* ptr = reinterpret_cast<IP_ADAPTER_ADDRESSES*>(buffer.data());
 
    while(ptr){
      if((ptr->IfType != IF_TYPE_ETHERNET_CSMACD) && // Ethernet
         (ptr->IfType != IF_TYPE_IEEE80211)){ // Wireless
        ptr = ptr->Next;
        continue;
      }
 
      adapters.push_back({});
      NetworkAdapter &adapter = adapters.back();
      adapter.name = narrow(ptr->FriendlyName); // narrow(ptr->AdapterName);
 
      PIP_ADAPTER_UNICAST_ADDRESS pUnicast = ptr->FirstUnicastAddress;
      if(pUnicast){
        sockaddr_in *addr = reinterpret_cast<sockaddr_in*>(pUnicast->Address.lpSockaddr);
        assert(addr->sin_family == AF_INET);
        adapter.addr = AddrIn(addr->sin_addr);
 
        ULONG mask;
        ConvertLengthToIpv4Mask(pUnicast->OnLinkPrefixLength, &mask);
        adapter.mask.addr.s_addr = mask;
        adapter.broadcast.addr.s_addr = addr->sin_addr.s_addr | ~mask;
      }
 
      ptr = ptr->Next;
    }
  }
  else{
    LOG_DEBUG(logger, "UpdateAdapters(): GetAdaptersAddresses failed with %08x error code.", ret);
    assert(false); // TODO
  }
#else
  struct ifaddrs *ifa = nullptr;
  int ret = getifaddrs(&ifa);
  if(ret == -1){
    // TODO errno
    return;
  }
 
  struct ifaddrs *next = ifa;
  for(; next; next = next->ifa_next){
    if(next->ifa_addr && next->ifa_addr->sa_family == AF_INET){
      sockaddr_in *addr = reinterpret_cast<sockaddr_in*>(next->ifa_addr);
      sockaddr_in *mask = reinterpret_cast<sockaddr_in*>(next->ifa_netmask);
#if defined( __APPLE__ )
      sockaddr_in *broadcast = reinterpret_cast<sockaddr_in*>(next->ifa_dstaddr);
#else
      sockaddr_in *broadcast = reinterpret_cast<sockaddr_in*>(next->ifa_ifu.ifu_broadaddr);
#endif
 
      adapters.push_back({});
      NetworkAdapter &adapter = adapters.back();
      adapter.name = next->ifa_name;
      adapter.addr = AddrIn(addr->sin_addr);
      adapter.mask = AddrIn(mask->sin_addr);
      adapter.broadcast = AddrIn(broadcast->sin_addr);
    }
  }
 
  freeifaddrs(ifa);
#endif
}
void PrintAdapters()
{
  LOG_INFO(logger, "Adapters(%zu):", adapters.size());
  for(auto &adapter : adapters){
    LOG_INFO(logger, "%s: ip %s (mask %s) (broadcast %s)",
             adapter.name.c_str(),
             adapter.addr.string().c_str(),
             adapter.mask.string().c_str(),
             adapter.broadcast.string().c_str());
  }
}
NetworkAdapter GetAdapter(size_t i)
{
  return adapters[i];
}
size_t GetAdapterCount()
{
  return adapters.size();
}
 
int FindAdapter(const AddrIn& address) {
  for (int idx = 0, count = static_cast<int>(adapters.size()); idx < count; ++idx) {
    if (adapters[idx].addr == address) {
      return idx;
    }
  }
  return -1;
}
 
}// namespace ...
 
#endif