ip_dhcp.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/eth_arp.h>
#include <satcat5/net_core.h>
#include <satcat5/ip_core.h>
#include <satcat5/polling.h>
#include <satcat5/udp_core.h>
 
// Set default for maximum client-ID length (range 1 - 254).
#ifndef SATCAT5_DHCP_MAX_ID_LEN
#define SATCAT5_DHCP_MAX_ID_LEN 62
#endif
 
namespace satcat5 {
    namespace ip {
        struct DhcpId {
            u8 id_len;      // Number of bytes in "id"
            u8 type;        // Type code (RFC2132 Section 9.14)
            u8 id[SATCAT5_DHCP_MAX_ID_LEN];
 
            DhcpId() = default;
            DhcpId(const DhcpId& t) = default;
            DhcpId& operator=(const DhcpId& t) = default;
        };
 
        enum class DhcpState {
            INIT,       // Initial state
            SELECTING,  // DISCOVER sent, waiting for OFFER
            TESTING,    // ARP sent, waiting for reply
            REQUESTING, // REQUEST sent, waiting for ACK
            BOUND,      // Successfully bound
            RENEWING,   // Normal unicast renew
            REBINDING,  // Fallback broadcast renew
            INFORMING,  // INFORM pending or sent; waiting for ACK
            STOPPED,    // Manually halted
        };
 
        class DhcpClient final
            : public satcat5::eth::ArpListener
            , public satcat5::net::Protocol
            , public satcat5::poll::Timer
        {
        public:
            DhcpClient(satcat5::udp::Dispatch* iface);
            ~DhcpClient() SATCAT5_OPTIONAL_DTOR;
 
            void inform(const satcat5::ip::Addr& new_addr);
 
            void release(const satcat5::ip::Addr& new_addr = satcat5::ip::ADDR_NONE);
 
            void renew();
 
            inline satcat5::ip::DhcpState state() const
                { return m_state; }
 
            u32 status() const;
 
            inline void set_client_id(const satcat5::ip::DhcpId* id)
                { m_client_id = id; }
 
        private:
            // Event handler methods.
            void arp_event(
                const satcat5::eth::MacAddr& mac,
                const satcat5::ip::Addr& ip) override;
            void frame_rcvd(satcat5::io::LimitedRead& src) override;
            void timer_event() override;
 
            // Internal methods.
            void next_timer();
            void send_message(u8 opcode);
 
            // Internal state.
            satcat5::udp::Dispatch* const m_iface;
            const satcat5::ip::DhcpId* m_client_id;
            satcat5::udp::Address m_server; 
            satcat5::ip::DhcpState m_state; 
            satcat5::ip::Addr m_ipaddr;     
            u16 m_seconds;                  
            u32 m_server_id;                
            u32 m_timeout;                  
            u32 m_xid;                      
        };
 
        struct DhcpAddress {
            u32 client;                     
            u32 timeout;                    
 
            DhcpAddress() = default;
            DhcpAddress(const DhcpAddress& t) = default;
            DhcpAddress& operator=(const DhcpAddress& t) = default;
        };
 
        class DhcpPool {
        public:
            virtual unsigned addr2idx(const satcat5::ip::Addr& addr) const = 0;
 
            virtual satcat5::ip::Addr idx2addr(unsigned idx) const = 0;
 
            virtual satcat5::ip::DhcpAddress* idx2meta(unsigned idx) = 0;
 
            inline bool contains(const satcat5::ip::Addr& addr)
                { return idx2addr(addr2idx(addr)).value > 0; }
 
            inline satcat5::ip::DhcpAddress* addr2meta(const satcat5::ip::Addr& addr)
                { return idx2meta(addr2idx(addr)); }
        };
 
        template <unsigned SIZE> class DhcpPoolStatic final
            : public satcat5::ip::DhcpPool
        {
        public:
            DhcpPoolStatic(const satcat5::ip::Addr& base) : m_base(base) {}
 
            unsigned addr2idx(const satcat5::ip::Addr& addr) const override
                { return (unsigned)(addr.value - m_base.value); }
 
            satcat5::ip::Addr idx2addr(unsigned idx) const override
                { return (idx < SIZE) ? (m_base + idx) : ADDR_NONE; }
 
            satcat5::ip::DhcpAddress* idx2meta(unsigned idx) override
                { return (idx < SIZE) ? (m_array + idx) : 0; }
 
        private:
            const satcat5::ip::Addr m_base;
            satcat5::ip::DhcpAddress m_array[SIZE];
        };
 
        class DhcpServer final
            : public satcat5::net::Protocol
            , public satcat5::poll::Timer
        {
        public:
            DhcpServer(
                satcat5::udp::Dispatch* iface,
                satcat5::ip::DhcpPool* pool);
            ~DhcpServer() SATCAT5_OPTIONAL_DTOR;
 
            void count_leases(unsigned& free, unsigned& taken) const;
 
            satcat5::ip::Addr request(u32 lease_seconds,
                const satcat5::ip::Addr& addr = satcat5::ip::ADDR_NONE);
 
            inline void set_dns(const satcat5::ip::Addr& addr)
                { m_dns = addr; }
            inline void set_domain(const char* name)
                { m_domain = name; }
            inline void set_gateway(const satcat5::ip::Subnet& gateway)
                { m_gateway = gateway; }
 
            inline void max_lease(u32 seconds)
                { m_max_lease = seconds; }
 
        private:
            // Event handler methods.
            void frame_rcvd(satcat5::io::LimitedRead& src) override;
            void timer_event() override;
 
            // Internal methods.
            satcat5::ip::Addr offer(
                u32 client_id, u32 req_ipaddr, u32 req_lease);
            satcat5::ip::Addr reserve(
                u32 client_id, u32 req_ipaddr, u32 req_lease);
 
            // Pointers to helper objects.
            satcat5::udp::Dispatch* const m_iface;
            satcat5::ip::DhcpPool* const m_pool;
 
            // Current reference time.
            u32 m_time;                     
            u32 m_max_lease;                
 
            // Round-robin indexing into the lease pool.
            unsigned m_next_lease;          
            unsigned m_next_timer;          
 
            // Parameters relayed to new clients.
            satcat5::ip::Addr m_dns;        
            const char* m_domain;           
            satcat5::ip::Subnet m_gateway;  
        };
    }
}