mirror of
https://github.com/Mauler125/r5sdk.git
synced 2025-02-09 19:15:03 +01:00
Reimplementation of CNetAdr
This will replace 'CNetAdr2' and 'v_netadr_t'. The implementation is directly compatible with the structures in engine.
This commit is contained in:
Kawe Mazidjatari
parent
682f29e69a
commit
0e033cb755
@ -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<sockaddr_in6*>(pSadr)->sin6_family = AF_INET6;
|
||||
reinterpret_cast<sockaddr_in6*>(pSadr)->sin6_port = port;
|
||||
inet_pton(AF_INET6, ToString(true), &reinterpret_cast<sockaddr_in6*>(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<sockaddr_in6*>(pSadr)->sin6_family = AF_INET6;
|
||||
reinterpret_cast<sockaddr_in6*>(pSadr)->sin6_port = port;
|
||||
reinterpret_cast<sockaddr_in6*>(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<sockaddr_in6*>(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<IN6_ADDR*>(&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;
|
||||
}
|
||||
|
||||
@ -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;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user