Connection.h

#pragma once
 
#if !defined( EMSCRIPTEN )
 
#include "Address.h"
#include "../Platform/Atomic.h"
 
#if defined( _WIN32 )
  #include <WinSock2.h>
#else
  #include <sys/socket.h>
#endif
 
namespace Cogs {
 
  namespace Network {
#if defined( _WIN32 )
    typedef SOCKET          Socket;
    typedef int             SocketType;
    typedef IPPROTO         IPProto;
    #define InvalidSocket   INVALID_SOCKET
#else
    typedef int             Socket;
    typedef int             SocketType;
    typedef int             IPProto;
    #define InvalidSocket   (-1)
#endif
 
    /*
     * Connection
     */
    class COGSFOUNDATION_API ConnectionBase{
    public:
      ConnectionBase() { }
      virtual ~ConnectionBase() { }
 
      Family family() const { return AF_INET; } // Only IPv4 for now
      virtual SocketType type() const = 0;
      virtual IPProto proto() const = 0;
 
      Socket getSocket() const { return socket; }
 
      void remove() { flags |= cRemove; }
      void removeAndDelete() { flags |= cRemove | cDelete; }
 
      const SockaddrIn& getAddress() const { return sockAddr; }
      int64_t getReconnectTime() const { return reconnectTime; }
 
      virtual bool isAutoConnectEnabled() const { return false; }
      virtual bool isConnected() const { return (socket != InvalidSocket); }
      bool shouldRemove() const { return flags & cRemove; }
      bool shouldDelete() const { return flags & cDelete; }
 
      void setNonblocking(bool val = true);
      void setDoNotProcess() { flags |= cDoNotProcess; }
 
      virtual bool reconnect() { return false; }
      virtual bool disconnect() = 0;
 
      bool bind(uint16_t port) { return bind(AddrIn((uint32_t)INADDR_ANY), port); }
      virtual bool bind(AddrIn ip, uint16_t port);
 
      bool send(const void* data, uint64_t byteCount, uint64_t& bytesSent);
      bool receive(void* buffer, uint64_t byteCount, uint64_t& bytesReceived);
 
      bool sendTo(const void *data, uint64_t byteCount, uint64_t &bytesSent, const SockaddrIn &addr);
      bool recvFrom(void* buffer, uint64_t byteCount, uint64_t& bytesReceived, SockaddrIn &addr);
 
      virtual bool processOutgoing() { return true; }
      virtual bool processIncoming() { return true; }
 
    protected:
      void create();
      void close();
 
      Cogs::Atomic< uint32_t > flags = 0;
      int64_t reconnectTime = 0;
 
      static constexpr uint32_t cRemove         = 0x00000001;
      static constexpr uint32_t cDelete         = 0x00000002;
      static constexpr uint32_t cDoNotProcess   = 0x00000004;   // Do not process this connection.
      // Bits 16-31 available for connection-derived types...
 
      Socket socket = InvalidSocket;
      SockaddrIn sockAddr = {};
    };
 
    /*
     * UDP Connection
     */
    class COGSFOUNDATION_API ConnectionUDP : public ConnectionBase {
    public:
      ConnectionUDP() = default;
      ~ConnectionUDP();
 
      SocketType type() const override { return SOCK_DGRAM; }
      IPProto proto() const override { return IPPROTO_UDP; }
 
      void setMulticastAdapter(const AddrIn& addr)    { multicastAdapter = addr; }
 
      virtual bool bind(AddrIn ip, uint16_t port) override;
      virtual bool disconnect() override;
 
    private:
      AddrIn  multicastAdapter;
    };
 
    /*
     * TCP Connection
     */
    class COGSFOUNDATION_API ConnectionTCP : public ConnectionBase {
    public:
      ConnectionTCP() { flags = cNoDelay; }
      ConnectionTCP(Socket socket, const SockaddrIn& addr);
      virtual ~ConnectionTCP();
 
      SocketType type() const override { return SOCK_STREAM; }
      IPProto proto() const override { return IPPROTO_TCP; }
 
              void  enableAutoReconnect()                   { flags |= cAutoReconnect; }
              void  disableAutoReconnect()                  { flags &= ~cAutoReconnect; }
      virtual bool  isAutoConnectEnabled() const override   { return (flags & cAutoReconnect) ? true : false; }
      virtual bool  isConnected() const override            { return (flags & (cConnected | cListening)) ? true : false; }
 
      void setConnectTimeout(int64_t milliseconds)          { connectTimeout = milliseconds; }
      void setNoDelay(bool val = true);
      void shutdown();
 
      virtual bool connect(const SockaddrIn& addr);
      virtual bool reconnect() override;
      virtual bool disconnect() override;
 
      bool listen(uint16_t port) { return listen(AddrIn((uint32_t)INADDR_ANY), port); }
      bool listen(AddrIn ip, uint16_t port);
 
      virtual bool processIncoming() override;
 
      virtual ConnectionTCP* accept(Socket /*socket*/, const SockaddrIn& /*remoteaddr*/) { return nullptr; }
 
    private:
      // Bits 0-15 reserved for ConnectionBase...
      static constexpr uint32_t cListening      = 0x00010000;
      static constexpr uint32_t cAutoReconnect  = 0x00020000;
      static constexpr uint32_t cNoDelay        = 0x00040000;
      static constexpr uint32_t cConnected      = 0x00080000;
 
      int64_t connectTimeout = 0;
    };
  }
}
 
#endif