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 = 0;
          if (CVB_CALL_CAPI(ILIPv4Address(guard.Handle(), i, ip)))
            throw std::runtime_error("error retrieving IP");
 
          CExports::gsipv4 subnetMask = 0;
          if (CVB_CALL_CAPI(ILIPv4SubnetMask(guard.Handle(), i, subnetMask)))
            throw std::runtime_error("error retrieving subnet mask");
 
          interfaces.push_back(LogicalNetworkInterface(Cvb::NetworkConnection::ToIPAddress(ip),
                                                       Cvb::NetworkConnection::ToIPAddress(subnetMask)));
        }
        return interfaces;
      }
      static std::vector<LogicalNetworkInterface> GetAllAvailable() {…}
 
      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_;
      }
      IPAddressType IPAddress() const {…}

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

      IPAddressTypeUInt IPAddressUInt() const
      {
        return ipAddressUInt_;
      }
      IPAddressTypeUInt IPAddressUInt() const {…}

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

      IPAddressType IPv4Mask() const
      {
        return ipv4Mask_;
      }
      IPAddressType IPv4Mask() const {…}

      void IPv4Mask(const IPAddressType &ipv4Mask)
      {
        ipv4Mask_ = ipv4Mask;
      }
      void IPv4Mask(const IPAddressType &ipv4Mask) {…}
 
      IPAddressType ipAddress_;
      IPAddressTypeUInt ipAddressUInt_ = 0;
      IPv4MaskType ipv4Mask_;
    };
    struct LogicalNetworkInterface {…};
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb