From 0e033cb755586fa9a0523a24fabb410d5d2ad97c Mon Sep 17 00:00:00 2001 From: Kawe Mazidjatari <48657826+Mauler125@users.noreply.github.com> Date: Sun, 29 Jan 2023 13:59:34 +0100 Subject: [PATCH] Reimplementation of CNetAdr This will replace 'CNetAdr2' and 'v_netadr_t'. The implementation is directly compatible with the structures in engine. --- r5dev/tier1/NetAdr.cpp | 461 ++++++++++++++--------------------------- r5dev/tier1/NetAdr.h | 71 ++----- 2 files changed, 172 insertions(+), 360 deletions(-) diff --git a/r5dev/tier1/NetAdr.cpp b/r5dev/tier1/NetAdr.cpp index 9010b74b..0961fa65 100644 --- a/r5dev/tier1/NetAdr.cpp +++ b/r5dev/tier1/NetAdr.cpp @@ -2,182 +2,71 @@ // // Purpose: implementation of the CNetAdr class. // -------------------------------------------------------------------------- -// -// NOTE: This implementation is considered deprecated. I rebuilded this -// not knowing that the engine supports IPv6 as well. I have fully rewritten -// this class in 'tier1/NetAdr2.cpp' in modern C++. Please use this instead. -// This class is for reference material only may some bits in the engine line -// up with this original 'CNetAdr' implementation. -// //===========================================================================// #include "core/stdafx.h" #include "tier1/netadr.h" #include "mathlib/swap.h" +#include "strtools.h" ////////////////////////////////////////////////////////////////////// -// Constructors +// Constructors. ////////////////////////////////////////////////////////////////////// -netadr_s::netadr_s(void) +CNetAdr::CNetAdr(void) { - SetIP(0); - SetPort(0); - SetType(netadrtype_t::NA_IP); + Clear(); } -netadr_s::netadr_s(std::uint32_t unIP, std::uint16_t usPort) -{ - SetIP(unIP); - SetPort(usPort); - SetType(netadrtype_t::NA_IP); -} -netadr_s::netadr_s(const char* pch) + +////////////////////////////////////////////////////////////////////// +// Constructors. +////////////////////////////////////////////////////////////////////// +CNetAdr::CNetAdr(const char* pch) { SetFromString(pch); } ////////////////////////////////////////////////////////////////////// -// +// Convert address to string. ////////////////////////////////////////////////////////////////////// -void netadr_t::SetFromSocket(int hSocket) -{ - Clear(); - type = netadrtype_t::NA_IP; - - struct sockaddr address{}; - socklen_t namelen = sizeof(address); - if (getsockname(hSocket, (struct sockaddr*)&address, &namelen) == 0) - { - SetFromSockadr(&address); - } -} - -////////////////////////////////////////////////////////////////////// -// Compares IP for equality -////////////////////////////////////////////////////////////////////// -bool netadr_t::CompareAdr(const netadr_t& a, bool onlyBase) const -{ - if (a.type != type) - { - return false; - } - - if (type == netadrtype_t::NA_LOOPBACK) - { - return true; - } - - if (type == netadrtype_t::NA_BROADCAST) - { - return true; - } - - if (type == netadrtype_t::NA_IP) - { - if (!onlyBase && (port != a.port)) - { - return false; - } - - if (a.ip[0] == ip[0] && a.ip[1] == ip[1] && a.ip[2] == ip[2] && a.ip[3] == ip[3]) - { - return true; - } - } - - return false; -} - -////////////////////////////////////////////////////////////////////// -// Compares Class-B IP for equality -////////////////////////////////////////////////////////////////////// -bool netadr_t::CompareClassBAdr(const netadr_t& a) const -{ - if (a.type != type) - { - return false; - } - - if (type == netadrtype_t::NA_LOOPBACK) - { - return true; - } - - if (type == netadrtype_t::NA_IP) - { - if (a.ip[0] == ip[0] && a.ip[1] == ip[1]) - { - return true; - } - } - - return false; -} - -////////////////////////////////////////////////////////////////////// -// Compares Class-C IP for equality -////////////////////////////////////////////////////////////////////// -bool netadr_t::CompareClassCAdr(const netadr_t& a) const -{ - if (a.type != type) - { - return false; - } - - if (type == netadrtype_t::NA_LOOPBACK) - { - return true; - } - - if (type == netadrtype_t::NA_IP) - { - if (a.ip[0] == ip[0] && a.ip[1] == ip[1] && a.ip[2] == ip[2]) - { - return true; - } - } - - return false; -} - -////////////////////////////////////////////////////////////////////// -// Convert address to string -////////////////////////////////////////////////////////////////////// -const char* netadr_t::ToString(bool onlyBase) const +const char* CNetAdr::ToString(bool bOnlyBase) const { // Select a static buffer. - static char s[4][64]{}; + static char s[4][128]{}; static int slot = 0; int useSlot = (slot++) % 4; // Render into it. - ToString(s[useSlot], sizeof(s[0]), onlyBase); + ToString(s[useSlot], sizeof(s[0]), bOnlyBase); // Pray the caller uses it before it gets clobbered. return s[useSlot]; } ////////////////////////////////////////////////////////////////////// -// Convert address to string +// Convert address to string. ////////////////////////////////////////////////////////////////////// -void netadr_t::ToString(char* pchBuffer, std::uint32_t unBufferSize, bool bOnlyBase) const +void CNetAdr::ToString(char* pchBuffer, size_t unBufferSize, bool bOnlyBase) const { - if (type == netadrtype_t::NA_LOOPBACK) + if (type == netadrtype_t::NA_NULL) { - memmove(pchBuffer, "loopback", unBufferSize); + strncpy(pchBuffer, "null", unBufferSize); } - else if (type == netadrtype_t::NA_BROADCAST) + else if (type == netadrtype_t::NA_LOOPBACK) { - memmove(pchBuffer, "broadcast", unBufferSize); + strncpy(pchBuffer, "loopback", unBufferSize); } else if (type == netadrtype_t::NA_IP) { + char pStringBuf[128]; + inet_ntop(AF_INET6, &adr, pStringBuf, INET6_ADDRSTRLEN); + if (bOnlyBase) { - snprintf(pchBuffer, unBufferSize, "%i.%i.%i.%i", ip[0], ip[1], ip[2], ip[3]); + snprintf(pchBuffer, unBufferSize, "%s", pStringBuf); } else { - snprintf(pchBuffer, unBufferSize, "%i.%i.%i.%i:%i", ip[0], ip[1], ip[2], ip[3], ntohs(port)); + snprintf(pchBuffer, unBufferSize, "[%s]:%i", pStringBuf, ntohs(port)); } } else @@ -187,46 +76,76 @@ void netadr_t::ToString(char* pchBuffer, std::uint32_t unBufferSize, bool bOnlyB } ////////////////////////////////////////////////////////////////////// -// Clears IP +// ////////////////////////////////////////////////////////////////////// -void netadr_t::Clear(void) +void CNetAdr::ToAdrinfo(addrinfo* pHint) const { - ip[0] = ip[1] = ip[2] = ip[3] = 0; + addrinfo hint{}; + hint.ai_flags = AI_PASSIVE; + hint.ai_family = AF_INET6; + hint.ai_socktype = SOCK_STREAM; + hint.ai_protocol = IPPROTO_TCP; + + char szBuffer[33]; + int results = getaddrinfo(ToString(true), _itoa(GetPort(), szBuffer, 10), &hint, &pHint); + + if (results != 0) + { + WCHAR* wszError = gai_strerror(results); + _bstr_t bStr(wszError); + const char* pszError = bStr; + + Warning(eDLL_T::ENGINE, "Address info translation failed: (%s)\n", pszError); + } +} + +////////////////////////////////////////////////////////////////////// +// Clears IP. +////////////////////////////////////////////////////////////////////// +void CNetAdr::Clear(void) +{ + adr = { 0 }; port = 0; + reliable = 0; type = netadrtype_t::NA_NULL; } ////////////////////////////////////////////////////////////////////// -// Sets IP +// Sets IP. ////////////////////////////////////////////////////////////////////// -void netadr_t::SetIP(std::uint8_t b1, std::uint8_t b2, std::uint8_t b3, std::uint8_t b4) +void CNetAdr::SetIP(IN6_ADDR* inAdr) { - ip[0] = b1; - ip[1] = b2; - ip[2] = b3; - ip[3] = b4; + adr = *inAdr; } ////////////////////////////////////////////////////////////////////// -// Sets IP +// Sets the port (must be network byte order, use 'htons' to flip). ////////////////////////////////////////////////////////////////////// -void netadr_t::SetIP(std::uint32_t unIP) +void CNetAdr::SetPort(std::uint16_t newport) { - *((std::uint32_t*)ip) = DWordSwapC(unIP); + port = newport; } ////////////////////////////////////////////////////////////////////// -// Sets type +// Returns the port in network byte order (use 'ntohs' to flip). ////////////////////////////////////////////////////////////////////// -void netadr_t::SetType(netadrtype_t newtype) +std::uint16_t CNetAdr::GetPort(void) const +{ + return port; +} + +////////////////////////////////////////////////////////////////////// +// Sets the address type. +////////////////////////////////////////////////////////////////////// +void CNetAdr::SetType(netadrtype_t newtype) { type = newtype; } ////////////////////////////////////////////////////////////////////// -// +// Returns the address type. ////////////////////////////////////////////////////////////////////// -netadrtype_t netadr_t::GetType(void) const +netadrtype_t CNetAdr::GetType(void) const { return type; } @@ -234,207 +153,127 @@ netadrtype_t netadr_t::GetType(void) const ////////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////////// -std::uint16_t netadr_t::GetPort(void) const +void CNetAdr::ToSockadr(struct sockaddr_storage* pSadr) const { - return WordSwapC(port); -} + memset(pSadr, NULL, sizeof(struct sockaddr)); -////////////////////////////////////////////////////////////////////// -// -////////////////////////////////////////////////////////////////////// -std::uint32_t netadr_t::GetIPNetworkByteOrder(void) const -{ - return *(std::uint32_t*)&ip; -} - -////////////////////////////////////////////////////////////////////// -// -////////////////////////////////////////////////////////////////////// -std::uint32_t netadr_t::GetIPHostByteOrder(void) const -{ - return DWordSwapC(GetIPNetworkByteOrder()); -} - -////////////////////////////////////////////////////////////////////// -// -////////////////////////////////////////////////////////////////////// -void netadr_t::ToSockadr(struct sockaddr* s) const -{ - memset(s, 0, sizeof(struct sockaddr)); - - if (type == netadrtype_t::NA_BROADCAST) + if (GetType() == netadrtype_t::NA_IP) { - ((struct sockaddr_in*)s)->sin_family = AF_INET; - ((struct sockaddr_in*)s)->sin_port = port; - ((struct sockaddr_in*)s)->sin_addr.s_addr = INADDR_BROADCAST; + reinterpret_cast(pSadr)->sin6_family = AF_INET6; + reinterpret_cast(pSadr)->sin6_port = port; + inet_pton(AF_INET6, ToString(true), &reinterpret_cast(pSadr)->sin6_addr); } - else if (type == netadrtype_t::NA_IP) + else if (GetType() == netadrtype_t::NA_LOOPBACK) { - ((struct sockaddr_in*)s)->sin_family = AF_INET; - ((struct sockaddr_in*)s)->sin_addr.s_addr = *(int*)&ip; - ((struct sockaddr_in*)s)->sin_port = port; - } - else if (type == netadrtype_t::NA_LOOPBACK) - { - ((struct sockaddr_in*)s)->sin_family = AF_INET; - ((struct sockaddr_in*)s)->sin_port = port; - ((struct sockaddr_in*)s)->sin_addr.s_addr = INADDR_LOOPBACK; + reinterpret_cast(pSadr)->sin6_family = AF_INET6; + reinterpret_cast(pSadr)->sin6_port = port; + reinterpret_cast(pSadr)->sin6_addr = in6addr_loopback; } } ////////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////////// -bool netadr_t::SetFromSockadr(const struct sockaddr* s) +bool CNetAdr::SetFromSockadr(struct sockaddr_storage* s) { - if (s->sa_family == AF_INET) - { - type = netadrtype_t::NA_IP; - *(int*)&ip = ((struct sockaddr_in*)s)->sin_addr.s_addr; - port = ((struct sockaddr_in*)s)->sin_port; - return true; - } - else - { - Clear(); - return false; - } + char szAdrv6[INET6_ADDRSTRLEN]{}; + sockaddr_in6* pAdrv6 = reinterpret_cast(s); + + inet_ntop(pAdrv6->sin6_family, &pAdrv6->sin6_addr, szAdrv6, sizeof(sockaddr_in6)); // TODO: Error check? + + SetFromString(szAdrv6); + SetPort(pAdrv6->sin6_port); + + return true; } ////////////////////////////////////////////////////////////////////// -// +// Returns true if we use the loopback buffers. ////////////////////////////////////////////////////////////////////// -bool netadr_t::IsValid(void) const -{ - return ((port != 0) && (type != netadrtype_t::NA_NULL) && - (ip[0] != 0 || ip[1] != 0 || ip[2] != 0 || ip[3] != 0)); -} - -////////////////////////////////////////////////////////////////////// -// -////////////////////////////////////////////////////////////////////// -bool netadr_t::IsBaseAdrValid(void) const -{ - return ((type != netadrtype_t::NA_NULL) && - (ip[0] != 0 || ip[1] != 0 || ip[2] != 0 || ip[3] != 0)); -} - -////////////////////////////////////////////////////////////////////// -// Returns true if we are localhost -////////////////////////////////////////////////////////////////////// -bool netadr_t::IsLocalhost(void) const -{ - return (ip[0] == 127) && (ip[1] == 0) && (ip[2] == 0) && (ip[3] == 1); -} - -////////////////////////////////////////////////////////////////////// -// Returns true if we use the loopback buffers -////////////////////////////////////////////////////////////////////// -bool netadr_t::IsLoopback(void) const +bool CNetAdr::IsLoopback(void) const { return type == netadrtype_t::NA_LOOPBACK; } -////////////////////////////////////////////////////////////////////// -// Check if address is reserved and not routable. -////////////////////////////////////////////////////////////////////// -bool netadr_t::IsReservedAdr(void) const -{ - if (type == netadrtype_t::NA_LOOPBACK) - { - return true; - } - - if (type == netadrtype_t::NA_IP) - { - if ((ip[0] == 10) || // 10.x.x.x is reserved - (ip[0] == 127) || // 127.x.x.x - (ip[0] == 172 && ip[1] >= 16 && ip[1] <= 31) || // 172.16.x.x - 172.31.x.x - (ip[0] == 192 && ip[1] >= 168)) // 192.168.x.x - { - return true; - } - } - return false; -} - ////////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////////// -void netadr_t::SetPort(std::uint16_t newport) -{ - port = WordSwapC(newport); -} - -////////////////////////////////////////////////////////////////////// -// -////////////////////////////////////////////////////////////////////// -bool netadr_t::SetFromString(const char* szIpAdr, bool bUseDNS) +bool CNetAdr::SetFromString(const char* pch, bool bUseDNS) { Clear(); - - if (!szIpAdr) + if (!pch) { - Assert(szIpAdr, "Invalid call: 'szIpAdr' was nullptr."); + Assert(pch, "Invalid call: 'szIpAdr' was nullptr."); return false; } - type = netadrtype_t::NA_IP; + SetType(netadrtype_t::NA_IP); - char szAddress[128]{}; - strcpy_s(szAddress, szIpAdr); + char szAddress[128]; + strncpy(szAddress, pch, sizeof(szAddress)); - if (!_strnicmp(szAddress, "loopback", 8)) + char* pszAddress = szAddress; + szAddress[sizeof(szAddress) - 1] = '\0'; + + if (szAddress[0] == '[') // Skip bracket. { - char szNewAddress[128]{}; - type = netadrtype_t::NA_LOOPBACK; - - strcpy_s(szNewAddress, "127.0.0.1"); - strcat_s(szNewAddress, szAddress + 8); // copy anything after "loopback" - - strcpy_s(szAddress, szNewAddress); + pszAddress = &szAddress[1]; } - if (!_strnicmp(szAddress, "localhost", 9)) + char* bracketEnd = strchr(szAddress, ']'); + if (bracketEnd) // Get and remove the last bracket. { - memcpy(szAddress, "127.0.0.1", 9); // Note use of memcpy allows us to keep the colon and rest of string since localhost and 127.0.0.1 are both 9 characters. - } + *bracketEnd = '\0'; - // IPv4 starts with a number and has a dot. - if (szAddress[0] >= '0' && szAddress[0] <= '9' && strchr(szAddress, '.')) - { - int i0 = -1, i1 = -1, i2 = -1, i3 = -1, n0 = 0; // Initialize port as zero - int nRes = sscanf_s(szAddress, "%d.%d.%d.%d:%d", &i0, &i1, &i2, &i3, &n0); - if ( - nRes < 4 - || i0 < 0 || i0 > 255 - || i1 < 0 || i1 > 255 - || i2 < 0 || i2 > 255 - || i3 < 0 || i3 > 255 - || n0 < 0 || n0 > 65535 - ) + char* portStart = &bracketEnd[1]; + char* pchColon = strrchr(portStart, ':'); + + if (pchColon && strchr(portStart, ':') == pchColon) { + pchColon[0] = '\0'; // Set the port. + SetPort(htons(atoi(&pchColon[1]))); + } + } + + if (!strchr(pszAddress, ':')) + { + char szNewAddressV4[128]; + V_snprintf(szNewAddressV4, sizeof(szNewAddressV4), "::FFFF:%s", pszAddress); + + if (inet_pton(AF_INET6, szNewAddressV4, &this->adr) > 0) + return true; + } + else // Address is formatted as IPv6. + { + if (inet_pton(AF_INET6, pszAddress, &this->adr) > 0) + return true; + } + + if (bUseDNS) // Perform DNS lookup instead. + { + ADDRINFOA pHints{}; + PADDRINFOA ppResult = nullptr; + + pHints.ai_family = AF_INET6; + pHints.ai_flags = AI_ALL | AI_V4MAPPED; + pHints.ai_socktype = NULL; + pHints.ai_addrlen = NULL; + pHints.ai_canonname = nullptr; + pHints.ai_addr = nullptr; + pHints.ai_next = nullptr; + + INT ret = getaddrinfo(pszAddress, nullptr, &pHints, &ppResult); + if (ret) + { + freeaddrinfo(ppResult); return false; } - SetIP(i0, i1, i2, i3); - SetPort((std::uint16_t)n0); - return true; - } -} + SetIP(reinterpret_cast(&ppResult->ai_addr->sa_data[6])); + freeaddrinfo(ppResult); -////////////////////////////////////////////////////////////////////// -// -////////////////////////////////////////////////////////////////////// -bool netadr_t::operator<(const netadr_t& netadr) const -{ - if (*((std::uint32_t*)netadr.ip) < *((std::uint32_t*)ip)) - { return true; } - else if (*((std::uint32_t*)netadr.ip) > *((std::uint32_t*)ip)) - { - return false; - } - return (netadr.port < port); + + return false; } diff --git a/r5dev/tier1/NetAdr.h b/r5dev/tier1/NetAdr.h index fc7383e8..f74b3551 100644 --- a/r5dev/tier1/NetAdr.h +++ b/r5dev/tier1/NetAdr.h @@ -4,66 +4,39 @@ enum class netadrtype_t { NA_NULL = 0, NA_LOOPBACK, - NA_BROADCAST, NA_IP, }; -typedef struct netadr_s netadr_t; -typedef struct netadr_s +class CNetAdr { public: - netadr_s(void); - netadr_s(std::uint32_t unIP, std::uint16_t usPort); - netadr_s(const char* pch); + CNetAdr(void); + CNetAdr(const char* pch); void Clear(void); + void SetIP(IN6_ADDR* inAdr); + void SetPort(uint16_t port); void SetType(netadrtype_t type); - void SetPort(std::uint16_t port); - bool SetFromSockadr(const struct sockaddr* s); - void SetIP(std::uint8_t b1, std::uint8_t b2, std::uint8_t b3, std::uint8_t b4); - void SetIP(std::uint32_t unIP); - void SetIPAndPort(std::uint32_t unIP, std::uint16_t usPort) { SetIP(unIP); SetPort(usPort); } + + bool SetFromSockadr(struct sockaddr_storage* s); bool SetFromString(const char* pch, bool bUseDNS = false); - void SetFromSocket(int hSocket); - bool CompareAdr(const netadr_s& a, bool onlyBase = false) const; - bool CompareClassBAdr(const netadr_s& a) const; - bool CompareClassCAdr(const netadr_s& a) const; + netadrtype_t GetType(void) const; + uint16_t GetPort(void) const; - netadrtype_t GetType(void) const; - std::uint16_t GetPort(void) const; + const char* ToString(bool onlyBase = false) const; + void ToString(char* pchBuffer, size_t unBufferSize, bool onlyBase = false) const; + void ToAdrinfo(addrinfo* pHint) const; - const char* ToString(bool onlyBase = false) const; + void ToSockadr(struct sockaddr_storage* s) const; + bool IsLoopback(void) const; // true if engine loopback buffers are used. - void ToString(char* pchBuffer, std::uint32_t unBufferSize, bool onlyBase = false) const; - template< size_t maxLenInChars > - void ToString_safe(char(&pDest)[maxLenInChars], bool onlyBase = false) const - { - ToString(&pDest[0], maxLenInChars, onlyBase); - } +private: + netadrtype_t type; + IN6_ADDR adr; + unsigned short port; + bool field_16; + bool reliable; +}; - //[xxxx::xxxx:xxxx:xxxx:xxxx]:00000 - - void ToSockadr(struct sockaddr* s) const; - - // Returns 0xAABBCCDD for AA.BB.CC.DD on all platforms, which is the same format used by SetIP(). - std::uint32_t GetIPHostByteOrder(void) const; - - // Returns a number that depends on the platform. In most cases, this probably should not be used. - std::uint32_t GetIPNetworkByteOrder(void) const; - - bool IsValid(void) const; // ip & port != 0 - bool IsBaseAdrValid(void) const; // ip != 0 - bool IsLocalhost(void) const; // true, if this is the localhost IP - bool IsLoopback(void) const; // true if engine loopback buffers are used - bool IsReservedAdr(void) const; // true, if this is a private LAN IP - - bool operator==(const netadr_s& netadr) const { return (CompareAdr(netadr)); } - bool operator!=(const netadr_s& netadr) const { return !(CompareAdr(netadr)); } - bool operator<(const netadr_s& netadr) const; - -public: // members are public to avoid to much changes - netadrtype_t type; - std::uint8_t ip[4]; - std::uint16_t port; -} netadr_t; +typedef class CNetAdr netadr_t;