sock.h

#pragma once
 
#if __has_include("defs.h")
#include "defs.h"
#endif
 
#include "safe_winsock.h"
#include "errorcode.h"
#include "inaddr.h"
#include "tvops.h"
 
namespace mlib {
 
// clang-format off
class sock
{
public:
  enum type
  {
    stream = SOCK_STREAM,
    dgram = SOCK_DGRAM,
    raw = SOCK_RAW
  };

  enum shuthow
  {
    shut_read = 0,     
    shut_write = 1,    
    shut_readwrite = 2 
  };

  enum mflags
  {
    none = 0,                   
    out_of_band = MSG_OOB,      
    peek = MSG_PEEK,            
    dont_route = MSG_DONTROUTE, 
    wait_all = MSG_WAITALL      
  };
 
  sock ();
  explicit sock (SOCKET soc);
  explicit sock (type t, int domain = AF_INET, int proto = 0);
  sock (const sock&);
  sock (sock&&);
 
  virtual ~sock ();
  sock& operator= (const sock&);
  sock& operator= (sock&&);
  HANDLE       handle () const;
  bool         operator== (const sock& other) const;
  bool         operator!= (const sock& other) const;
  operator     SOCKET () const;
 
  virtual erc  open (type t, int domain = AF_INET, int proto = 0);
  virtual void close ();
  virtual erc  shutdown (shuthow sh) const;
 
  virtual bool is_open () const;
  size_t       recv (void* buf, size_t maxlen, mflags msgf = mflags::none) const;
  size_t       recvfrom (sockaddr& sa, void* buf, size_t maxlen, mflags msgf = mflags::none) const;
  size_t       send (const void* buf, size_t len, mflags msgf = mflags::none) const;
  template <typename T>
  size_t       send (std::basic_string<T> buf, mflags msgf = mflags::none) const;
  size_t       sendto (const sockaddr& sa, const void* buf, size_t len, mflags msgf = mflags::none) const;
  template <typename T>
  size_t       sendto (const sockaddr& sa, std::basic_string<T> buf, mflags msgf = mflags::none) const;
 
  void                      sendtimeout (std::chrono::milliseconds tmo) const;
  std::chrono::milliseconds sendtimeout () const;
  void                      recvtimeout (std::chrono::milliseconds tmo) const;
  std::chrono::milliseconds recvtimeout () const;
  bool         is_readready (std::chrono::milliseconds tmo = std::chrono::milliseconds{0}) const;
  bool         is_writeready (std::chrono::milliseconds tmo = std::chrono::milliseconds{0}) const;
  bool         is_exceptionpending (std::chrono::milliseconds tmo = std::chrono::milliseconds{0}) const;
  unsigned int nread () const;
 
  erc          bind (const inaddr&) const;
  erc          bind () const;
  erc          connect (const inaddr& peer) const;
  erc          connect (const inaddr& peer, std::chrono::milliseconds tmo) const;
  bool         connected () const;
  erc          listen (int num = SOMAXCONN) const;
  erc          accept (sock& client, inaddr* sa = nullptr) const;
  erc          accept (sock& client, std::chrono::milliseconds tmo, inaddr* sa = nullptr) const;
  checked<inaddr>  name () const;
  checked<inaddr>  peer () const;
 
  int          getopt (int op, void* buf, int len, int level = SOL_SOCKET) const;
  erc          setopt (int op, void* buf, int len, int level = SOL_SOCKET) const;
 
