logical_network_interface.hpp

#pragma once

#include "../global.hpp"

#include "../network_connection.hpp"
#include "gevserver.hpp"

#include "../_cexports/c_img.h"

namespace Cvb
{
CVB_BEGIN_INLINE_NS

template <>
inline HandleGuard<CExports::GEVIFACELIST>::HandleGuard(void *handle) noexcept
    : HandleGuard<CExports::GEVIFACELIST>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
{
}

namespace GevServer
{
struct LogicalNetworkInterface
{
  typedef Cvb::NetworkConnection::IPAddress IPAddressType;
  typedef Cvb::NetworkConnection::IPAddress IPv4MaskType;
  typedef Cvb::NetworkConnection::IPAddressUInt IPAddressTypeUInt;
  typedef std::uint16_t PortType;

  static std::vector<LogicalNetworkInterface> GetAllAvailable()
  {
    HandleGuard<CExports::GEVIFACELIST> guard(CVB_CALL_CAPI(CreateInterfaceList()));
    if (!guard.Handle())
      throw std::runtime_error("Failed to create interface list");

    auto numInterfaces = CVB_CALL_CAPI(ILCount(guard.Handle()));
    std::vector<LogicalNetworkInterface> interfaces;

    for (std::size_t i = 0; i < numInterfaces; ++i)
    {
      CExports::gsipv4 ip;
      auto result = CVB_CALL_CAPI(ILIPv4Address(guard.Handle(), i, ip));
      if (result < 0)
        throw std::runtime_error("Error retrieving IP");

      CExports::gsipv4 subnetMask;
      result = CVB_CALL_CAPI(ILIPv4SubnetMask(guard.Handle(), i, subnetMask));

      interfaces.push_back(LogicalNetworkInterface(Cvb::NetworkConnection::ToIPAddress(ip),
                                                   Cvb::NetworkConnection::ToIPAddress(subnetMask)));
    }
    return interfaces;
  }

  LogicalNetworkInterface(const IPAddressType &ip, const IPv4MaskType &ipv4Mask) : ipAddress_{ip}, ipv4Mask_{ipv4Mask}
  {
  }

  LogicalNetworkInterface(const IPAddressTypeUInt &ipUInt, const IPv4MaskType &ipv4Mask)
      : ipAddressUInt_{ipUInt}, ipv4Mask_{ipv4Mask}
  {
  }

  IPAddressType IPAddress() const { return ipAddress_; }

  void SetIPAddress(const IPAddressType &ipAddress)
  {
    ipAddress_ = ipAddress;
    ipAddressUInt_ = Cvb::NetworkConnection::ToIPAddressUInt(ipAddress_);
  }

  IPAddressTypeUInt IPAddressUInt() const { return ipAddressUInt_; }

  void SetIPAddressUInt(const IPAddressTypeUInt &ipAddressUInt)
  {
    ipAddressUInt_ = ipAddressUInt;
    ipAddress_ = Cvb::NetworkConnection::ToIPAddress(ipAddressUInt_);
  }

  IPAddressType IPv4Mask() const { return ipv4Mask_; }

  void IPv4Mask(const IPAddressType &ipv4Mask) { ipv4Mask_ = ipv4Mask; }

  IPAddressType ipAddress_;
  IPAddressTypeUInt ipAddressUInt_;
  IPv4MaskType ipv4Mask_;
};
}
CVB_END_INLINE_NS
}