Socket.h

Go to the documentation of this file.

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
 
/* The MIT License:
 
Copyright (c) 2008 Ivan Gagis
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE. */
 
// (c) Ivan Gagis 2008
// e-mail: igagis\gmail.com
 
// Description:
//          cross platform C++ Sockets wrapper
//
 
 
#pragma once
 
#ifdef _MSC_VER
# pragma  warning( disable : 4290)
# pragma warning( disable: 4275 )  //  warning C4275: non dll-interface class
#endif
 
 
#include <exception>
#include <stdexcept>
#include <new>
#include <agxNet/FramePacket.h>
#include <agx/stdint.h>
#include <agx/agxCore_export.h>
#include <agx/Singleton.h>
#include <agx/Referenced.h>
#include <agx/Vector.h>
#include <agx/String.h>
#include <iosfwd>
 
namespace agxNet{
 
  //forward declarations
  class SocketSet;
  class IPAddress;
  class Socket;
 
  class AGXCORE_EXPORT NetError : public std::runtime_error {
  public:
    NetError(const char* message) : std::runtime_error(message), m_socket(nullptr) {}
    NetError(Socket *socket) : std::runtime_error("Connection closed"), m_socket(socket) {}
    NetError(const char* message, Socket* socket) : std::runtime_error(message), m_socket(socket) {}
 
    virtual ~NetError() throw() {}
 
    Socket *getSocket() { return m_socket; }
  private:
    Socket *m_socket;
  };
 
  class AGXCORE_EXPORT TimeoutConnectError : public NetError {
  public:
    TimeoutConnectError(const char* message) : NetError(message) {}
    virtual ~TimeoutConnectError() noexcept {}
  };
 
  agx::UInt16 AGXCORE_EXPORT getAvailablePort();
 
  class AGXCORE_EXPORT IPAddress
  {
  public:
 
    IPAddress();
 
    inline IPAddress(agx::UInt32 h, agx::UInt16 p) :
    m_host(h),
      m_port(p)
    {}
 
    inline IPAddress(agx::UInt8 h1, agx::UInt8 h2, agx::UInt8 h3, agx::UInt8 h4, agx::UInt16 p) :
    m_host(agx::UInt32(h1) + (agx::UInt32(h2)<<8) + (agx::UInt32(h3)<<16) + (agx::UInt32(h4)<<24)),
      m_port(p)
    {
    }
 
    IPAddress(const agx::String& ip, agx::UInt16 p);
 
    inline bool operator==(const IPAddress& ip){
      return (this->m_host == ip.m_host) && (this->m_port == ip.m_port);
    }
 
    const agx::UInt32& host() const { return m_host; }
 
    agx::UInt32& host() { return m_host; }
 
    const agx::UInt16& port() const { return m_port; }
 
    agx::UInt16& port() { return m_port; }
 
    agx::String string() const;
  private:
    //parse IP address from string
    static agx::UInt32 parseString(const char* ip);
 
    agx::UInt32 m_host;
    agx::UInt16 m_port;
 
  };
 
  std::ostream& operator<<(std::ostream& stream, const IPAddress& adr);
 
  class AGXCORE_EXPORT Library : public agx::Singleton {
 
  public:
    Library();
 
    static Library *instance();
 
    virtual void shutdown() override;
 
    IPAddress getHostByName(const char *hostName, agx::UInt16 port);
 
    SINGLETON_CLASSNAME_METHOD();
 
  private:
 
    virtual ~Library();
 
    void initSockets();
    void deinitSockets();
 
    static Library *s_instance;
    bool m_initialized;
  };
 
  AGX_DECLARE_POINTER_TYPES(Socket);
  AGX_DECLARE_VECTOR_TYPES(Socket);
  class AGXCORE_EXPORT Socket : public agx::Referenced {
    friend class SocketSet;
 
  public:
    //this type will hold system specific socket handle.
    //this buffer should be large enough to hold socket handle in different systems.
    //sizeof(u64) looks enough so far (need to work on 64-bit platforms too).
#ifndef DOC_DONT_EXTRACT //direction to doxygen not to extract this class
    struct SystemIndependentSocketHandle{
      agx::UInt8 buffer[sizeof(uint64_t)]; 
    };
#endif//~DOC_DONT_EXTRACT
 
  public:
 
    bool isValid()const;
 
    void setBlocking(bool flag);
    bool isBlocking() const { return m_blocking; }
 
    inline bool isReady()const
    {
      return m_readyToReceive;
    }
 
    void select(agx::UInt32 timeoutMillis = 0);
 
    inline bool readyToReceive() const
    {
      return m_readyToReceive;
    }
 
    inline bool readyToSend() const
    {
      return m_readyToSend;
    }
 
