ip_core.h

// Copyright 2021-2025 The Aerospace Corporation.
// This file is a part of SatCat5, licensed under CERN-OHL-W v2 or later.
// Basic type definitions for Internet Protocol v4 packets (IPv4)
 
#pragma once
 
#include <satcat5/io_core.h>
 
namespace satcat5 {
    namespace ip {
        struct Addr {
            u32 value;
 
            constexpr Addr()
                : value(0) {}
            constexpr Addr(u32 ip)  // NOLINT
                : value(ip) {}
            constexpr Addr(u16 msb, u16 lsb)
                : value(65536ul * msb + lsb) {}
            constexpr Addr(u8 a, u8 b, u8 c, u8 d)
                : value(16777216ul * a + 65536ul * b + 256ul * c + d) {}
            Addr(const Addr& t) = default;
            Addr& operator=(const Addr& t) = default;
 
            constexpr bool operator==(const satcat5::ip::Addr& other) const
                {return value == other.value;}
            constexpr bool operator!=(const satcat5::ip::Addr& other) const
                {return value != other.value;}
            inline void write_to(satcat5::io::Writeable* wr) const
                {wr->write_u32(value);}
            inline bool read_from(satcat5::io::Readable* rd)
                {value = rd->read_u32(); return true;}
            constexpr satcat5::ip::Addr operator+(unsigned offset) const
                {return satcat5::ip::Addr(value + (u32)offset);}
 
            void log_to(satcat5::log::LogBuffer& wr) const;
 
            // Tests for various reserved address ranges:
            bool is_broadcast() const;  
            bool is_multicast() const;  
            bool is_reserved() const;   
            bool is_unicast() const;    
            bool is_valid() const;      
        };
 
        constexpr u32 cidr_prefix(unsigned npre) {
            return (npre ? ~((0x80000000 >> (npre-1)) - 1) : 0);
        }
 
        struct Mask : public satcat5::ip::Addr {
            constexpr Mask()
                : Addr() {}
            constexpr Mask(unsigned npre)  // NOLINT
                : Addr(satcat5::ip::cidr_prefix(npre)) {}
            constexpr Mask(u8 a, u8 b, u8 c, u8 d)
                : Addr(a, b, c, d) {}
            constexpr Mask(const satcat5::ip::Addr& addr)  // NOLINT
                : Addr(addr.value) {}
            Mask& operator=(const Mask& t) = default;
 
            unsigned prefix() const;
        };
 
        struct Subnet {
            // Raw access to the underlying representation.
            satcat5::ip::Addr addr;     
            satcat5::ip::Mask mask;     
 
            Subnet() = default;
            Subnet(const Subnet& t) = default;
            Subnet& operator=(const Subnet& t) = default;
 
            constexpr bool contains(const satcat5::ip::Addr& other) const
                {return (addr.value & mask.value) == (other.value & mask.value);}
 
            constexpr bool operator==(const satcat5::ip::Addr& other) const
                {return (addr == other) && (mask == Mask(32));}
            constexpr bool operator==(const satcat5::ip::Subnet& other) const
                {return (addr == other.addr) && (mask == other.mask);}
            constexpr bool operator!=(const satcat5::ip::Subnet& other) const
                {return (addr != other.addr) || (mask != other.mask);}
 
            inline unsigned prefix() const
                {return mask.prefix();}
 
            void log_to(satcat5::log::LogBuffer& wr) const;
        };
 
        struct Port {
            u16 value;
 
            constexpr Port(u16 port) : value(port) {}   // NOLINT
            Port(const Port& t) = default;
            Port& operator=(const Port& t) = default;
 
            constexpr bool operator==(const satcat5::ip::Port& other) const
                {return value == other.value;}
            constexpr bool operator!=(const satcat5::ip::Port& other) const
                {return value != other.value;}
            inline void write_to(satcat5::io::Writeable* wr) const
                {wr->write_u16(value);}
            inline bool read_from(satcat5::io::Readable* rd)
                {value = rd->read_u16(); return true;}
        };
 
        constexpr unsigned
            HDR_MIN_WORDS        = 5,
            HDR_MIN_SHORTS       = 2 * HDR_MIN_WORDS,
            HDR_MIN_BYTES        = 4 * HDR_MIN_WORDS,
            HDR_MAX_WORDS        = 15,
            HDR_MAX_SHORTS       = 2 * HDR_MAX_WORDS,
            HDR_MAX_BYTES        = 4 * HDR_MAX_WORDS;
 
        // Commonly used IP-addresses and other constants:
        constexpr satcat5::ip::Mask
            MASK_NONE   = 0,                        
            MASK_8      = 8,                        
            MASK_16     = 16,                       
            MASK_24     = 24,                       
            MASK_32     = 32;                       
        constexpr satcat5::ip::Port
            PORT_NONE   = 0;                        
        constexpr satcat5::ip::Addr
            ADDR_NONE(0, 0, 0, 0),                  
            ADDR_BROADCAST(255, 255, 255, 255),     
            ADDR_LOOPBACK(127, 0, 0, 1),            
            ADDR_ALL_SYSTEMS(224, 0, 0, 1),         
            ADDR_ALL_ROUTERS(224, 0, 0, 2),         
            ADDR_PTP_PDELAY(224, 0, 0, 107),        
            ADDR_PTP_PRIMARY(224, 0, 1, 129);       
        constexpr satcat5::ip::Subnet
            DEFAULT_ROUTE = {ADDR_NONE, MASK_NONE},
            UDP_MULTICAST = {Addr(224, 0, 0, 0), Mask(4)};
 
        constexpr u8 PROTO_ICMP                 = 0x01;
        constexpr u8 PROTO_IGMP                 = 0x02;
        constexpr u8 PROTO_TCP                  = 0x06;
        constexpr u8 PROTO_UDP                  = 0x11;
 
        struct Header {
            u16 data[HDR_MAX_SHORTS];
 
            Header() = default;
            Header(const Header& t) = default;
            Header& operator=(const Header& t) = default;
 
            // Accessors for specific sub-fields.
            // See also: https://en.wikipedia.org/wiki/IPv4#Header
            constexpr unsigned ver() const              
                {return (data[0] >> 12) & 0x0F;}
            constexpr unsigned ihl() const              
                {return (data[0] >> 8) & 0x0F;}
            constexpr unsigned len_total() const        
                {return data[1];}
            constexpr u16 id() const                    
                {return data[2];}
            constexpr u16 frg() const                   
                {return data[3] & 0xBFFF;}
            constexpr unsigned len_inner() const        
                {return len_total() - 4*ihl();}
            constexpr u8 ttl() const                    
                {return (u8)(data[4] >> 8);}
            constexpr u8 proto() const                  
                {return (u8)(data[4] & 0x00FF);}
            constexpr u16 chk() const                   
                {return data[5];}
            constexpr satcat5::ip::Addr src() const     
                {return satcat5::ip::Addr(data[6], data[7]);}
            constexpr satcat5::ip::Addr dst() const     
                {return satcat5::ip::Addr(data[8], data[9]);}
 
            void chk_incr16(u16 prev, u16 next);
            void chk_incr32(u32 prev, u32 next);
 
            void option_alert();
 
            void write_to(satcat5::io::Writeable* wr) const;
 
            bool read_core(satcat5::io::Readable* rd);  // Core header (first 20 bytes)
 
            bool read_from(satcat5::io::Readable* rd);  // Entire header (up to 64 bytes)
        };
 
        u16 checksum(unsigned wcount, const u16* data, u16 prev = UINT16_MAX);
    }
}