wsockstream.h

Go to the documentation of this file.

/*
  MLIB Library
  (c) Mircea Neacsu 2001-2023. Licensed under MIT License.
  See README file for full license terms.
*/
 
#pragma once
 
#if __has_include("defs.h")
#include "defs.h"
#endif
 
#include "safe_winsock.h"
#include <iostream>
 
#include <mlib/errorcode.h>
#include <mlib/inaddr.h>
 
#include <assert.h>
 
namespace mlib {
 
// clang-format off
class sock
{
public:
  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 (int type, 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;
 
  virtual erc  open (int type, int domain = AF_INET, int proto = 0);
  virtual erc  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;
 
  int          sendtimeout (int wp_sec) const;
  int          sendtimeout () const;
  int          recvtimeout (int wp_sec) const;
  int          recvtimeout () const;
  bool         is_readready (int wp_sec, int wp_usec = 0) const;
  bool         is_writeready (int wp_sec, int wp_usec = 0) const;
  bool         is_exceptionpending (int wp_sec, int wp_usec = 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, int wp_sec) const;
  erc          listen (int num = SOMAXCONN) const;
  erc          accept (sock& client, inaddr* sa = nullptr) const;
  erc          accept (sock& client, int wp_sec, inaddr* sa = nullptr) const;
  erc          name (inaddr& addr) const;
  erc          peer (inaddr& addr) 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);
  erc          setevent (HANDLE evt, long mask) const;
  long         enumevents () const;
  void         linger (bool on_off, unsigned short seconds) const;
  bool         linger (unsigned short* seconds = 0) 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;
};
 
inline std::ostream& operator<< (std::ostream& strm, const sock& s)
{
  strm << s.handle ();
  return strm;
}
 
// default buffer size
#if !defined(SOCKBUF_BUFSIZ)
#define SOCKBUF_BUFSIZ 1024
#endif
 
class sockbuf : public sock, public std::streambuf
{
public:
  // constructors
  sockbuf (SOCKET soc = INVALID_SOCKET);
  sockbuf (int type, int domain = AF_INET, int proto = 0);
  sockbuf (const sockbuf&);
  sockbuf (const sock& soc);
 
  virtual ~sockbuf ();
  sockbuf& operator= (const sockbuf&);
 
protected:
  virtual int             underflow () override;
  virtual int             overflow (int c = EOF) override;
  virtual int             sync () override;
  virtual std::streambuf* setbuf (char* buf, std::streamsize sz) override;
  virtual std::streamsize showmanyc () override;
 
private:
  enum flags
  {
    allocbuf = 0x0002,  
    no_reads = 0x0004,  
    no_writes = 0x0008, 
    eof_seen = 0x0010   
  };
 
  int x_flags;
  int ibsize; // input buffer size
};
// clang-format on
 
 
template <class strm>
class generic_sockstream : public strm
{
public:
  generic_sockstream ()
    : strm (new sockbuf ()){};
 
  generic_sockstream (const sockbuf& sb)
    : strm (new sockbuf (sb)){};
 
  generic_sockstream (const sock& s)
    : strm (new sockbuf (s)){};
 
  generic_sockstream (int type, int domain = AF_INET, int proto = 0)
    : strm (new sockbuf (type, domain, proto)){};
 
  generic_sockstream (const inaddr& remote, int type = SOCK_STREAM);
 
  ~generic_sockstream ();
 
  sockbuf* rdbuf ()
  {
    return (sockbuf*)std::ios::rdbuf ();
  }
  sockbuf* operator->()
  {
    return rdbuf ();
  }
};
 
template <class strm>
generic_sockstream<strm>::generic_sockstream (const inaddr& remote, int type)
  : strm (new sockbuf ())
{
  rdbuf ()->open (type);
  rdbuf ()->connect (remote);
}
 
template <class strm>
generic_sockstream<strm>::~generic_sockstream ()
{
  delete std::ios::rdbuf ();
}
 
typedef generic_sockstream<std::istream> isockstream;
 
typedef generic_sockstream<std::ostream> osockstream;
 
typedef generic_sockstream<std::iostream> sockstream;
 
 
/*---------------------- support classes ------------------------------------*/
static struct sock_initializer
{
  sock_initializer ();
  ~sock_initializer ();
} sock_nifty_counter;
 
/*==================== INLINE FUNCTIONS ===========================*/
 
inline sock::sock ()
  : sl{nullptr}
{}
 
inline HANDLE sock::handle () const
{
  return sl ? (HANDLE)sl->handle : INVALID_HANDLE_VALUE;
}
 
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 == SOCKET_ERROR)
    return last_error ();
 
  return erc::success;
}
 
inline erc sock::accept (sock& client, inaddr* addr) const
{
  if (!sl || sl->handle == INVALID_SOCKET)
    return erc (WSAENOTSOCK, Errors());
 
  sockaddr sa;
  int 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 int sock::sendtimeout (int wp_sec) const
{
  if (!sl || sl->handle == INVALID_SOCKET)
    return erc (WSAENOTSOCK, Errors());
 
  int oldwtmo;
  int optlen = sizeof (int);
  getsockopt (sl->handle, SOL_SOCKET, SO_SNDTIMEO, (char*)&oldwtmo, &optlen);
  wp_sec *= 1000;
  setsockopt (sl->handle, SOL_SOCKET, SO_SNDTIMEO, (char*)&wp_sec, optlen);
  return oldwtmo / 1000;
}
 
inline int sock::sendtimeout () const
{
  if (!sl || sl->handle == INVALID_SOCKET)
    return erc (WSAENOTSOCK, Errors());
 
  int oldwtmo;
  int optlen = sizeof (int);
  getsockopt (sl->handle, SOL_SOCKET, SO_SNDTIMEO, (char*)&oldwtmo, &optlen);
  return oldwtmo / 1000;
}
 
inline int sock::recvtimeout (int wp_sec) const
{
  if (!sl || sl->handle == INVALID_SOCKET)
    return erc (WSAENOTSOCK, Errors());
 
  int oldrtmo;
  int optlen = sizeof (int);
  getsockopt (sl->handle, SOL_SOCKET, SO_RCVTIMEO, (char*)&oldrtmo, &optlen);
  wp_sec *= 1000;
  setsockopt (sl->handle, SOL_SOCKET, SO_RCVTIMEO, (char*)&wp_sec, optlen);
  return oldrtmo / 1000;
}
 
inline int sock::recvtimeout () const
{
  if (!sl || sl->handle == INVALID_SOCKET)
    return erc (WSAENOTSOCK, Errors());
 
  int oldrtmo;
  int optlen = sizeof (int);
  getsockopt (sl->handle, SOL_SOCKET, SO_RCVTIMEO, (char*)&oldrtmo, &optlen);
  return oldrtmo / 1000;
}
 
inline int sock::getopt (int op, void* buf, int len, int level) const
{
  if (!sl || sl->handle == INVALID_SOCKET)
    return erc (WSAENOTSOCK, Errors());
 
  int 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 != FALSE);
}
 
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 != FALSE);
}
 
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 != FALSE);
}
 
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 != FALSE);
}
 
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 != FALSE);
}
 
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 != FALSE);
}
 
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 ();
}
 
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;
}
 
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 erc sock::last_error ()
{
  int code = WSAGetLastError ();
  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