stream_channel.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/flags>
#include <idfxx/net/endpoint>
#include <idfxx/net/error>
#include <idfxx/net/netconn/buffer>
#include <idfxx/net/netconn/detail/base_channel.hpp>
 
#include <cstddef>
#include <cstdint>
#include <span>
#include <string_view>
 
namespace idfxx::net::netconn {
 
enum class write_flag : uint8_t {
    no_copy = 0x01,
    more = 0x02,       
    dont_block = 0x04, 
};
 
} // namespace idfxx::net::netconn
 
template<>
inline constexpr bool idfxx::enable_flags_operators<idfxx::net::netconn::write_flag> = true;
 
namespace idfxx::net::netconn {
 
class listener;
 
class [[nodiscard]] stream_channel : public detail::base_channel {
public:
    // ----- construction -----
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    stream_channel();
#endif
 
    [[nodiscard]] static result<stream_channel> make();
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    explicit stream_channel(address_family fam);
#endif
 
    [[nodiscard]] static result<stream_channel> make(address_family fam);
 
    // ----- connect / close / shutdown -----
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    void connect(const endpoint& peer) { idfxx::unwrap(try_connect(peer)); }
#endif
 
    [[nodiscard]] result<void> try_connect(const endpoint& peer);
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    void close() { idfxx::unwrap(try_close()); }
#endif
 
    result<void> try_close();
 
#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);
 
    // ----- send / receive -----
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    size_t send(std::span<const std::byte> data, idfxx::flags<write_flag> flags = {}) {
        return idfxx::unwrap(try_send(data, flags));
    }
#endif
 
    [[nodiscard]] result<size_t> try_send(std::span<const std::byte> data, idfxx::flags<write_flag> flags = {});
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    size_t send(std::string_view data, idfxx::flags<write_flag> flags = {}) {
        return idfxx::unwrap(try_send(data, flags));
    }
#endif
 
    [[nodiscard]] result<size_t> try_send(std::string_view data, idfxx::flags<write_flag> flags = {});
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] buffer recv() { return idfxx::unwrap(try_recv()); }
#endif
 
    [[nodiscard]] result<buffer> try_recv();
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] std::span<std::byte> recv(std::span<std::byte> buf) { return idfxx::unwrap(try_recv(buf)); }
#endif
 
    [[nodiscard]] result<std::span<std::byte>> try_recv(std::span<std::byte> buf);
 
    // ----- endpoint -----
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] endpoint peer_endpoint() const { return idfxx::unwrap(try_peer_endpoint()); }
#endif
 
    [[nodiscard]] result<endpoint> try_peer_endpoint() const { return _try_getaddr(false); }
 
private:
    friend class listener;
 
    stream_channel(::netconn* conn, address_family fam) noexcept
        : base_channel(conn, fam) {}
 
    // Once the peer closes the receive direction (ERR_CLSD), lwIP only
    // signals that condition on the first `netconn_recv`; subsequent calls
    // return ERR_CONN. Track the close locally so `try_recv` keeps reporting
    // the BSD-style empty-buffer EOF instead of surfacing the stale error.
    bool _eof = false;
 
    // Leftover from a previous `try_recv(std::span)` whose caller buffer was
    // smaller than the segment lwIP delivered. The netbuf-returning
    // `try_recv` has no partial-consume hook on the lwIP side, so when the
    // copy overshoots we keep the netbuf alive here and drain the remainder
    // on subsequent span-recv calls. Cleared on close/shutdown and moved
    // along with the channel.
    buffer _pending;
    size_t _pending_offset = 0;
};
 
} // namespace idfxx::net::netconn