cNetHost.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cNetHost_H
#define _INC_cNetHost_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cNetSystem.h"
#include "GrayCore/include/cString.h"
#include "GrayCore/include/cTypes.h"
 
#ifndef __linux__       
typedef short sa_family_t;      
#endif
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cNetHost);
 
#if defined(_WINDLL) || defined(USE_64BIT) || defined(__linux__) || (defined(_MSC_VER) && ( _MSC_VER >= 1600 ))
#define USE_WINSOCK2_ADDR       // addrinfo,ADDRINFO doesn't work for Win2000 ? used for multiple resolutions on a single hostname.
#endif
 
        class GRAYLIB_LINK cNetMacAddr
        {
 
        public:
                static const size_t k_SIZE_M48 = 6;     
                static const size_t k_SIZE_E48 = 6;     
                static const size_t k_SIZE_E64 = 8;     
                static const size_t k_SIZE_MAX = 8;
 
                BYTE m_bAddr[k_SIZE_MAX];       
 
        public:
                cNetMacAddr() noexcept
                {
                        cMem::Zero(m_bAddr, sizeof(m_bAddr));
                }
                cNetMacAddr(const cNetMacAddr& mac) noexcept
                {
                        ::memcpy(m_bAddr, mac.m_bAddr, sizeof(m_bAddr));
                }
                cNetMacAddr(const char* pszMac)
                {
                        put_MacStr(pszMac);
                }
 
                cStringA get_MacStr() const;
                bool put_MacStr(const char* pszMac);
                HRESULT SetMacAddrFromAdapter(sa_family_t nAddressFamily = AF_INET, int nAdapterIndex = 0);
        };
 
        class GRAYLIB_LINK cNetHost4
        {
 
        public:
#ifdef USE_LITTLE_ENDIAN
                static const UINT32 k_LOOPBACK_N = 0x0100007f; 
#else
                static const UINT32 k_LOOPBACK_N = 0x7F000001; 
#endif
                static const UINT32 k_BROADCAST = 0xFFFFFFFF;   
 
        protected:
                in_addr m_ipa4; 
 
        public:
                cNetHost4() noexcept
                {
                        m_ipa4.s_addr = INADDR_ANY;
                }
                explicit cNetHost4(UINT uIP4) noexcept
                {
                        m_ipa4.s_addr = cMemT::HtoN(uIP4);
                }
                cNetHost4(const in_addr& ip) noexcept
                : m_ipa4(ip)
                {
                }
                cNetHost4(const char* pszIP)
                {
                        put_HostStr(pszIP);
                }
 
                //********************************
 
                bool isHostValid() const noexcept
                {
                        return m_ipa4.s_addr != INADDR_ANY;
                }
                bool isHostLoopback() const noexcept
                {
                        return m_ipa4.s_addr == k_LOOPBACK_N; // cMemT::HtoN(INADDR_LOOPBACK)
                }
                bool isHostBroadcast() const noexcept
                {
                        return m_ipa4.s_addr == k_BROADCAST;
                }
                bool isHostPrivate() const
                {
                        UINT32 ip4h = get_HostIp4_H();  // host order.
                        BYTE bClassB;
                        switch ((ip4h & IN_CLASSA_NET) >> IN_CLASSA_NSHIFT)
                        {
                        case 0: // 0.* - INADDR_ANY
                                if (ip4h == 0)
                                        return true;
                                break;
                        case 10: // 10.0.0.0 - 10.255.255.255  class A
                                return true;
                        case 127:       // INADDR_LOOPBACK
                                if (ip4h == INADDR_LOOPBACK)
                                        return true;
                                break;
                        case 172: // 172.16.0.0 - 172.31.255.255  class B
                                bClassB = (BYTE)((ip4h >> IN_CLASSB_NSHIFT) & 0xFF);
                                if (bClassB >= 16 && bClassB <= 31)
                                        return true;
                                break;
                        case 192: // 192.168.0.0 - 192.168.255.255 class C
                                bClassB = (BYTE)((ip4h >> IN_CLASSB_NSHIFT) & 0xFF);
                                if (bClassB == 168)
                                        return true;
                                break;
                        case 255: // 255.255.255.255 = INADDR_BROADCAST
                                if (ip4h == INADDR_BROADCAST)
                                        return true;
                                break;
                        }
                        return false;
                }
                bool isHostLocalTo(const cNetHost4& ip, UINT32 dwMask = 0xFFFFFF00) const noexcept
                {
                        UINT32 dwMaskN = cMemT::HtoN(dwMask);   // to network order
                        return (m_ipa4.s_addr & dwMaskN) == (ip.m_ipa4.s_addr & dwMaskN);
                }
                bool operator == (cNetHost4 ip) const noexcept
                {
                        return m_ipa4.s_addr == ip.m_ipa4.s_addr;
                }
                void SetEmptyHostAddr() noexcept
                {
                        m_ipa4.s_addr = INADDR_NONE;
                }
 
                //********************************
 
                operator in_addr() const noexcept
                {
                        return m_ipa4;
                }
                BYTE GetByte(int i = 0) const
                {
                        ASSERT(IS_INDEX_GOOD(i, 4));
                        return ((const BYTE*)&m_ipa4.s_addr)[i];
                }
                in_addr get_HostIp4() const noexcept
                {
                        return m_ipa4;
                }
                UINT32 get_HostIp4_H() const noexcept
                {
                        return cMemT::NtoH(m_ipa4.s_addr);
                }
                void put_HostIp4(in_addr addr4) noexcept
                {
                        m_ipa4 = addr4;
                }
                void put_HostIp4_H(UINT32 uIP4) noexcept
                {
                        m_ipa4.s_addr = cMemT::HtoN(uIP4);
                }
                void put_HostLoopback() noexcept
                {
                        m_ipa4.s_addr = k_LOOPBACK_N; // cMemT::HtoN(INADDR_LOOPBACK);
                }
                HASHCODE32_t get_HashCode() const noexcept
                {
                        return (HASHCODE32_t)get_HostIp4_H();
                }
 
                //********************************
 
                cStringA get_HostStr() const;
                HRESULT put_HostStr(const char* pszIP);
                static StrLen_t GRAYCALL GetIP4Format(const char* pszIP, bool bTerm = true);
 
                static const in_addr k_AddrNull;                
                static const in_addr k_AddrBroadcast;   
 
                UNITTEST_FRIEND(cNetHost);
        };
 
        class GRAYLIB_LINK cNetHost6
        {
 
        public:
                static const in6_addr k_AddrNull; 
        protected:
                in6_addr m_ipa6;        
 
        public:
                cNetHost6() noexcept
                {
                        cMem::Zero(&m_ipa6, sizeof(m_ipa6));    // IN6ADDR_ANY_INIT
                }
                cNetHost6(const in6_addr& ip) noexcept
                        : m_ipa6(ip)
                {
                }
                cNetHost6(const in_addr& ip)
                {
                        cUnion32* pU = (cUnion32*)&m_ipa6;
                        pU[0].u_dw = 0;
                        pU[1].u_dw = 0;
                        pU[2].u_dw = 0xFFFF0000;        // assume USE_LITTLE_ENDIAN
                        pU[3].u_dw = ip.s_addr;
                        ASSERT(isHostIP4());
                }
                cNetHost6(const char* pszIP)
                {
                        put_HostStr(pszIP);
                }
                void SetEmptyHostAddr() noexcept
                {
                        cMem::Zero(&m_ipa6, sizeof(m_ipa6));
                }
 
                bool isHostValid() const;
                bool isHostLoopback() const;
                bool isHostPrivate() const;
                bool isHostIP4() const;
 
                static StrLen_t GRAYCALL GetIP6Format(const char* pszIP, bool bTerm = true);
 
                HRESULT put_HostStr(const char* pszIP);
                cStringA get_HostStr() const;
 
                operator in6_addr() const noexcept
                {
                        return m_ipa6;
                }
                const in6_addr& get_HostIp6() const noexcept
                {
                        return m_ipa6 ;
                }
                HASHCODE_t get_HashCode() const noexcept;
 
                bool operator == (const in6_addr& ip) const noexcept
                {
                        return !::memcmp(&m_ipa6, &ip, sizeof(m_ipa6));
                }
        };
}
#endif // _INC_cNetHost_H