  int          gettype () const;
  int          clearerror () const;
  bool         debug () const;
  void         debug (bool opt) const;
  bool         reuseaddr () const;
  void         reuseaddr (bool opt) const;
  bool         keepalive () const;
  void         keepalive (bool opt) const;
  bool         dontroute () const;
  void         dontroute (bool opt) const;
  bool         broadcast () const;
  void         broadcast (bool opt) const;
  bool         oobinline () const;
  void         oobinline (bool opt) const;
  int          sendbufsz () const;
  void         sendbufsz (size_t sz) const;
  int          recvbufsz () const;
  void         recvbufsz (size_t sz) const;
  void         blocking (bool on_off);
#ifdef _WIN32
  erc          setevent (HANDLE evt, long mask) const;
  long         enumevents () const;
#endif
  void         linger (bool on_off, unsigned short seconds) const;
  bool         linger (unsigned short* seconds = 0) const;
  void         nodelay (bool on_off);
  bool         nodelay () const;

  static errfac& Errors ();

  static void Errors (errfac& facitlity);
 
protected:
  static erc   last_error ();
 
private:
  struct sock_ref
  {
    sock_ref ()
      : handle{INVALID_SOCKET}
      , ref_count{1} {};
    SOCKET handle;
    int ref_count;
  }* sl;
 
