eth_header.h

Go to the documentation of this file.

// Copyright 2023-2025 The Aerospace Corporation.
// This file is a part of SatCat5, licensed under CERN-OHL-W v2 or later.
 
#pragma once
 
#include <satcat5/io_core.h>
#include <satcat5/types.h>
 
// Enable 802.1Q VLAN tagging?
#ifndef SATCAT5_VLAN_ENABLE
#define SATCAT5_VLAN_ENABLE 1
#endif
 
namespace satcat5 {
    namespace eth {
        struct MacAddr {
            u8 addr[6];
 
            MacAddr() = default;
            MacAddr(const MacAddr& t) = default;
            MacAddr& operator=(const MacAddr& t) = default;
 
            static constexpr satcat5::eth::MacAddr from_u64(u64 x) {
                return MacAddr {
                    (u8)(x >> 40), (u8)(x >> 32), (u8)(x >> 24),
                    (u8)(x >> 16), (u8)(x >>  8), (u8)(x >>  0)};
            }
            constexpr u64 to_u64() const {
                return 1099511627776ULL * addr[0]
                     +    4294967296ULL * addr[1]
                     +      16777216ULL * addr[2]
                     +         65536ULL * addr[3]
                     +           256ULL * addr[4]
                     +             1ULL * addr[5];
            }
 
            constexpr u64 to_ptp_clockid() const {
                return 72057594037927936ull * addr[0]
                    +    281474976710656ull * addr[1]
                    +      1099511627776ull * addr[2]
                    +         4294967296ull * 0xFF
                    +           16777216ull * 0xFE
                    +              65536ull * addr[3]
                    +                256ull * addr[4]
                    +                  1ull * addr[5];
            }
 
            bool operator==(const satcat5::eth::MacAddr& other) const;
            bool operator<(const satcat5::eth::MacAddr& other) const;
            inline bool operator!=(const satcat5::eth::MacAddr& other) const
                {return !operator==(other);}
 
            // Tests for various reserved address ranges:
            bool is_broadcast() const;      
            bool is_l2multicast() const;    
            bool is_l3multicast() const;    
            bool is_multicast() const;      
            bool is_swcontrol() const;      
            bool is_unicast() const;        
            bool is_valid() const;          
 
            void log_to(satcat5::log::LogBuffer& wr) const;
            inline void write_to(satcat5::io::Writeable* wr) const
                {wr->write_bytes(6, addr);}
            inline bool read_from(satcat5::io::Readable* rd)
                {return rd->read_bytes(6, addr);}
        };
 
        struct MacType {
            u16 value;
 
            MacType() = default;
            MacType(const MacType& t) = default;
            MacType& operator=(const MacType& t) = default;
 
            inline bool operator==(const satcat5::eth::MacType& other) const
                {return value == other.value;}
            inline bool operator!=(const satcat5::eth::MacType& other) const
                {return value != other.value;}
 
            void log_to(satcat5::log::LogBuffer& wr) const;
            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;}
        };
 
        struct VlanTag {
            u16 value;
 
            VlanTag() = default;
            VlanTag(const VlanTag& t) = default;
            VlanTag& operator=(const VlanTag& t) = default;
 
            inline bool any() const {return !!value;}
            inline u16 vid() const {return ((value >> 0)  & 0xFFF);}
            inline u16 dei() const {return ((value >> 12) & 0x001);}
            inline u16 pcp() const {return ((value >> 13) & 0x007);}
            inline void set(u16 vid, u16 dei, u16 pcp) {
                value = ((vid & 0xFFF) << 0)
                      | ((dei & 0x001) << 12)
                      | ((pcp & 0x007) << 13);
            }
 
            inline bool operator==(const satcat5::eth::VlanTag& other) const
                {return value == other.value;}
            inline bool operator!=(const satcat5::eth::VlanTag& other) const
                {return value != other.value;}
 
            void log_to(satcat5::log::LogBuffer& wr) const;
            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;}
        };
 
        struct Header {
            satcat5::eth::MacAddr dst;
            satcat5::eth::MacAddr src;
            satcat5::eth::MacType type;
            satcat5::eth::VlanTag vtag;
 
            Header() = default;
            Header(const Header& t) = default;
            Header& operator=(const Header& t) = default;
 
            void log_to(satcat5::log::LogBuffer& wr) const;
 
            void write_to(satcat5::io::Writeable* wr) const;
 
            bool read_from(satcat5::io::Readable* rd);
        };
 
        // Commonly used MAC addresses and EtherTypes.
        constexpr satcat5::eth::MacAddr MACADDR_NONE =
            {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
        constexpr satcat5::eth::MacAddr MACADDR_BROADCAST =
            {{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}};
        constexpr satcat5::eth::MacAddr MACADDR_FLOWCTRL =
            {{0x01, 0x80, 0xC2, 0x00, 0x00, 0x01}};
        constexpr satcat5::eth::MacAddr BASEADDR_LINKLOCAL =
            {{0x01, 0x80, 0xC2, 0x00, 0x00, 0x00}};
        constexpr satcat5::eth::MacAddr BASEADDR_L2MULTICAST =
            {{0x01, 0x80, 0xC2, 0x00, 0x01, 0x00}};
        constexpr satcat5::eth::MacAddr BASEADDR_L3MULTICAST =
            {{0x01, 0x00, 0x5E, 0x00, 0x00, 0x00}};
 
        constexpr satcat5::eth::MacType
            ETYPE_NONE          = {0x0000},
            ETYPE_IPV4          = {0x0800},
            ETYPE_ARP           = {0x0806},
            ETYPE_RECOVERY      = {0x5252},
            ETYPE_CFGBUS_CMD    = {0x5C01},
            ETYPE_CFGBUS_ACK    = {0x5C02},
            ETYPE_SLINGSHOT_LOG = {0x5C03},
            ETYPE_CBOR_TLM      = {0x5C04},
            ETYPE_SWITCH_LOG    = {0x5C05},
            ETYPE_VTAG          = {0x8100},
            ETYPE_FLOWCTRL      = {0x8808},
            ETYPE_MACSEC        = {0x88E5},
            ETYPE_PTP           = {0x88F7};
 
        constexpr satcat5::eth::VlanTag
            VTAG_NONE           = {0x0000},     // Untagged frame
            VTAG_DEFAULT        = {0x0001},     // Default ports use VID = 1
            VTAG_PRIORITY1      = {0x2000},     // Set priority only (1-7)
            VTAG_PRIORITY2      = {0x4000},
            VTAG_PRIORITY3      = {0x6000},
            VTAG_PRIORITY4      = {0x8000},
            VTAG_PRIORITY5      = {0xA000},
            VTAG_PRIORITY6      = {0xC000},
            VTAG_PRIORITY7      = {0xE000};
 
        // Min/max range for VLAN identifier (VID)
        constexpr u16 VID_NONE  = 0;    // Default / placeholder
        constexpr u16 VID_MIN   = 1;    // Start of user VID range
        constexpr u16 VID_MAX   = 4094; // End of user VID range
        constexpr u16 VID_RSVD  = 4095; // Reserved
 
        // Null Ethernet header.
        constexpr satcat5::eth::Header HEADER_NULL =
            {MACADDR_NONE, MACADDR_NONE, ETYPE_NONE, VTAG_NONE};
    }
}