First

lib/ipv6_address.cpp

@@ -0,0 +1,362 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (c) Lewis Baker
+// Licenced under MIT license. See LICENSE.txt for details.
+///////////////////////////////////////////////////////////////////////////////
+
+#include <cppcoro/net/ipv6_address.hpp>
+#include <cppcoro/config.hpp>
+
+#include <cassert>
+
+namespace
+{
+	namespace local
+	{
+		constexpr bool is_digit(char c)
+		{
+			return c >= '0' && c <= '9';
+		}
+
+		constexpr std::uint8_t digit_value(char c)
+		{
+			return static_cast<std::uint8_t>(c - '0');
+		}
+
+		std::optional<std::uint8_t> try_parse_hex_digit(char c)
+		{
+			if (c >= '0' && c <= '9')
+			{
+				return static_cast<std::uint8_t>(c - '0');
+			}
+			else if (c >= 'a' && c <= 'f')
+			{
+				return static_cast<std::uint8_t>(c - 'a' + 10);
+			}
+			else if (c >= 'A' && c <= 'F')
+			{
+				return static_cast<std::uint8_t>(c - 'A' + 10);
+			}
+
+			return std::nullopt;
+		}
+
+		char hex_char(std::uint8_t value)
+		{
+			return value < 10 ?
+				static_cast<char>('0' + value) :
+				static_cast<char>('a' + value - 10);
+		}
+	}
+}
+
+std::optional<cppcoro::net::ipv6_address>
+cppcoro::net::ipv6_address::from_string(std::string_view string) noexcept
+{
+	// Longest possible valid IPv6 string is
+	// "xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:nnn.nnn.nnn.nnn"
+	constexpr std::size_t maxLength = 45;
+
+	if (string.empty() || string.length() > maxLength)
+	{
+		return std::nullopt;
+	}
+
+	const std::size_t length = string.length();
+
+	std::optional<int> doubleColonPos;
+
+	std::size_t pos = 0;
+
+	if (length >= 2 && string[0] == ':' && string[1] == ':')
+	{
+		doubleColonPos = 0;
+		pos = 2;
+	}
+
+	int partCount = 0;
+	std::uint16_t parts[8] = { 0 };
+
+	while (pos < length && partCount < 8)
+	{
+		std::uint8_t digits[4];
+		int digitCount = 0;
+		auto digit = local::try_parse_hex_digit(string[pos]);
+		if (!digit)
+		{
+			return std::nullopt;
+		}
+
+		do
+		{
+			digits[digitCount] = *digit;
+			++digitCount;
+			++pos;
+		} while (digitCount < 4 && pos < length && (digit = local::try_parse_hex_digit(string[pos])));
+
+		// If we're not at the end of the string then there must either be a ':' or a '.' next
+		// followed by the next part.
+		if (pos < length)
+		{
+			// Check if there's room for anything after the separator.
+			if ((pos + 1) == length)
+			{
+				return std::nullopt;
+			}
+
+			if (string[pos] == ':')
+			{
+				++pos;
+				if (string[pos] == ':')
+				{
+					if (doubleColonPos)
+					{
+						// This is a second double-colon, which is invalid.
+						return std::nullopt;
+					}
+
+					doubleColonPos = partCount + 1;
+					++pos;
+				}
+			}
+			else if (string[pos] == '.')
+			{
+				// Treat the current set of digits as decimal digits and parse
+				// the remaining three groups as dotted decimal notation.
+
+				// Decimal notation produces two 16-bit parts.
+				// If we already have more than 6 parts then we'll end up
+				// with too many.
+				if (partCount > 6)
+				{
+					return std::nullopt;
+				}
+
+				// Check for over-long or octal notation.
+				if (digitCount > 3 || (digitCount > 1 && digits[0] == 0))
+				{
+					return std::nullopt;
+				}
+
+				// Check that digits are valid decimal digits
+				if (digits[0] > 9 ||
+					(digitCount > 1 && digits[1] > 9) ||
+					(digitCount == 3 && digits[2] > 9))
+				{
+					return std::nullopt;
+				}
+
+				std::uint16_t decimalParts[4];
+
+				{
+					decimalParts[0] = digits[0];
+					for (int i = 1; i < digitCount; ++i)
+					{
+						decimalParts[0] *= 10;
+						decimalParts[0] += digits[i];
+					}
+
+					if (decimalParts[0] > 255)
+					{
+						return std::nullopt;
+					}
+				}
+
+				for (int decimalPart = 1; decimalPart < 4; ++decimalPart)
+				{
+					if (string[pos] != '.')
+					{
+						return std::nullopt;
+					}
+
+					++pos;
+
+					if (pos == length || !local::is_digit(string[pos]))
+					{
+						// Expected a number after a dot.
+						return std::nullopt;
+					}
+
+					const bool hasLeadingZero = string[pos] == '0';
+
+					decimalParts[decimalPart] = local::digit_value(string[pos]);
+					++pos;
+					digitCount = 1;
+					while (digitCount < 3 && pos < length && local::is_digit(string[pos]))
+					{
+						decimalParts[decimalPart] *= 10;
+						decimalParts[decimalPart] += local::digit_value(string[pos]);
+						++pos;
+						++digitCount;
+					}
+
+					if (decimalParts[decimalPart] > 255)
+					{
+						return std::nullopt;
+					}
+
+					// Detect octal-style number (redundant leading zero)
+					if (digitCount > 1 && hasLeadingZero)
+					{
+						return std::nullopt;
+					}
+				}
+
+				parts[partCount] = (decimalParts[0] << 8) + decimalParts[1];
+				parts[partCount + 1] = (decimalParts[2] << 8) + decimalParts[3];
+				partCount += 2;
+
+				// Dotted decimal notation only appears at end.
+				// Don't parse any more of the string.
+				break;
+			}
+			else
+			{
+				// Invalid separator.
+				return std::nullopt;
+			}
+		}
+
+		// Current part was made up of hex-digits.
+		std::uint16_t partValue = digits[0];
+		for (int i = 1; i < digitCount; ++i)
+		{
+			partValue = partValue * 16 + digits[i];
+		}
+
+		parts[partCount] = partValue;
+		++partCount;
+	}
+
+	// Finished parsing the IPv6 address, we should have consumed all of the string.
+	if (pos < length)
+	{
+		return std::nullopt;
+	}
+
+	if (partCount < 8)
+	{
+		if (!doubleColonPos)
+		{
+			return std::nullopt;
+		}
+
+		const int preCount = *doubleColonPos;
+
+		//CPPCORO_ASSUME(preCount <= partCount);
+
+		const int postCount = partCount - preCount;
+		const int zeroCount = 8 - preCount - postCount;
+
+		// Move parts after double colon down to the end.
+		for (int i = 0; i < postCount; ++i)
+		{
+			parts[7 - i] = parts[7 - zeroCount - i];
+		}
+
+		// Fill gap with zeroes.
+		for (int i = 0; i < zeroCount; ++i)
+		{
+			parts[preCount + i] = 0;
+		}
+	}
+	else if (doubleColonPos)
+	{
+		return std::nullopt;
+	}
+
+	return ipv6_address{ parts };
+}
+
+std::string cppcoro::net::ipv6_address::to_string() const
+{
+	std::uint32_t longestZeroRunStart = 0;
+	std::uint32_t longestZeroRunLength = 0;
+	for (std::uint32_t i = 0; i < 8; )
+	{
+		if (m_bytes[2 * i] == 0 && m_bytes[2 * i + 1] == 0)
+		{
+			const std::uint32_t zeroRunStart = i;
+			++i;
+			while (i < 8 && m_bytes[2 * i] == 0 && m_bytes[2 * i + 1] == 0)
+			{
+				++i;
+			}
+
+			std::uint32_t zeroRunLength = i - zeroRunStart;
+			if (zeroRunLength > longestZeroRunLength)
+			{
+				longestZeroRunLength = zeroRunLength;
+				longestZeroRunStart = zeroRunStart;
+			}
+		}
+		else
+		{
+			++i;
+		}
+	}
+
+	// Longest string will be 8 x 4 digits + 7 ':' separators
+	char buffer[40];
+
+	char* c = &buffer[0];
+
+	auto appendPart = [&](std::uint32_t index)
+	{
+		const std::uint8_t highByte = m_bytes[index * 2];
+		const std::uint8_t lowByte = m_bytes[index * 2 + 1];
+
+		// Don't output leading zero hex digits in the part string.
+		if (highByte > 0 || lowByte > 15)
+		{
+			if (highByte > 0)
+			{
+				if (highByte > 15)
+				{
+					*c++ = local::hex_char(highByte >> 4);
+				}
+				*c++ = local::hex_char(highByte & 0xF);
+			}
+			*c++ = local::hex_char(lowByte >> 4);
+		}
+		*c++ = local::hex_char(lowByte & 0xF);
+	};
+
+	if (longestZeroRunLength >= 2)
+	{
+		for (std::uint32_t i = 0; i < longestZeroRunStart; ++i)
+		{
+			if (i > 0)
+			{
+				*c++ = ':';
+			}
+
+			appendPart(i);
+		}
+
+		*c++ = ':';
+		*c++ = ':';
+
+		for (std::uint32_t i = longestZeroRunStart + longestZeroRunLength; i < 8; ++i)
+		{
+			appendPart(i);
+
+			if (i < 7)
+			{
+				*c++ = ':';
+			}
+		}
+	}
+	else
+	{
+		appendPart(0);
+		for (std::uint32_t i = 1; i < 8; ++i)
+		{
+			*c++ = ':';
+			appendPart(i);
+		}
+	}
+
+	assert((c - &buffer[0]) <= sizeof(buffer));
+
+	return std::string{ &buffer[0], c };
+}