listener.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
#include "sdkconfig.h"
 
#include <idfxx/net/detail/ip_socket_base.hpp>
#include <idfxx/net/endpoint>
#include <idfxx/net/error>
#include <idfxx/net/stream_socket>
 
#include <chrono>
#include <optional>
#include <string_view>
 
namespace idfxx::net {
 
class [[nodiscard]] listener : public detail::ip_socket_base {
public:
    struct accepted_connection {
        stream_socket socket; 
        endpoint peer;        
    };
 
    static constexpr int default_backlog = 5;
 
    struct config {
        address_family family = address_family::ipv4; 
        int backlog = default_backlog;                
        bool reuse_address = true;
#ifdef CONFIG_LWIP_IPV6
        bool ipv6_only = false;
#endif
        bool non_blocking = false;
        std::optional<std::string_view> bind_to_device = std::nullopt;
    };
 
    // ----- construction -----
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    explicit listener(const endpoint& bind_addr);
 
    explicit listener(const endpoint& bind_addr, const config& cfg);
 
    explicit listener(port_number port);
 
    explicit listener(port_number port, const config& cfg);
#endif
 
    [[nodiscard]] static result<listener> make(const endpoint& bind_addr);
 
    [[nodiscard]] static result<listener> make(const endpoint& bind_addr, const config& cfg);
 
    [[nodiscard]] static result<listener> make(port_number port);
 
    [[nodiscard]] static result<listener> make(port_number port, const config& cfg);
 
    // ----- accept -----
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] stream_socket accept() { return idfxx::unwrap(try_accept()); }
 
    [[nodiscard]] accepted_connection accept_with_peer() { return idfxx::unwrap(try_accept_with_peer()); }
 
    template<typename Rep, typename Period>
    [[nodiscard]] stream_socket accept_for(const std::chrono::duration<Rep, Period>& timeout) {
        return idfxx::unwrap(_try_accept_for(std::chrono::ceil<std::chrono::milliseconds>(timeout)));
    }
#endif
 
    [[nodiscard]] result<stream_socket> try_accept();
 
    [[nodiscard]] result<accepted_connection> try_accept_with_peer();
 
    template<typename Rep, typename Period>
    [[nodiscard]] result<stream_socket> try_accept_for(const std::chrono::duration<Rep, Period>& timeout) {
        return _try_accept_for(std::chrono::ceil<std::chrono::milliseconds>(timeout));
    }
 
private:
    explicit listener(int fd, address_family fam) noexcept
        : ip_socket_base(fd, fam) {}
 
    [[nodiscard]] result<stream_socket> _try_accept_for(std::chrono::milliseconds timeout);
};
 
} // namespace idfxx::net