stream_socket.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_io_socket_base.hpp>
#include <idfxx/net/endpoint>
#include <idfxx/net/error>
#include <idfxx/net/resolver>
 
#include <chrono>
#include <cstddef>
#include <optional>
#include <span>
#include <string_view>
 
namespace idfxx::net {
 
class listener;
 
class [[nodiscard]] stream_socket : public detail::ip_io_socket_base {
public:
    struct config {
        address_family family = address_family::ipv4; 
        bool non_blocking = false;
        std::optional<std::chrono::milliseconds> recv_timeout = std::nullopt;
        std::optional<std::chrono::milliseconds> send_timeout = std::nullopt;
        bool reuse_address = false;
        bool no_delay = false;
        bool keep_alive = false;
        std::optional<std::chrono::seconds> keep_idle = std::nullopt;
        std::optional<std::chrono::seconds> keep_interval = std::nullopt;
        std::optional<uint32_t> keep_count = std::nullopt;
#ifdef CONFIG_LWIP_IPV6
        bool ipv6_only = false;
#endif
        std::optional<std::string_view> bind_to_device = std::nullopt;
    };
 
    // ----- construction (unconnected) -----
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    stream_socket();
 
    explicit stream_socket(address_family fam);
 
    explicit stream_socket(const config& cfg);
#endif
 
    [[nodiscard]] static result<stream_socket> make();
 
    [[nodiscard]] static result<stream_socket> make(address_family fam);
 
    [[nodiscard]] static result<stream_socket> make(const config& cfg);
 
    // ----- connect_to (single peer) -----
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    explicit stream_socket(const endpoint& peer);
 
    explicit stream_socket(const endpoint& peer, const config& cfg);
#endif
 
    [[nodiscard]] static result<stream_socket> connect_to(const endpoint& peer);
 
    [[nodiscard]] static result<stream_socket> connect_to(const endpoint& peer, const config& cfg);
 
    // ----- connect_to (resolve a host, try each candidate until one connects) -----
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    explicit stream_socket(std::string_view host, port_number port);
 
    explicit stream_socket(
        std::string_view host,
        port_number port,
        const config& cfg,
        const resolver_options& opts = {}
    );
#endif
 
    [[nodiscard]] static result<stream_socket> connect_to(std::string_view host, port_number port);
 
    [[nodiscard]] static result<stream_socket>
    connect_to(std::string_view host, port_number port, const config& cfg, const resolver_options& opts = {});
 
    // ----- connect_to_for (resolve a host with per-candidate timeout) -----
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    template<typename Rep, typename Period>
    explicit stream_socket(std::string_view host, port_number port, const std::chrono::duration<Rep, Period>& timeout);
 
    template<typename Rep, typename Period>
    explicit stream_socket(
        std::string_view host,
        port_number port,
        const std::chrono::duration<Rep, Period>& timeout,
        const config& cfg,
        const resolver_options& opts = {}
    )
        : stream_socket(idfxx::unwrap(connect_to_for(host, port, timeout, cfg, opts))) {}
#endif
 
    template<typename Rep, typename Period>
    [[nodiscard]] static result<stream_socket>
    connect_to_for(std::string_view host, port_number port, const std::chrono::duration<Rep, Period>& timeout);
 
    template<typename Rep, typename Period>
    [[nodiscard]] static result<stream_socket> connect_to_for(
        std::string_view host,
        port_number port,
        const std::chrono::duration<Rep, Period>& timeout,
        const config& cfg,
        const resolver_options& opts = {}
    ) {
        return _connect_to_for(host, port, std::chrono::ceil<std::chrono::milliseconds>(timeout), cfg, opts);
    }
 
    // ----- connect / disconnect -----
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    template<typename Rep, typename Period>
    void connect_for(const endpoint& peer, const std::chrono::duration<Rep, Period>& timeout) {
        idfxx::unwrap(_try_connect_for(peer, std::chrono::ceil<std::chrono::milliseconds>(timeout)));
    }
#endif
 
