socket.hpp

Go to the documentation of this file.

#pragma once
 
// TCP, UDP, and OS-local socket abstraction.
 
#include <atomic>
#include <string>
#include <string_view>
#include <vector>
#include <optional>
#include <cstddef>
#include <cstdint>
#include <chrono>
 
namespace pulp::runtime {
 
enum class SocketType { TCP, UDP, Local };

struct LocalPeerCredentials {
    std::uint64_t user_id = 0;
    std::uint64_t group_id = 0;
    std::int64_t process_id = 0;
    std::uint64_t process_generation_id = 0;
};
 
class Socket {
public:
    Socket() = default;
    ~Socket();

    bool create(SocketType type);

    bool bind(std::string_view address, uint16_t port);

    bool bind_local(std::string_view path);

    bool listen(int backlog = 5);

    std::optional<Socket> accept();

    std::optional<Socket> accept(std::chrono::milliseconds timeout);

    bool connect(std::string_view address, uint16_t port,
                 std::chrono::milliseconds timeout = {});

    bool connect_local(std::string_view path,
                       std::chrono::milliseconds timeout = {});

    std::optional<LocalPeerCredentials> local_peer_credentials() const;

    bool duplicate_local_handle(std::intptr_t handle);

    int send(const uint8_t* data, size_t length);
    int send(std::string_view data);

    int send_to(const uint8_t* data, size_t length,
                std::string_view address, uint16_t port);

    int receive(uint8_t* buffer, size_t buffer_size);

    bool set_write_timeout(std::chrono::milliseconds timeout);

    bool set_read_timeout(std::chrono::milliseconds timeout);

    int receive_from(uint8_t* buffer, size_t buffer_size,
                     std::string& from_address, uint16_t& from_port);

    void close();

    void shutdown();

    bool is_open() const;

    uint16_t local_port() const;

    std::string local_address() const;
 
    // No copy, move OK
    Socket(const Socket&) = delete;
    Socket& operator=(const Socket&) = delete;
    Socket(Socket&& other) noexcept;
    Socket& operator=(Socket&& other) noexcept;
 
private:
#ifdef _WIN32
    std::uintptr_t fd_ = ~std::uintptr_t{0};
#else
    int fd_ = -1;
#endif
    SocketType type_ = SocketType::TCP;
    std::string bound_local_path_;
    std::uint64_t bound_local_device_ = 0;
    std::uint64_t bound_local_inode_ = 0;
#ifdef _WIN32
    // Winsock does not wake a recv() blocked in another thread when the socket
    // is shut down locally, so receive() waits for readiness in short slices,
    // checks this flag between them, and enforces the read timeout itself.
    std::atomic<bool> shutdown_requested_{false};
    std::atomic<std::int64_t> read_timeout_ms_{0};
#endif
 
    bool connect_address(const void* address, std::size_t address_size,
                         std::chrono::milliseconds timeout);
};
 
}  // namespace pulp::runtime