    inline const IPAddress& adr() const { return m_adr; }
 
    void close();
 
    static int getLastError();
 
  protected:
 
    virtual ~Socket(){
      this->close();
    }
 
    Socket(const IPAddress& adr = IPAddress());
 
    Socket& operator=(const Socket& s);
 
  protected:
    // bool m_isReady;
    bool m_readyToReceive;
    bool m_readyToSend;
    bool m_blocking;
    IPAddress m_adr;
 
    SystemIndependentSocketHandle m_socket;
  };
 
 
  AGX_DECLARE_POINTER_TYPES(TCPSocket);
  AGX_DECLARE_VECTOR_TYPES(TCPSocket);
  class AGXCORE_EXPORT TCPSocket : public Socket {
    friend class TCPServerSocket;
  public:
    TCPSocket() {}
 
    //copy constructor
    TCPSocket(const TCPSocket& s, const IPAddress& adr = IPAddress()) : Socket(adr) {
      //NOTE: that operator= calls destructor, so this->socket should be invalid, base class constructor takes care about it.
      this->operator=(s);//same as auto_ptr
    }
 
    TCPSocket(const IPAddress& ip, bool disableNaggle = false) : Socket(ip) {
      this->open(ip, disableNaggle);
    }
 
    TCPSocket& operator=(const TCPSocket& s){
      this->Socket::operator=(s);
      return *this;
    }
 
    void open(const IPAddress& ip, bool disableNaggle = false);
 
    agx::UInt32 send(const agx::UInt8* data, agx::UInt32 size);
 
    //returns 0 if connection was closed by peer
    size_t recv(agx::UInt8* buf, size_t maxSize);
 
    void sendBlocking(const agx::UInt8 *data, agx::UInt32 size);
    void recvBlocking(agx::UInt8 *buf, agx::UInt32 size);
 
    void sendBlocking(const StructuredMessage *message);
 
  private:
    void disableNaggle();
  };
 
 
 
  AGX_DECLARE_POINTER_TYPES(TCPServerSocket);
  class AGXCORE_EXPORT TCPServerSocket : public Socket{
  public:
    TCPServerSocket() : m_disableNaggle(false) {}
 
    //copy constructor
    TCPServerSocket(const TCPServerSocket& s) : Socket(), m_disableNaggle(s.m_disableNaggle)
    {
      //NOTE: that operator= calls destructor, so this->socket should be invalid, base class constructor takes care about it.
      this->operator=(s);//same as auto_ptr
    }
 
    TCPServerSocket& operator=(const TCPServerSocket& s){
      this->Socket::operator=(s);
      return *this;
    }
 
    TCPServerSocket(agx::UInt16 port, bool disableNaggle = false){
      this->open(port, disableNaggle);
    }
 
    void open(agx::UInt16 port, bool disableNaggle = false);
 
    TCPSocket* accept();
  private:
    bool m_disableNaggle;//this flag indicates if accepted sockets should be created with disabled Naggle
 
  };
 
  AGX_DECLARE_POINTER_TYPES(UDPSocket);
  class AGXCORE_EXPORT UDPSocket : public Socket{
  public:
    UDPSocket(){}
 
    void open(agx::UInt16 port);
 
 
    inline void open(){
      this->open(0);
    }
 
    //returns number of bytes sent, should be less or equal to size.
    size_t send(const agx::UInt8* buf, agx::UInt16 size, IPAddress destinationIP);
 
    //returns number of bytes received, 0 if connection was gracefully closed (???).
    agx::UInt32 recv(agx::UInt8* buf, agx::UInt16 maxSize, IPAddress &out_SenderIP);
 
    protected:
      virtual ~UDPSocket(){
        this->close();
      }
  };
 
 
  AGX_DECLARE_POINTER_TYPES(SocketSet);
  class AGXCORE_EXPORT SocketSet : public agx::Referenced {
 
  public:
 
    SocketSet();
 
    inline size_t getNumSockets()const{return m_set.size(); }
 
    size_t getMaxSockets()const;
 
    bool addSocket(Socket *sock);
 
    bool removeSocket(Socket *sock);
 
    //This function checks to see if data is available for reading on the
    //given set of sockets.  If 'timeout' is 0, it performs a quick poll,
    //otherwise the function returns when either data is available for
    //reading, or the timeout in milliseconds has elapsed, which ever occurs
    //first.  This function returns true if there are any sockets ready for reading,
    //or false if there was an error with the select() system call.
    bool checkSockets(agx::UInt32 timeoutMillis);
 
    const SocketRefVector& getSockets() const { return m_set; }
 
  protected:
 
    virtual ~SocketSet(){
      m_set.clear();
    }
 
  private:
 
    SocketRefVector m_set;
 
  };
}