sid
/
NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Network: Fix minor issues with IP address parsing and add tests

This commit is contained in:
Jérôme Leclercq 2022-02-24 12:38:08 +01:00
parent 13f2132110
commit 7dbaed9aa5
4 changed files with 170 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/Nazara/Network/AlgorithmNetwork.cpp
View File

@ -353,7 +353,7 @@ namespace Nz
// validation of ipv4 subspace ::ffff:x.x
if (mappedIPv4)
{
static const UInt8 abyPfx[] = {0,0, 0,0, 0,0, 0,0, 0,0, 0xFF,0xFF};
const UInt8 abyPfx[] = {0,0, 0,0, 0,0, 0,0, 0,0, 0xFF,0xFF};
if (std::memcmp(result, abyPfx, sizeof(abyPfx)) != 0)
return false;
}
@ -376,11 +376,10 @@ namespace Nz
++addressPtr; // past the colon
unsigned int portValue;
if (!Detail::ParseDecimal(addressPtr, &portValue, nullptr) || portValue > 65535)
if (!Detail::ParseDecimal(addressPtr, &portValue, &addressPtr) || portValue > 65535)
return false;
if (port)
*port = static_cast<UInt16>(portValue);
*port = static_cast<UInt16>(portValue);
}
else // finished just with IP address
*port = 0; // indicate we have no port part

54
src/Nazara/Network/IpAddress.cpp
View File

