Network.h

Go to the documentation of this file.

 
 
#ifndef Network_h
#define Network_h
 
#include <sys/types.h>
#if IBM
#include <winsock2.h>
#include <ws2ipdef.h>           // required for sockaddr_in6 (?)
#include <iphlpapi.h>           // for GetAdaptersAddresses
#include <ws2tcpip.h>           // for socklen_t
#include <mswsock.h>            // for LPFN_WSARECVMSG 
#else
#define __APPLE_USE_RFC_3542    // both required for newer constants like IPV6_RECVPKTINFO
#define _GNU_SOURCE
#include <sys/socket.h>
#include <netdb.h>
#include <ifaddrs.h>
typedef int SOCKET;             
constexpr SOCKET INVALID_SOCKET = -1;
#endif
 
#include <stdexcept>
 
namespace XPMP2 {
 
struct XPMP2_EXPORT SockAddrTy
{
    union {
        sockaddr        sa;             // unspecific
        sockaddr_in     sa_in;          // AF_INET  / IPv4
        sockaddr_in6    sa_in6;         // AF_INET6 / IPv6
    };
    
    SockAddrTy() { memset((void*)this, 0, sizeof(SockAddrTy)); }
    SockAddrTy (const sockaddr* pSa);
    
    bool operator< (const SockAddrTy& o) const
    { return std::memcmp(this, &o, sizeof(*this)) < 0; }
    bool operator== (const SockAddrTy& o) const
    { return std::memcmp(this, &o, sizeof(*this)) == 0; }
 
    uint8_t family() const { return (uint8_t) sa.sa_family; }      
    bool isIp4() const { return family() == AF_INET; }                  
    bool isIp6() const { return family() == AF_INET6; }                 
    socklen_t size () const                                             
    { return
        sa.sa_family == AF_INET     ? sizeof(sa_in) :
        sa.sa_family == AF_INET6    ? sizeof(sa_in6) : sizeof(sa); }
    
    uint16_t port () const {
        return ntohs(isIp4() ? sa_in.sin_port :
                     isIp6() ? sa_in6.sin6_port : 0);
    }
    void setPort (uint16_t port) {
        if (isIp4())        sa_in.sin_port      = htons(port);
        else if (isIp6())   sa_in6.sin6_port    = htons(port);
    }
};
 
class XPMP2_EXPORT NetRuntimeError : public std::runtime_error
{
public:
    std::string errTxt;             
    std::string fullWhat;           
    NetRuntimeError(const std::string& w); 
    const char* what() const noexcept override { return fullWhat.c_str(); }
};
 
class XPMP2_EXPORT SocketNetworking
{
protected:
    SOCKET              f_socket        = INVALID_SOCKET;
    int                 f_port          = 0;
    std::string         f_addr;
    
    // the data receive buffer
    char*               buf             = NULL;
    size_t              bufSize         = 512;
 
#if IBM
    LPFN_WSARECVMSG     pWSARecvMsg     = nullptr;
#endif
public:
    SocketNetworking() {}
    virtual ~SocketNetworking();
 
    virtual void Open(const std::string& _addr, int _port, size_t _bufSize = 512,
                      unsigned _timeOut_ms = 0, bool _bBroadcast = false);
    virtual void Connect(const std::string& _addr, int _port, size_t _bufSize,
                         unsigned _timeOut_ms = 0);
    virtual void Close();
    inline bool isOpen() const { return (f_socket != INVALID_SOCKET); }
    void SetBufSize (size_t _bufSize);
    static std::string GetLastErr();
    
    // attribute access
    SOCKET       getSocket() const   { return f_socket; }   
    int          getPort() const     { return f_port; }     
    std::string  getAddr() const     { return f_addr; }     
 
    const char* getBuf () const  { return buf ? buf : ""; }
    
    void setBlocking (bool bBlock);
    
    long                recv(std::string* _pFromAddr = nullptr,
                             SockAddrTy* _pFromSockAddr = nullptr);
    long                timedRecv(int max_wait_ms,
                                  std::string* _pFromAddr = nullptr,
                                  SockAddrTy* _pFromSockAddr = nullptr);
    
    virtual bool send(const char* msg);
 
    bool broadcast (const char* msg);
    