    template<typename Rep, typename Period>
    [[nodiscard]] result<void>
    try_connect_for(const endpoint& peer, const std::chrono::duration<Rep, Period>& timeout) {
        return _try_connect_for(peer, std::chrono::ceil<std::chrono::milliseconds>(timeout));
    }
 
    // ----- send -----
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] size_t send(std::span<const std::byte> buf) { return idfxx::unwrap(try_send(buf)); }
#endif
 
    [[nodiscard]] result<size_t> try_send(std::span<const std::byte> buf);
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] size_t send(std::string_view buf) { return idfxx::unwrap(try_send(buf)); }
#endif
 
    [[nodiscard]] result<size_t> try_send(std::string_view buf);
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    void send_all(std::span<const std::byte> buf) { idfxx::unwrap(try_send_all(buf)); }
#endif
 
    [[nodiscard]] result<void> try_send_all(std::span<const std::byte> buf);
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    void send_all(std::string_view buf) { idfxx::unwrap(try_send_all(buf)); }
#endif
 
    [[nodiscard]] result<void> try_send_all(std::string_view buf);
 
    // ----- receive -----
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    void recv_exact(std::span<std::byte> buf) { idfxx::unwrap(try_recv_exact(buf)); }
#endif
 
    [[nodiscard]] result<void> try_recv_exact(std::span<std::byte> buf);
 
    // ----- shutdown -----
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    void shutdown() { idfxx::unwrap(try_shutdown()); }
#endif
 
    result<void> try_shutdown();
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    void shutdown(direction dir) { idfxx::unwrap(try_shutdown(dir)); }
#endif
 
    result<void> try_shutdown(direction dir);
 
    // ----- TCP-only options (setters) -----
 
    void set_no_delay(bool on) noexcept;
 
    void set_keep_alive(bool on) noexcept;
 
    template<typename Rep, typename Period>
    void set_keep_idle(const std::chrono::duration<Rep, Period>& t) noexcept {
        _set_keep_idle(std::chrono::ceil<std::chrono::seconds>(t));
    }
 
    template<typename Rep, typename Period>
    void set_keep_interval(const std::chrono::duration<Rep, Period>& t) noexcept {
        _set_keep_interval(std::chrono::ceil<std::chrono::seconds>(t));
    }
 
    void set_keep_count(uint32_t count) noexcept;
 
    // ----- TCP-only options (getters) -----
 
    [[nodiscard]] bool get_no_delay() const noexcept;
 
    [[nodiscard]] bool get_keep_alive() const noexcept;
 
private:
    friend class listener;
 
    stream_socket(int fd, address_family fam) noexcept
        : ip_io_socket_base(fd, fam) {}
 
    [[nodiscard]] result<void> _try_connect_for(const endpoint& peer, std::chrono::milliseconds timeout);
    [[nodiscard]] static result<stream_socket>
    _make_and_connect_for(const endpoint& ep, const config& cfg, std::chrono::milliseconds timeout);
    [[nodiscard]] static result<stream_socket> _connect_to_for(
        std::string_view host,
        port_number port,
        std::chrono::milliseconds timeout,
        const config& cfg,
        const resolver_options& opts
    );
    void _set_keep_idle(std::chrono::seconds s) noexcept;
    void _set_keep_interval(std::chrono::seconds s) noexcept;
};
 
// Out-of-line definitions for the bare timed `connect_to_for` overload and the
// throwing ctor that delegates to it. These cannot be defined inside the class
// body because they need to value-initialize `config{}`, and the nested `config`
// class's default member initializers are not visible inside the enclosing class
// until its definition is complete.
 
template<typename Rep, typename Period>
result<stream_socket> stream_socket::connect_to_for(
    std::string_view host,
    port_number port,
    const std::chrono::duration<Rep, Period>& timeout
) {
    return connect_to_for(host, port, timeout, config{}, {});
}
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
template<typename Rep, typename Period>
stream_socket::stream_socket(std::string_view host, port_number port, const std::chrono::duration<Rep, Period>& timeout)
    : stream_socket(idfxx::unwrap(connect_to_for(host, port, timeout))) {}
#endif
 
} // namespace idfxx::net