  friend class inaddr;
  friend struct sock_initializer;
};
 
/*---------------------- support classes ------------------------------------*/
struct sock_initializer
{
  sock_initializer ();
  ~sock_initializer ();
};
inline sock_initializer sock_nifty_counter;
 
 
/*==================== INLINE FUNCTIONS ===========================*/

inline 
sock::sock ()
  : sl{nullptr}
{}

inline 
HANDLE sock::handle () const
{
  return sl ? (HANDLE)(std::intptr_t)sl->handle : INVALID_HANDLE_VALUE;
}

inline
sock::operator SOCKET () const
{
  return sl ? sl->handle : INVALID_SOCKET;
}

inline
bool sock::is_open () const
{
  return sl && sl->handle != INVALID_SOCKET;
}

inline
erc sock::connect (const inaddr& peer) const
{
  if (!sl || sl->handle == INVALID_SOCKET)
    return erc (WSAENOTSOCK, Errors());
 
  int ret = ::connect (sl->handle, peer, sizeof (peer));
  if (ret == INVALID_SOCKET)
    return last_error ();
 
  return erc::success;
}

inline
bool sock::connected () const
{
  return is_writeready ();
}

inline
erc sock::accept (sock& client, inaddr* addr) const
{
  if (!sl || sl->handle == INVALID_SOCKET)
    return erc (WSAENOTSOCK, Errors());
 
  sockaddr sa;
  socklen_t len = sizeof (sa);
  client = sock (::accept (sl->handle, &sa, &len));
  if (addr)
    *addr = sa;
  return erc ();
}

inline
erc sock::listen (int num) const
{
  if (!sl || sl->handle == INVALID_SOCKET)
    return erc (WSAENOTSOCK, Errors());
 
  ::listen (sl->handle, num);
  return last_error ();
}

template <typename T>
size_t sock::send (std::basic_string<T> buf, mflags msgf) const
{
  return send (buf.c_str (), buf.size () * sizeof (T), msgf);
}

template <typename T>
size_t sock::sendto (const sockaddr& sa, std::basic_string<T> buf, mflags msgf) const
{
  return sendto (sa, buf.c_str (), buf.size () * sizeof (T), msgf);
}

inline
void sock::sendtimeout (std::chrono::milliseconds tmo) const
{
  assert (sl && sl->handle != INVALID_SOCKET);
 
#ifdef _WIN32
  socklen_t optlen = sizeof (int);
  int par = (int)tmo.count();
#else
  socklen_t optlen = sizeof(timeval);
  timeval par = from_chrono (tmo);
#endif
  setsockopt (sl->handle, SOL_SOCKET, SO_SNDTIMEO, (char*)&par, optlen);
}

inline
std::chrono::milliseconds sock::sendtimeout () const
{
  assert (sl && sl->handle != INVALID_SOCKET);
 
#ifdef _WIN32
  socklen_t optlen = sizeof (int);
  int tmo;
  getsockopt (sl->handle, SOL_SOCKET, SO_SNDTIMEO, (char*)&tmo, &optlen);
  return std::chrono::milliseconds(tmo);
#else
  socklen_t optlen = sizeof(timeval);
  timeval tv;
  getsockopt (sl->handle, SOL_SOCKET, SO_SNDTIMEO, (char*)&tv, &optlen);
  return std::chrono::duration_cast<std::chrono::milliseconds>(to_chrono (tv));
#endif
}

inline
void sock::recvtimeout (std::chrono::milliseconds tmo) const
{
  assert (sl && sl->handle != INVALID_SOCKET);
#ifdef _WIN32
  socklen_t optlen = sizeof (int);
  int par = (int)tmo.count();
#else
  socklen_t optlen = sizeof(timeval);
  timeval par = from_chrono (tmo);
#endif
  setsockopt (sl->handle, SOL_SOCKET, SO_RCVTIMEO, (char*)&par, optlen);
}

inline
std::chrono::milliseconds sock::recvtimeout () const
{
  assert (sl && sl->handle != INVALID_SOCKET);
#ifdef _WIN32
  socklen_t optlen = sizeof (int);
  int tmo;
  getsockopt (sl->handle, SOL_SOCKET, SO_RCVTIMEO, (char*)&tmo, &optlen);
  return std::chrono::milliseconds (tmo);
#else
  socklen_t optlen = sizeof(timeval);
  timeval tv;
  getsockopt (sl->handle, SOL_SOCKET, SO_RCVTIMEO, (char*)&tv, &optlen);
  return std::chrono::duration_cast<std::chrono::milliseconds> (to_chrono(tv));
#endif
}

inline
int sock::getopt (int op, void* buf, int len, int level) const
{
  if (!sl || sl->handle == INVALID_SOCKET)
    return erc (WSAENOTSOCK, Errors());
 
  socklen_t rlen = len;
  if (::getsockopt (sl->handle, level, op, (char*)buf, &rlen) == SOCKET_ERROR)
    last_error ().raise ();
  return rlen;
}

inline
erc sock::setopt (int op, void* buf, int len, int level) const
{
  if (!sl || sl->handle == INVALID_SOCKET)
    return erc (WSAENOTSOCK, Errors());
 
  if (::setsockopt (sl->handle, level, op, (char*)buf, len) == SOCKET_ERROR)
    return last_error ();
 
  return erc::success;
}

inline
int sock::gettype () const
{
  int ty = 0;
  getopt (SO_TYPE, &ty, sizeof (ty));
  return ty;
}

inline
int sock::clearerror () const
{
  int err = 0;
  getopt (SO_ERROR, &err, sizeof (err));
  return err;
}

inline
bool sock::debug () const
{
  BOOL old;
  getopt (SO_DEBUG, &old, sizeof (old));
  return (old != 0);
}

inline
void sock::debug (bool b) const
{
  BOOL opt = b;
  setopt (SO_DEBUG, &opt, sizeof (opt));
}

inline
bool sock::reuseaddr () const
{
  BOOL old;
  getopt (SO_REUSEADDR, &old, sizeof (old));
  return (old != 0);
}

inline
void sock::reuseaddr (bool b) const
{
  BOOL opt = b;
  setopt (SO_REUSEADDR, &opt, sizeof (opt));
}

inline
bool sock::keepalive () const
{
  BOOL old;
  getopt (SO_KEEPALIVE, &old, sizeof (old));
  return (old != 0);
}

inline
void sock::keepalive (bool b) const
{
  BOOL opt = b;
  setopt (SO_KEEPALIVE, &opt, sizeof (opt));
}

inline
bool sock::dontroute () const
{
  BOOL old;
  getopt (SO_DONTROUTE, &old, sizeof (old));
  return (old != 0);
}

inline
void sock::dontroute (bool b) const
{
  BOOL opt = b;
  setopt (SO_DONTROUTE, &opt, sizeof (opt));
}

inline
bool sock::broadcast () const
{
  BOOL old;
  getopt (SO_BROADCAST, &old, sizeof (old));
  return (old != 0);
}

inline
void sock::broadcast (bool b) const
{
  BOOL opt = b;
  setopt (SO_BROADCAST, &opt, sizeof (opt));
}

inline
bool sock::oobinline () const
{
  BOOL old;
  getopt (SO_OOBINLINE, &old, sizeof (old));
  return (old != 0);
}

inline
void sock::oobinline (bool b) const
{
  BOOL opt = b;
  setopt (SO_OOBINLINE, &opt, sizeof (opt));
}

inline
int sock::sendbufsz () const
{
  int old = 0;
  getopt (SO_SNDBUF, &old, sizeof (old));
  return old;
}

inline
void sock::sendbufsz (size_t sz) const
{
  setopt (SO_SNDBUF, &sz, sizeof (sz));
}

inline
int sock::recvbufsz () const
{
  int old = 0;
  getopt (SO_RCVBUF, &old, sizeof (old));
  return old;
}

inline
void sock::recvbufsz (size_t sz) const
{
  setopt (SO_RCVBUF, &sz, sizeof (sz));
}

inline
void sock::blocking (bool on_off)
{
  if (!sl || sl->handle == INVALID_SOCKET)
    throw erc (WSAENOTSOCK, Errors());
 
  unsigned long mode = on_off ? 0 : 1;
  if (ioctlsocket (sl->handle, FIONBIO, &mode) == SOCKET_ERROR)
    last_error ().raise ();
}
 
#ifdef _WIN32
inline
erc sock::setevent (HANDLE evt, long mask) const
{
  if (!sl || sl->handle == INVALID_SOCKET)
    return erc (WSAENOTSOCK, Errors());
 
  if (WSAEventSelect (sl->handle, (WSAEVENT)evt, mask) == SOCKET_ERROR)
    return last_error ();
  return erc::success;
}

inline
long sock::enumevents () const
{
  if (!sl || sl->handle == INVALID_SOCKET)
    throw erc (WSAENOTSOCK, Errors());
 
  WSANETWORKEVENTS netev;
  if (WSAEnumNetworkEvents (sl->handle, NULL, &netev) == SOCKET_ERROR)
    last_error ().raise ();
  return netev.lNetworkEvents;
}
#endif

inline
void sock::linger (bool on_off, unsigned short seconds) const
{
  struct linger opt;
  opt.l_onoff = on_off;
  opt.l_linger = seconds;
  setopt (SO_LINGER, &opt, sizeof (opt));
}

inline
bool sock::linger (unsigned short* seconds) const
{
  struct linger opt;
  getopt (SO_LINGER, &opt, sizeof (opt));
  if (seconds)
    *seconds = opt.l_linger;
  return (opt.l_onoff == 0);
}

inline
void sock::nodelay (bool on_off)
{
  int value = on_off;
  setopt (TCP_NODELAY, &value, sizeof (int), IPPROTO_TCP);
}

inline
bool sock::nodelay () const
{
  int value;
  getopt (TCP_NODELAY, &value, sizeof (int), IPPROTO_TCP);
  return (value != 0);
}

inline
erc sock::last_error ()
{
#ifdef _WIN32
  int code = WSAGetLastError ();
#else
  int code = errno;
#endif
  if (!code)
    return erc::success;
  else
    return erc (code, Errors());
}

inline
bool sock::operator== (const sock& other) const
{
  return (sl == other.sl);
}

inline
bool sock::operator!= (const sock& other) const
{
  return !operator== (other);
}

inline 
sock::mflags operator| (sock::mflags f1, sock::mflags f2)
{
  return (sock::mflags) ((int)f1 | (int)f2);
}
 
} // namespace mlib

inline 
std::ostream& operator<< (std::ostream& strm, const mlib::sock& s)
{
  strm << s.handle ();
  return strm;
}