    static std::string GetAddrString (const SockAddrTy& sa, bool withPort = true);
    
protected:
    virtual void GetAddrHints (struct addrinfo& hints) = 0;
#if IBM
    int WSARecvMsg(
        LPWSAMSG lpMsg,
        LPDWORD lpdwNumberOfBytesRecvd,
        LPWSAOVERLAPPED lpOverlapped,
        LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
#endif
};
 
 
class XPMP2_EXPORT UDPReceiver : public SocketNetworking
{
public:
    UDPReceiver() : SocketNetworking() {}
 
protected:
    void GetAddrHints (struct addrinfo& hints) override;
};
 
 
class XPMP2_EXPORT UDPMulticast : public SocketNetworking
{
protected:
    std::string multicastAddr;          
    struct addrinfo* pMCAddr = nullptr; 
    
    bool bSendToAll = true;             
    uint32_t oneIntfIdx = 0;            
    
    std::map<SockAddrTy,std::chrono::time_point<std::chrono::steady_clock> > mapSender;
 
public:
    UDPMulticast() : SocketNetworking() {}
    UDPMulticast(const std::string& _multicastAddr, int _port,
                 const std::string& _sendIntf,
                 int _ttl=8, size_t _bufSize = 512, unsigned _timeOut_ms = 0);
    ~UDPMulticast() override;
    
    const std::string& GetMCAddr() const { return multicastAddr; }
    
    void Join (const std::string& _multicastAddr, int _port,
               const std::string& _sendIntf,
               int _ttl=8, size_t _bufSize = 512, unsigned _timeOut_ms = 0);
    
    uint8_t GetFamily () const { return pMCAddr ? (uint8_t)pMCAddr->ai_family : AF_UNSPEC; }
    bool IsIPv4 () const { return GetFamily() == AF_INET; }     
    bool IsIPv6 () const { return GetFamily() == AF_INET6; }    
    
    void SendToDefault ();
    void SendToAll ();
    void SendToIntf (uint32_t idx);
 
    size_t SendMC (const void* _bufSend, size_t _bufSendSize);
    
    size_t RecvMC (bool bSwitchToRecvIntf,
                   std::string* _pFromAddr  = nullptr,
                   SockAddrTy* _pFromSockAddr = nullptr,
                   bool* _pbIntfChanged = nullptr);
 
protected:
    void Cleanup ();                    
    void GetAddrHints (struct addrinfo& hints) override;
    void SetSendInterface (const in_addr& addr);
    void SetSendInterface (uint32_t ifIdx);
};
 
 
class XPMP2_EXPORT TCPConnection : public SocketNetworking
{
protected:
    SOCKET              f_session_socket = INVALID_SOCKET;  
    struct sockaddr_in  f_session_addr = {};                
#if APL == 1 || LIN == 1
    SOCKET selfPipe[2] = { INVALID_SOCKET, INVALID_SOCKET };
#endif
 
public:
    TCPConnection() : SocketNetworking() {}
    
    void Close() override;                      
    void CloseListenerOnly();                   
 
    void listen (int numConnections = 1);       
    bool accept (bool bUnlisten = false);       
    bool listenAccept (int numConnections = 1); 
    
    bool IsConnected () const { return f_session_socket != INVALID_SOCKET; };
    
    bool send(const char* msg) override;
 
protected:
    void GetAddrHints (struct addrinfo& hints) override;
};
 
 
struct XPMP2_EXPORT InetAddrTy {
    union {
        std::uint32_t   addr[4] = {0,0,0,0};
        struct in_addr  in_addr;
        struct in6_addr in6_addr;
    };
    
    InetAddrTy () {}
    InetAddrTy (const SockAddrTy& sa) { CopyFrom(sa); }
    InetAddrTy (const sockaddr* pSa) { CopyFrom(SockAddrTy(pSa)); }
 
    void CopyFrom (const SockAddrTy& sa);
 
    bool operator==(const InetAddrTy& o) const
    { return std::memcmp(this, &o, sizeof(*this)) == 0; }
    
    bool operator<(const InetAddrTy& o) const
    { return std::memcmp(this, &o, sizeof(*this)) < 0; }
 
};
 
bool XPMP2_EXPORT NetwIsLocalAddr (const InetAddrTy& addr);
inline bool NetwIsLocalAddr (const SockAddrTy& sa)
{ return NetwIsLocalAddr(InetAddrTy(sa)); }
inline bool NetwIsLocalAddr (const sockaddr* pSa)
{ return NetwIsLocalAddr(InetAddrTy(pSa)); }
 
std::vector<std::string> XPMP2_EXPORT NetwGetInterfaces (uint8_t family, uint32_t fMust = 0, uint32_t fSkip = 0);
std::string XPMP2_EXPORT NetwGetInterfaceNames (uint8_t family, uint32_t fMust = 0, uint32_t fSkip = 0);
 
} // namespace XPMP2
 
#endif /* Network_h */