InterfaceAddress.hxx

#pragma once
 
// Linux
#include <ifaddrs.h>
#include <sys/types.h>
 
// C++
#include <optional>
 
// cosmos
#include <cosmos/BitMask.hxx>
#include <cosmos/SysString.hxx>
#include <cosmos/net/IPAddress.hxx>
#include <cosmos/net/LinkLayerAddress.hxx>
#include <cosmos/net/types.hxx>
 
 
namespace cosmos {
 
 
enum class InterfaceFlag : unsigned int {
        UP           = IFF_UP,           
        BROADCAST    = IFF_BROADCAST,    
        DEBUG        = IFF_DEBUG,        
        LOOPBACK     = IFF_LOOPBACK,     
        POINTOPOINT  = IFF_POINTOPOINT,  
        NOTRAILERS   = IFF_NOTRAILERS,   
        RUNNING      = IFF_RUNNING,      
        NOARP        = IFF_NOARP,        
        PROMISC      = IFF_PROMISC,      
        ALLMULTI     = IFF_ALLMULTI,     
        MASTER       = IFF_MASTER,       
        SLAVE        = IFF_SLAVE,        
        MULTICAST    = IFF_MULTICAST,    
        PORTSEL      = IFF_PORTSEL,      
        AUTOMEDIA    = IFF_AUTOMEDIA,    
        DYNAMIC      = IFF_DYNAMIC,      
        LOWER_UP     = IFF_LOWER_UP,     
        DORMANT      = IFF_DORMANT,      
        ECHO         = IFF_ECHO,         
};
 
using InterfaceFlags = BitMask<InterfaceFlag>;
 
 
class InterfaceAddress :
        protected ::ifaddrs {
 
public: // functions
 
        // this type is only available via InterfaceAddressList, so disallow
        // construction
 
        InterfaceAddress() = delete;
        InterfaceAddress(const InterfaceAddress&) = delete;
 
        SysString ifname() const {
                return ifa_name;
        }
 
        InterfaceFlags flags() const {
                return InterfaceFlags{ifa_flags};
        }
 
 
        SocketFamily family() const {
                if (!hasAddress())
                        return SocketFamily::UNSPEC;
 
                return SocketFamily{ifa_addr->sa_family};
        }
 
        bool hasAddress() const {
                return ifa_addr != nullptr;
        }
 
        bool hasNetmask() const {
                return ifa_netmask != nullptr;
        }
 
 
        bool hasBroadcastAddress() const {
                if (!flags()[InterfaceFlag::BROADCAST])
                        return false;
 
                return ifa_broadaddr != nullptr;
        }
 
        bool hasPointToPointDest() const {
                if (!flags()[InterfaceFlag::POINTOPOINT])
                        return false;
 
                return ifa_dstaddr != nullptr;
        }
 
        bool isIP4() const {
                return family() == SocketFamily::INET;
        }
 
        bool isIP6() const {
                return family() == SocketFamily::INET6;
        }
 
        bool isLinkLayer() const {
                return family() == SocketFamily::PACKET;
        }
 
        std::optional<cosmos::IP4Address> addrAsIP4() const {
                if (!isIP4())
                        return std::nullopt;
 
                return cosmos::IP4Address{*(reinterpret_cast<sockaddr_in*>(ifa_addr))};
        }
 
        std::optional<cosmos::IP6Address> addrAsIP6() const {
                if (!isIP6())
                        return std::nullopt;
 
                return cosmos::IP6Address{*(reinterpret_cast<sockaddr_in6*>(ifa_addr))};
        }
 
        std::optional<cosmos::LinkLayerAddress> addrAsLLA() const {
                if (!isLinkLayer())
                        return std::nullopt;
 
                return cosmos::LinkLayerAddress{*(reinterpret_cast<sockaddr_ll*>(ifa_addr))};
        }
 
        std::optional<cosmos::IP4Address> netmaskAsIP4() const {
                if (!hasNetmask() || SocketFamily{ifa_netmask->sa_family} != SocketFamily::INET)
                        return std::nullopt;
 
                return cosmos::IP4Address{*(reinterpret_cast<sockaddr_in*>(ifa_netmask))};
        }
 
        std::optional<cosmos::IP6Address> netmaskAsIP6() const {
                if (!hasNetmask() || SocketFamily{ifa_netmask->sa_family} != SocketFamily::INET6)
                        return std::nullopt;
 
                return cosmos::IP6Address{*(reinterpret_cast<sockaddr_in6*>(ifa_netmask))};
        }
 
        std::optional<cosmos::IP4Address> broadcastAsIP4() const {
                if (!hasBroadcastAddress() || SocketFamily{ifa_broadaddr->sa_family} != SocketFamily::INET)
                        return std::nullopt;
 
                return cosmos::IP4Address{*(reinterpret_cast<sockaddr_in*>(ifa_broadaddr))};
        }
 
        std::optional<cosmos::IP4Address> pointToPointAsIP4() const {
                if (!hasPointToPointDest() || SocketFamily{ifa_broadaddr->sa_family} != SocketFamily::INET)
                        return std::nullopt;
 
                return cosmos::IP4Address{*(reinterpret_cast<sockaddr_in*>(ifa_dstaddr))};
        }
};
 
} // end ns