@ -33,16 +33,20 @@ namespace Nz
* \brief Builds the IP from a hostname
* \return true If successful
*
* \remark address C-string symbolizing the IP address or hostname
* \remark address C-string symbolizing the IP address
*/
bool IpAddress::BuildFromAddress(const char* address)
{
m_isValid = false;
bool isIPv6;
UInt8 result[16];
if (!ParseIPAddress(address, result, &m_port, &isIPv6, nullptr))
const char* endOfRead;
if (!ParseIPAddress(address, result, &m_port, &isIPv6, &endOfRead))
return false;
// was everything parsed?
if (*endOfRead != '\0')
return false;
m_isValid = true;
@ -154,20 +158,42 @@ namespace Nz
if (m_port != 0)
stream << '[';
for (unsigned int i = 0; i < 8; ++i)
// IPv4-mapped IPv6?
if (f0 == 0 && l0 == 5 && m_ipv6[5] == 0xFFFF)
{
if (i == f0)
{
stream << "::";
i = l0;
if (i >= 8)
break;
}
else if (i != 0)
stream << ':';
IPv4 ipv4 = {
m_ipv6[6] >> 8,
m_ipv6[6] & 0xFF,
m_ipv6[7] >> 8,
m_ipv6[7] & 0xFF,
};
stream << ToLower(NumberToString(m_ipv6[i], 16));
stream << "::ffff:";
for (unsigned int i = 0; i < 4; ++i)
{
stream << int(ipv4[i]);
if (i != 3)
stream << '.';
}
}
else
{
for (unsigned int i = 0; i < 8; ++i)
{
if (i == f0)
{
stream << "::";
i = l0;
if (i >= 8)
break;
}
else if (i != 0)
stream << ':';
stream << ToLower(NumberToString(m_ipv6[i], 16));
}
}
if (m_port != 0)
stream << ']';

6
src/Nazara/Network/Win32/IpAddressImpl.cpp
View File

@ -57,6 +57,9 @@ namespace Nz
std::string TranslateCanonicalName(const wchar_t* str)
{
if (!str)
return {};
return FromWideString(str);
}
#else
@ -92,6 +95,9 @@ namespace Nz
std::string TranslateCanonicalName(const char* str)
{
if (!str)
return {};
return str;
}
#endif

136
tests/Engine/Network/IpAddressTest.cpp
View File

@ -1,33 +1,139 @@
#include <Nazara/Network/Algorithm.hpp>
#include <Nazara/Network/IpAddress.hpp>
#include <catch2/catch.hpp>
SCENARIO("IpAddress", "[NETWORK][IPADDRESS]")
{
GIVEN("Two default IpAddress")
WHEN("Parsing IP")
{
Nz::IpAddress ipAddressV4;
Nz::IpAddress ipAddressV6;
// IPv4
CHECK(Nz::IpAddress("0.0.0.0") == Nz::IpAddress::AnyIpV4);
CHECK(Nz::IpAddress("0.0.0.0:0") == Nz::IpAddress::AnyIpV4);
CHECK(Nz::IpAddress("0.0.0.0:12345") == Nz::IpAddress(0, 0, 0, 0, 12345));
WHEN("We parse localhost")
Nz::IpAddress loopbackIpV4("127.0.0.1");
CHECK(loopbackIpV4 == Nz::IpAddress::LoopbackIpV4);
CHECK(static_cast<bool>(loopbackIpV4));
CHECK(loopbackIpV4.IsValid());
CHECK(loopbackIpV4.IsLoopback());
CHECK(loopbackIpV4.GetPort() == 0);
CHECK(loopbackIpV4.GetProtocol() == Nz::NetProtocol::IPv4);
CHECK(loopbackIpV4.ToString() == "127.0.0.1");
CHECK(loopbackIpV4.ToUInt32() == 0x7F000001);
Nz::IpAddress loopbackIpV4WithPort("127.0.0.1:80");
CHECK(loopbackIpV4WithPort != Nz::IpAddress::LoopbackIpV4);
CHECK(static_cast<bool>(loopbackIpV4WithPort));
CHECK(loopbackIpV4WithPort.IsValid());
CHECK(loopbackIpV4WithPort.IsLoopback());
CHECK(loopbackIpV4WithPort.GetPort() == 80);
CHECK(loopbackIpV4WithPort.GetProtocol() == Nz::NetProtocol::IPv4);
CHECK(loopbackIpV4WithPort.ToString() == "127.0.0.1:80");
CHECK(loopbackIpV4WithPort.ToUInt32() == 0x7F000001);
Nz::IpAddress nonregularLoopbackIpV4("127.147.254.15:41235");
CHECK(nonregularLoopbackIpV4 != Nz::IpAddress::LoopbackIpV4);
CHECK(static_cast<bool>(nonregularLoopbackIpV4));
CHECK(nonregularLoopbackIpV4.IsValid());
CHECK(nonregularLoopbackIpV4.IsLoopback());
CHECK(nonregularLoopbackIpV4.GetPort() == 41235);
CHECK(nonregularLoopbackIpV4.GetProtocol() == Nz::NetProtocol::IPv4);
CHECK(nonregularLoopbackIpV4.ToString() == "127.147.254.15:41235");
CHECK(nonregularLoopbackIpV4.ToUInt32() == 0x7F93FE0F);
nonregularLoopbackIpV4.SetPort(14738);
CHECK(nonregularLoopbackIpV4.GetPort() == 14738);
CHECK(nonregularLoopbackIpV4.ToString() == "127.147.254.15:14738");
// IPv6
CHECK(Nz::IpAddress("::") == Nz::IpAddress::AnyIpV6);
CHECK(Nz::IpAddress("[::]:0") == Nz::IpAddress::AnyIpV6);
CHECK(Nz::IpAddress("[::]:80") == Nz::IpAddress(0, 0, 0, 0, 0, 0, 0, 0, 80));
CHECK(Nz::IpAddress("1:2:3:4:5:6:7:8") == Nz::IpAddress(1, 2, 3, 4, 5, 6, 7, 8));
CHECK(Nz::IpAddress("1:2:3:4:5::7:8") == Nz::IpAddress(1, 2, 3, 4, 5, 0, 7, 8));
CHECK(Nz::IpAddress("1:2:3:4::7:8") == Nz::IpAddress(1, 2, 3, 4, 0, 0, 7, 8));
CHECK(Nz::IpAddress("1:2:3::7:8") == Nz::IpAddress(1, 2, 3, 0, 0, 0, 7, 8));
CHECK(Nz::IpAddress("1:2::5:6:7:8") == Nz::IpAddress(1, 2, 0, 0, 0, 6, 7, 8));
CHECK(Nz::IpAddress("1::7:8") == Nz::IpAddress(1, 0, 0, 0, 0, 0, 7, 8));
CHECK(Nz::IpAddress("1::8") == Nz::IpAddress(1, 0, 0, 0, 0, 0, 0, 8));
CHECK(Nz::IpAddress("::8") == Nz::IpAddress(0, 0, 0, 0, 0, 0, 0, 8));
CHECK(Nz::IpAddress("1::") == Nz::IpAddress(1, 0, 0, 0, 0, 0, 0, 0));
CHECK(Nz::IpAddress("1:2::8") == Nz::IpAddress(1, 2, 0, 0, 0, 0, 0, 8));
CHECK(Nz::IpAddress("2001:41d0:2:d4cd::") == Nz::IpAddress(0x2001, 0x41D0, 0x2, 0xD4CD, 0, 0, 0, 0));
CHECK(Nz::IpAddress("[2001:41D0:2:D4CD::]:80") == Nz::IpAddress(0x2001, 0x41D0, 0x2, 0xD4CD, 0, 0, 0, 0, 80));
CHECK(Nz::IpAddress(0x2001, 0x41D0, 0x2, 0, 0, 0, 0, 0xD4CD).ToString() == "2001:41d0:2::d4cd");
CHECK(Nz::IpAddress(0x2001, 0x41D0, 0x2, 0, 0, 0, 0, 0xD4CD, 443).ToString() == "[2001:41d0:2::d4cd]:443");
CHECK(Nz::IpAddress(0x2001, 0x41D0, 0x2, 0xDEAD, 0xBEEF, 0x42, 0x2022, 0xD4CD, 443).ToString() == "[2001:41d0:2:dead:beef:42:2022:d4cd]:443");
// All of theses are differents representations of the same IPv6 address
std::array<std::string, 8> testAddresses {
"2001:db8:0:0:1:0:0:1",
"2001:0db8:0:0:1:0:0:1",
"2001:db8::1:0:0:1",
"2001:db8::0:1:0:0:1",
"2001:0db8::1:0:0:1",
"2001:db8:0:0:1::1",
"2001:db8:0000:0:1::1",
"2001:DB8:0:0:1::1"
};
Nz::IpAddress referenceAddress(0x2001, 0xDB8, 0, 0, 1, 0, 0, 1);
for (const std::string& str : testAddresses)
{
std::string localhostIPv4 = "127.0.0.1";
std::string localhostIPv6 = "::1";
REQUIRE(ipAddressV4.BuildFromAddress(localhostIPv4));
REQUIRE(ipAddressV6.BuildFromAddress(localhostIPv6));
THEN("It's the loop back")
{
CHECK(ipAddressV4.IsLoopback());
CHECK(ipAddressV6.IsLoopback());
}
INFO(str);
CHECK(Nz::IpAddress(str) == referenceAddress);
}
Nz::IpAddress loopbackIpV6("::1");
CHECK(loopbackIpV6 == Nz::IpAddress::LoopbackIpV6);
CHECK(loopbackIpV6.IsValid());
CHECK(loopbackIpV6.IsLoopback());
CHECK(loopbackIpV6.GetPort() == 0);
CHECK(loopbackIpV6.GetProtocol() == Nz::NetProtocol::IPv6);
CHECK(loopbackIpV6.ToString() == "::1");
Nz::IpAddress loopbackIpV6WithPort("[::1]:443");
CHECK(loopbackIpV6WithPort != Nz::IpAddress::LoopbackIpV6);
CHECK(loopbackIpV6WithPort.IsValid());
CHECK(loopbackIpV6WithPort.IsLoopback());
CHECK(loopbackIpV6WithPort.GetPort() == 443);
CHECK(loopbackIpV6WithPort.GetProtocol() == Nz::NetProtocol::IPv6);
CHECK(loopbackIpV6WithPort.ToString() == "[::1]:443");
// IPv4-mapped IPv6
Nz::IpAddress ipv4MappedIPv6("::ffff:192.168.173.22");
CHECK(ipv4MappedIPv6.IsValid());
CHECK_FALSE(ipv4MappedIPv6.IsLoopback());
CHECK(ipv4MappedIPv6.GetProtocol() == Nz::NetProtocol::IPv6);
CHECK(ipv4MappedIPv6.ToString() == "::ffff:192.168.173.22");
CHECK(ipv4MappedIPv6 == Nz::IpAddress(0, 0, 0, 0, 0, 0xFFFF, 0xC0A8, 0xAD16));
Nz::IpAddress ipv4MappedIPv6WithPort("::ffff:192.168.173.22");
CHECK(ipv4MappedIPv6WithPort.IsValid());
CHECK_FALSE(ipv4MappedIPv6WithPort.IsLoopback());
CHECK(ipv4MappedIPv6WithPort.GetProtocol() == Nz::NetProtocol::IPv6);
CHECK(ipv4MappedIPv6WithPort.ToString() == "::ffff:192.168.173.22");
CHECK(ipv4MappedIPv6WithPort == Nz::IpAddress(0, 0, 0, 0, 0, 0xFFFF, 0xC0A8, 0xAD16));
// Invalid addresses
CHECK_FALSE(Nz::IpAddress("000.123.456.789").IsValid());
CHECK_FALSE(Nz::IpAddress("0.0.0.0SomeGarbage").IsValid());
CHECK_FALSE(Nz::IpAddress("0.0.0.0:Hell0").IsValid());
CHECK_FALSE(Nz::IpAddress("Hey0.0.0.0:12345").IsValid());
CHECK_FALSE(Nz::IpAddress("::1:ffff:192.168.173.22").IsValid());
CHECK_FALSE(Nz::IpAddress("::ffff:123.412.210.230").IsValid());
CHECK_FALSE(Nz::IpAddress("::ffff:127.0.0.0.1").IsValid());
CHECK_FALSE(Nz::IpAddress("::ffff:0:255.255.255.255").IsValid());
}
GIVEN("No IpAddress")
{
WHEN("We get the IP of Nazara")
{
std::vector<Nz::HostnameInfo> hostnameInfos = Nz::IpAddress::ResolveHostname(Nz::NetProtocol::IPv4, "nazara.digitalpulsesoftware.net");
std::vector<Nz::HostnameInfo> hostnameInfos = Nz::IpAddress::ResolveHostname(Nz::NetProtocol::Any, "nazara.digitalpulsesoftware.net");
THEN("Result is not null")
{