ip_socket_base.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
 
// Narrow internal base class shared by every public socket type — `listener`,
// `stream_socket`, `datagram_socket`, `raw_socket`. Holds the file descriptor,
// address family, lifecycle (move, close), `bind` / `local_endpoint`,
// `wait_readable`, and the family-generic socket options that are meaningful
// even on a listening (accept-only) socket.
//
// Members that imply peer-oriented I/O (`connect`, `recv`, `peer_endpoint`,
// `set_send_buffer`, `set_send_timeout`, `wait_writable`, `get_send_buffer`)
// live on `ip_io_socket_base`, which sits between this class and the
// connectable socket types — keeping them off `listener` at compile time.
//
// Public inheritance with no virtual functions: there is no polymorphism,
// derived destructors run first, and the base destructor calls `close()` to
// guarantee the descriptor is released even if a derived class forgets.
 
#include "sdkconfig.h"
 
#include <idfxx/net/endpoint>
#include <idfxx/net/error>
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string_view>
 
namespace idfxx::net::detail {
 
class ip_socket_base {
public:
    ~ip_socket_base() noexcept;
 
    ip_socket_base(const ip_socket_base&) = delete;
    ip_socket_base& operator=(const ip_socket_base&) = delete;
 
    ip_socket_base(ip_socket_base&& other) noexcept;
    ip_socket_base& operator=(ip_socket_base&& other) noexcept;
 
    [[nodiscard]] int idf_handle() const noexcept { return _fd; }
 
    [[nodiscard]] address_family family() const noexcept { return _family; }
 
    [[nodiscard]] bool is_open() const noexcept { return _fd >= 0; }
 
    void close() noexcept;
 
    [[nodiscard]] std::optional<endpoint> local_endpoint() const noexcept;
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    void bind(const endpoint& addr) { idfxx::unwrap(try_bind(addr)); }
#endif
 
    [[nodiscard]] result<void> try_bind(const endpoint& addr);
 
    void set_non_blocking(bool on) noexcept;
 
    void set_reuse_address(bool on) noexcept;
 
    void set_recv_buffer(size_t bytes) noexcept;
 
    void set_ttl(uint8_t ttl) noexcept;
 
    void set_tos(uint8_t tos) noexcept;
 
    void set_dscp(dscp value) noexcept;
 
    template<typename Rep, typename Period>
    void set_recv_timeout(const std::chrono::duration<Rep, Period>& t) noexcept {
        _set_recv_timeout(std::chrono::ceil<std::chrono::milliseconds>(t));
    }
 
#ifdef CONFIG_LWIP_IPV6
    void set_ipv6_only(bool on) noexcept;
#endif
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    void set_bind_to_device(std::string_view ifname) { idfxx::unwrap(try_set_bind_to_device(ifname)); }
#endif
 
    [[nodiscard]] result<void> try_set_bind_to_device(std::string_view ifname);
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    template<typename Rep, typename Period>
    void wait_readable(const std::chrono::duration<Rep, Period>& timeout) {
        idfxx::unwrap(_try_wait_readable(std::chrono::ceil<std::chrono::milliseconds>(timeout)));
    }
#endif
 
    template<typename Rep, typename Period>
    [[nodiscard]] result<void> try_wait_readable(const std::chrono::duration<Rep, Period>& timeout) {
        return _try_wait_readable(std::chrono::ceil<std::chrono::milliseconds>(timeout));
    }
 
    [[nodiscard]] size_t get_recv_buffer() const noexcept;
 
    [[nodiscard]] std::error_code get_last_error() const noexcept;
 
    [[nodiscard]] int idf_last_error() const noexcept;
 
protected:
    ip_socket_base() noexcept = default;
    ip_socket_base(int fd, address_family fam) noexcept
        : _fd(fd)
        , _family(fam) {}
 
    void _set_recv_timeout(std::chrono::milliseconds t) noexcept;
    [[nodiscard]] result<void> _try_wait_readable(std::chrono::milliseconds timeout);
 
    int _fd = -1;
    address_family _family = address_family::ipv4;
};
 
} // namespace idfxx::net::detail