tcp.h

Go to the documentation of this file.

#pragma once
 
// TCP socket, acceptor, and endpoint types — Asio-compatible shapes.
// Requires native socket APIs (Windows or POSIX).
// On embedded platforms (STM32, AVR, etc.) this file compiles to nothing.
 
#include "fl/stl/asio/completion_handler.h"
#include "fl/stl/asio/error_code.h"
#include "fl/stl/span.h"
#include "fl/stl/stdint.h"
#include "fl/stl/string.h"
#include "fl/stl/noexcept.h"
 
namespace fl {
namespace asio {
namespace ip {
namespace tcp {

struct endpoint {
    fl::string host; // hostname or IP address
    u16 port;
 
    endpoint() FL_NOEXCEPT : port(0) {}
    endpoint(const fl::string &h, u16 p) : host(h), port(p) {}
    endpoint(const char *h, u16 p) : host(h), port(p) {}
 
    bool operator==(const endpoint &o) const {
        return port == o.port && host == o.host;
    }
    bool operator!=(const endpoint &o) const { return !(*this == o); }
};
 
#ifdef FASTLED_HAS_NETWORKING

class socket {
  public:
    socket() FL_NOEXCEPT;
    ~socket() FL_NOEXCEPT;
 
    // Movable
    socket(socket &&other) FL_NOEXCEPT;
    socket &operator=(socket &&other) FL_NOEXCEPT;
 
    // Not copyable
    socket(const socket &) FL_NOEXCEPT = delete;
    socket &operator=(const socket &) FL_NOEXCEPT = delete;

    bool is_open() const;

    error_code connect(const endpoint &ep);

    void close();

    void shutdown();

    size_t read_some(fl::span<u8> buffer, error_code &ec);

    size_t write_some(fl::span<const u8> buffer, error_code &ec);

    void async_read_some(fl::span<u8> buffer, io_handler handler);

    void async_write_some(fl::span<const u8> buffer, io_handler handler);

    void async_connect(const endpoint &ep, connect_handler handler);

    void set_non_blocking(bool mode);

    bool is_non_blocking() const;

    int native_handle() const;

    void assign(int fd);
 
  private:
    int mFd;
    bool mNonBlocking;
 
    void close_fd();
};

class acceptor {
  public:
    acceptor() FL_NOEXCEPT;
    ~acceptor() FL_NOEXCEPT;
 
    // Not copyable or movable (owns listening socket)
    acceptor(const acceptor &) FL_NOEXCEPT = delete;
    acceptor &operator=(const acceptor &) FL_NOEXCEPT = delete;

    error_code open(u16 port);

    error_code listen(int backlog = 5);

    error_code accept(socket &peer);

    void async_accept(socket &peer, connect_handler handler);

    void close();

    bool is_open() const;

    int native_handle() const;

    u16 port() const;
 
  private:
    int mFd;
    u16 mPort;
};
 
#endif // FASTLED_HAS_NETWORKING
 
} // namespace tcp
} // namespace ip
} // namespace asio
} // namespace fl