socket.h

Go to the documentation of this file.

#pragma once
 
#include <chrono>
#include <span>
#include <utility>
 
#include <rex/platform.h>
#include <rex/bit.h>
#include <rex/platform/thread.h>
#include <rex/platform/sync.h>
#include <rex/types.h>
#include <rex/utility.h>
 
struct sockaddr;
 
namespace rex::platform {

using SocketHandle = i64;
 
constexpr SocketHandle kInvalidSocket = -1;

REX_API int SocketClose(SocketHandle handle);

REX_API int SocketIOCTL(SocketHandle handle, u32 cmd, u8* arg);
 
enum class SocketReady : u8 {
  kNone = 0,
  kRead = 1 << 0,   
  kWrite = 1 << 1,  
  kExcept = 1 << 2, 
};
 
struct SocketWait {
  SocketHandle handle = kInvalidSocket;
  WaitHandle* event = nullptr; 
  SocketReady ready = SocketReady::kNone;
};

REX_API int SocketPrepare(SocketHandle handle, WaitHandle* event);

REX_API bool IsSocketWouldBlock();

REX_API u32 GetSocketError();

REX_API int PollSockets(std::span<const SocketWait> sockets, std::span<SocketReady> ready);

REX_API WaitResult WaitSockets(std::span<const SocketWait> sockets, bool alertable,
                               std::chrono::milliseconds timeout);

class Socket : public MoveOnly {
 public:
  Socket() = default;

  explicit Socket(SocketHandle handle) : handle_(handle) {}
 
  ~Socket() { Reset(); }
 
  Socket(Socket&& other) noexcept : handle_(std::exchange(other.handle_, kInvalidSocket)) {}
 
  Socket& operator=(Socket&& other) noexcept {
    if (this != &other) {
      Reset();
      handle_ = std::exchange(other.handle_, kInvalidSocket);
    }
    return *this;
  }

  REX_API static Socket Create(i32 family, i32 type, i32 protocol);
 
  bool IsValid() const { return handle_ != kInvalidSocket; }

  SocketHandle GetHandle() const { return handle_; }

  REX_API i32 Connect(const sockaddr* name, i32 name_len) const;

  REX_API i32 Bind(const sockaddr* name, i32 name_len) const;

  REX_API i32 GetLocalName(sockaddr* name, i32* name_len) const;

  REX_API i32 Listen(i32 backlog) const;

  REX_API Socket Accept(sockaddr* name, i32* name_len) const;

  REX_API i32 Shutdown(i32 how) const;

  REX_API i32 Recv(void* buf, i32 len, i32 flags) const;

  REX_API i32 RecvFrom(void* buf, i32 len, i32 flags, sockaddr* from, i32* from_len) const;

  REX_API i32 Send(const void* buf, i32 len, i32 flags) const;

  REX_API i32 SendTo(const void* buf, i32 len, i32 flags, const sockaddr* to, i32 to_len) const;

  REX_API i32 SetOption(i32 level, i32 name, const void* value, i32 len) const;

  REX_API i32 GetOption(i32 level, i32 name, void* value, i32* len) const;

  REX_API i32 GetPeerName(sockaddr* name, i32* name_len) const;

  i32 IOCTL(u32 cmd, u8* arg) const { return SocketIOCTL(handle_, cmd, arg); }

  i32 Prepare(WaitHandle* event) const { return SocketPrepare(handle_, event); }
 
 private:
  void Reset() {
    if (IsValid()) {
      SocketClose(std::exchange(handle_, kInvalidSocket));
    }
  }
 
  SocketHandle handle_ = kInvalidSocket;
};
 
}  // namespace rex::platform

template <>
inline constexpr bool rex::is_flags_enum<rex::platform::SocketReady> = true;