cNetAddr.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cNetAddr_H
#define _INC_cNetAddr_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cNetHost.h"
#include "cNetPort.h"
#include "GrayCore/include/cLogMgr.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cMem.h"
#include "GrayCore/include/cNewPtr.h"
#include "GrayCore/include/cArray.h"
 
#ifdef _WIN32
typedef int socklen_t;
#endif
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cNetAddress);
 
        class GRAYLIB_LINK cNetAddress
        {
 
        private:
                socklen_t m_nSockAddrLen;       
                union   // sizeof(sockaddr)==16, sizeof(sockaddr_in6) == 28 bytes
                {
                        sockaddr m_SockAddr;            
                        sockaddr_in m_SockAddr4;        
                        sockaddr_in6 m_SockAddr6;       
                } m_u;
 
        protected:
                const in_addr& ref_HostIp4() const
                {
                        ASSERT(get_Family() == AF_INET);
                        return m_u.m_SockAddr4.sin_addr;
                }
                in_addr& ref_HostIp4()
                {
                        ASSERT(get_Family() == AF_INET);
                        return m_u.m_SockAddr4.sin_addr;
                }
                const in6_addr& ref_HostIp6() const
                {
                        ASSERT(get_Family() == AF_INET6);
                        return m_u.m_SockAddr6.sin6_addr;
                }
                in6_addr& ref_HostIp6()
                {
                        ASSERT(get_Family() == AF_INET6);
                        return m_u.m_SockAddr6.sin6_addr;
                }
 
        public:
                cNetAddress() noexcept
                        : m_nSockAddrLen(sizeof(m_u))
                {
                        cMem::Zero(&m_u, sizeof(m_u));
                        DEBUG_ASSERT(!isAddrValid(), "cNetAddress");
                }
                cNetAddress(sa_family_t nFamily, NET_PORT_t wPort = k_NET_PORT_INVALID) noexcept
                        : m_nSockAddrLen(sizeof(m_u))
                {
                        cMem::Zero(&m_u, sizeof(m_u));
                        m_u.m_SockAddr.sa_family = nFamily;
                        m_u.m_SockAddr4.sin_port = cMemT::HtoN(wPort);
                }
                cNetAddress(in_addr ip, NET_PORT_t wPort = k_NET_PORT_INVALID) noexcept
                        : m_nSockAddrLen(sizeof(m_u))
                {
                        cMem::Zero(&m_u, sizeof(m_u));
                        m_u.m_SockAddr.sa_family = AF_INET;
                        m_u.m_SockAddr4.sin_port = cMemT::HtoN(wPort);
                        m_u.m_SockAddr4.sin_addr = ip;
                }
                cNetAddress(const char* pszAddr, bool bWait = false)
                        : m_nSockAddrLen(sizeof(m_u))
                {
                        cMem::Zero(&m_u, sizeof(m_u));
                        // nFamily = AF_UNSPEC; // AF_INET, AF_INET6, etc
                        // wPort = k_NET_PORT_INVALID;
                        put_AddrStr(pszAddr, bWait);
                }
                cNetAddress(const char* pszAddr, NET_PORT_t wPortDefault, bool bWait = false)
                        : m_nSockAddrLen(sizeof(m_u))
                {
                        cMem::Zero(&m_u, sizeof(m_u));
                        m_u.m_SockAddr4.sin_port = cMemT::HtoN(wPortDefault);   // Set the default port first. (if not also set in the string)
                        put_AddrStr(pszAddr, bWait);
                }
 
                sa_family_t get_Family() const noexcept
                {
                        return m_u.m_SockAddr.sa_family;
                }
                socklen_t get_AddrLen() const noexcept
                {
                        return m_nSockAddrLen;
                }
                socklen_t& ref_AddrLen() noexcept
                {
                        return m_nSockAddrLen;
                }
                const sockaddr& get_Addr() const noexcept
                {
                        return (sockaddr&)m_u.m_SockAddr;
                }
                const sockaddr& ref_Addr() const noexcept
                {
                        return (sockaddr&)m_u.m_SockAddr;
                }
                sockaddr& ref_Addr() noexcept
                {
                        return (sockaddr&)m_u.m_SockAddr;
                }
 
                bool isAddrValid() const;
                void ResetAddr() noexcept
                {
                        m_nSockAddrLen = sizeof(m_u);
                        // sa_family = AF_UNSPEC;
                        // sin_port = k_NET_PORT_INVALID;
                        // sin_addr.s_addr = INADDR_NONE;       // invalid address
                        cMem::Zero(&m_u, sizeof(m_u));
                }
                COMPARE_t CompareAddr(const cNetAddress& SocketAddr) const
                {
                        if (m_nSockAddrLen != SocketAddr.m_nSockAddrLen)
                        {
                                return m_nSockAddrLen - SocketAddr.m_nSockAddrLen;
                        }
                        ASSERT((size_t)m_nSockAddrLen <= sizeof(m_u));
                        COMPARE_t iRet = ::memcmp(&m_u, &SocketAddr.m_u, m_nSockAddrLen);
                        if (iRet != COMPARE_Equal)
                        {
                                return iRet;
                        }
                        return COMPARE_Equal;
                }
                bool operator == (const cNetAddress& SocketAddr) const
                {
                        return(CompareAddr(SocketAddr) == COMPARE_Equal);
                }
                bool operator != (const cNetAddress& SocketAddr) const
                {
                        return(CompareAddr(SocketAddr) != COMPARE_Equal);
                }
 
                HASHCODE_t get_HashCodeHost() const noexcept;
                HASHCODE_t get_HashCode() const noexcept
                {
                        return get_HashCodeHost();
                }
 
                //********************************
                // Isolate the port part of the address
 
                NET_PORT_t get_PortNumber() const noexcept
                {
                        return cMemT::NtoH(m_u.m_SockAddr4.sin_port);
                }
                void put_PortNumber(NET_PORT_t wPort)
                {
                        m_u.m_SockAddr4.sin_port = cMemT::HtoN(wPort);
                }
                bool isPortValid() const
                {
                        return(m_u.m_SockAddr4.sin_port != k_NET_PORT_INVALID);
                }
                static char* GRAYCALL FindPortExtPtr(const char* pszAddr);
                bool put_PortServiceName(const char* pszPortServiceName);
                cStringA get_PortServiceName() const;
 
                //********************************
                // Isolate the host part of the address. depends on family type.
 
                const BYTE* get_HostPtr() const
                {
                        return (const BYTE*)&m_u.m_SockAddr4.sin_addr;
                }
                BYTE* ref_HostPtr() const
                {
                        return (BYTE*)&m_u.m_SockAddr4.sin_addr;
                }
                size_t get_HostLen() const
                {
                        return m_nSockAddrLen - (sizeof(sa_family_t) + sizeof(NET_PORT_t));
                }
 
                bool isHostLoopback() const;
                bool isHostPrivate() const;
                bool put_HostLoopback(sa_family_t nFamily = AF_UNSPEC);
 
                COMPARE_t CompareHost(const cNetAddress& SocketAddr) const;
 
                HRESULT SetHostStr(const char* pszHost, bool bWait = false);
                HRESULT SetHostStrFix(const char* pszAddr, bool bWait = false);
                cStringA get_HostStr() const;
 
                cNetHost4 get_HostIp4() const;
                void put_HostIp4(in_addr nIP)
                {
                        m_nSockAddrLen = sizeof(m_u.m_SockAddr4);
                        m_u.m_SockAddr4.sin_family = AF_INET;
                        ref_HostIp4() = nIP;
                }
                cNetHost6 get_HostIp6() const;
                void put_HostIp6(const in6_addr& addr)
                {
                        m_nSockAddrLen = sizeof(m_u.m_SockAddr6);
                        m_u.m_SockAddr6.sin6_family = AF_INET6;
                        ref_HostIp6() = addr;
                }
                bool SetHostData(sa_family_t nFamily, const void* pHostData, size_t nDataSize = sizeof(in_addr));
                void ResetHost()
                {
                        NET_PORT_t wPort = get_PortNumber();
                        ResetAddr();
                        put_PortNumber(wPort);
                }
 
                //********************************
 
                void put_Addr(const cNetAddress& rAddr)
                {
                        *this = rAddr;
                }
                bool SetAddrData(const sockaddr* pSockAddr, socklen_t nSockAddrLen);
 
                cStringA get_AddrStr() const;
                HRESULT put_AddrStr(const char* pszAddr, bool bWait = false);
 
                //*****************************
 
                HRESULT SerializeOutput(cStreamOutput& rout);
                HRESULT SerializeInput(cStreamInput& file);
 
                UNITTEST_FRIEND(cNetAddress);
        };
 
        typedef cArrayStruct<cNetAddress> cNetAddressArray;
 
};
#endif // _INC_cNetAddr_H