src/corosio/src/ipv6_address.cpp

100.0% Lines (295 / 295, 4 excl) 100.0% Functions (22 / 22)

[ ] prev/next file

ipv6_address.cpp

f(x) Functions (22)

Function Calls Lines Blocks

Line	Hits	Source Code
1		//
2		// Copyright (c) 2026 Vinnie Falco (vinnie.falco@gmail.com)
3		//
4		// Distributed under the Boost Software License, Version 1.0. (See accompanying
5		// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6		//
7		// Official repository: https://github.com/cppalliance/corosio
8		//
9
10		#include <boost/corosio/ipv6_address.hpp>
11		#include <boost/corosio/ipv4_address.hpp>
12
13		#include <boost/corosio/detail/except.hpp>
14		#include <boost/corosio/detail/platform.hpp>
15
16		#if BOOST_COROSIO_POSIX
17		#include <net/if.h>
18		#endif
19
20		#include <cstring>
21		#include <ostream>
22		#include <stdexcept>
23
24		namespace boost::corosio {
25
26	298x	ipv6_address::ipv6_address(
27	298x	bytes_type const& bytes, std::uint32_t scope_id) noexcept
28	298x	: scope_id_(scope_id)
29		{
30	298x	std::memcpy(addr_.data(), bytes.data(), 16);
31	298x	}
32
33	13x	ipv6_address::ipv6_address(ipv4_address const& addr) noexcept
34		{
35	13x	auto const v = addr.to_bytes();
36	52x	addr_ = {
37	13x	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, v[0], v[1], v[2], v[3]}};
38	13x	}
39
40	28x	ipv6_address::ipv6_address(std::string_view s)
41		{
42	28x	auto [ec, addr] = make_ipv6_address(s);
43	28x	if (ec)
44	3x	detail::throw_system_error(ec, "invalid IPv6 address");
45	25x	*this = addr;
46	25x	}
47
48		std::string
49	21x	ipv6_address::to_string() const
50		{
51		char buf[max_str_len];
52	21x	auto n = print_impl(buf);
53	42x	return std::string(buf, n);
54		}
55
56		std::string_view
57	11x	ipv6_address::to_buffer(char* dest, std::size_t dest_size) const
58		{
59	11x	if (dest_size < max_str_len)
60	3x	throw std::length_error("buffer too small for IPv6 address");
61	8x	auto n = print_impl(dest);
62	8x	return std::string_view(dest, n);
63		}
64
65		bool
66	6x	ipv6_address::is_unspecified() const noexcept
67		{
68		// Classification tests the address bits; the zone names a link,
69		// not a different kind of address
70	6x	return addr_ == bytes_type{};
71		}
72
73		bool
74	13x	ipv6_address::is_loopback() const noexcept
75		{
76	13x	return addr_ == loopback().addr_;
77		}
78
79		bool
80	6x	ipv6_address::is_multicast() const noexcept
81		{
82	6x	return addr_[0] == 0xff;
83		}
84
85		bool
86	44x	ipv6_address::is_v4_mapped() const noexcept
87		{
88	78x	return addr_[0] == 0 && addr_[1] == 0 && addr_[2] == 0 && addr_[3] == 0 &&
89	31x	addr_[4] == 0 && addr_[5] == 0 && addr_[6] == 0 && addr_[7] == 0 &&
90	89x	addr_[8] == 0 && addr_[9] == 0 && addr_[10] == 0xff &&
91	55x	addr_[11] == 0xff;
92		}
93
94		ipv4_address
95	8x	ipv6_address::to_v4() const
96		{
97	8x	if (!is_v4_mapped())
98	4x	detail::throw_system_error(
99	4x	std::make_error_code(std::errc::address_family_not_supported),
100		"address is not v4-mapped");
101	8x	return ipv4_address(
102	4x	ipv4_address::bytes_type{{addr_[12], addr_[13], addr_[14], addr_[15]}});
103		}
104
105		ipv6_address
106	115x	ipv6_address::loopback() noexcept
107		{
108	115x	ipv6_address a;
109	115x	a.addr_[15] = 1;
110	115x	return a;
111		}
112
113		std::ostream&
114	3x	operator<<(std::ostream& os, ipv6_address const& addr)
115		{
116		char buf[ipv6_address::max_str_len];
117	3x	os << addr.to_buffer(buf, sizeof(buf));
118	3x	return os;
119		}
120
121		std::size_t
122	29x	ipv6_address::print_impl(char* dest) const noexcept
123		{
124	91x	auto const count_zeroes = [](unsigned char const* first,
125		unsigned char const* const last) {
126	91x	std::size_t n = 0;
127	251x	while (first != last)
128		{
129	248x	if (first[0] != 0 \|\| first[1] != 0)
130		break;
131	160x	n += 2;
132	160x	first += 2;
133		}
134	91x	return n;
135		};
136
137	66x	auto const print_hex = [](char* dest, unsigned short v) {
138	66x	char const* const dig = "0123456789abcdef";
139	66x	if (v >= 0x1000)
140		{
141	25x	*dest++ = dig[v >> 12];
142	25x	v &= 0x0fff;
143	25x	*dest++ = dig[v >> 8];
144	25x	v &= 0x0ff;
145	25x	*dest++ = dig[v >> 4];
146	25x	v &= 0x0f;
147	25x	*dest++ = dig[v];
148		}
149	41x	else if (v >= 0x100)
150		{
151	4x	*dest++ = dig[v >> 8];
152	4x	v &= 0x0ff;
153	4x	*dest++ = dig[v >> 4];
154	4x	v &= 0x0f;
155	4x	*dest++ = dig[v];
156		}
157	37x	else if (v >= 0x10)
158		{
159	1x	*dest++ = dig[v >> 4];
160	1x	v &= 0x0f;
161	1x	*dest++ = dig[v];
162		}
163		else
164		{
165	36x	*dest++ = dig[v];
166		}
167	66x	return dest;
168		};
169
170	29x	auto const dest0 = dest;
171		// find longest run of zeroes
172	29x	std::size_t best_len = 0;
173	29x	int best_pos = -1;
174	29x	auto it = addr_.data();
175	29x	auto const v4 = is_v4_mapped();
176	58x	auto const end = v4 ? (it + addr_.size() - 4) : it + addr_.size();
177
178	120x	while (it != end)
179		{
180	91x	auto n = count_zeroes(it, end);
181	91x	if (n == 0)
182		{
183	66x	it += 2;
184	66x	continue;
185		}
186	25x	if (n > best_len)
187		{
188	25x	best_pos = static_cast<int>(it - addr_.data());
189	25x	best_len = n;
190		}
191	25x	it += n;
192		}
193
194	29x	it = addr_.data();
195	29x	if (best_pos != 0)
196		{
197	13x	unsigned short v = static_cast<unsigned short>(it[0] * 256U + it[1]);
198	13x	dest = print_hex(dest, v);
199	13x	it += 2;
200		}
201		else
202		{
203	16x	*dest++ = ':';
204	16x	it += best_len;
205	16x	if (it == end)
206	2x	*dest++ = ':';
207		}
208
209	91x	while (it != end)
210		{
211	62x	*dest++ = ':';
212	62x	if (it - addr_.data() == best_pos)
213		{
214	9x	it += best_len;
215	9x	if (it == end)
216	1x	*dest++ = ':';
217	9x	continue;
218		}
219	53x	unsigned short v = static_cast<unsigned short>(it[0] * 256U + it[1]);
220	53x	dest = print_hex(dest, v);
221	53x	it += 2;
222		}
223
224	29x	if (v4)
225		{
226		ipv4_address::bytes_type bytes;
227	3x	bytes[0] = it[0];
228	3x	bytes[1] = it[1];
229	3x	bytes[2] = it[2];
230	3x	bytes[3] = it[3];
231	3x	ipv4_address a(bytes);
232	3x	*dest++ = ':';
233		char buf[ipv4_address::max_str_len];
234	3x	auto sv = a.to_buffer(buf, sizeof(buf));
235	3x	std::memcpy(dest, sv.data(), sv.size());
236	3x	dest += sv.size();
237		}
238
239	29x	if (scope_id_ != 0)
240		{
241	6x	*dest++ = '%';
242		char digits[10];
243	6x	int n = 0;
244	6x	std::uint32_t v = scope_id_;
245		do
246		{
247	33x	digits[n++] = static_cast<char>('0' + v % 10);
248	33x	v /= 10;
249		}
250	33x	while (v != 0);
251	39x	while (n != 0)
252	33x	*dest++ = digits[--n];
253		}
254
255	29x	return static_cast<std::size_t>(dest - dest0);
256		}
257
258		namespace {
259
260		// Convert hex character to value (0-15), or -1 if not hex
261		inline int
262	873x	hexdig_value(char c) noexcept
263		{
264	873x	if (c >= '0' && c <= '9')
265	516x	return c - '0';
266	357x	if (c >= 'a' && c <= 'f')
267	171x	return c - 'a' + 10;
268	186x	if (c >= 'A' && c <= 'F')
269	8x	return c - 'A' + 10;
270	178x	return -1;
271		}
272
273		// Parse h16 (1-4 hex digits) returning 16-bit value
274		// Returns true on success, advances `it`
275		bool
276	304x	parse_h16(
277		char const*& it,
278		char const* end,
279		unsigned char& hi,
280		unsigned char& lo) noexcept
281		{
282	−	if (it == end) // LCOV_EXCL_LINE callers pre-check end-of-input
283	−	return false; // LCOV_EXCL_LINE callers pre-check end-of-input
284
285	304x	int d = hexdig_value(*it);
286	304x	if (d < 0)
287	10x	return false;
288
289	294x	unsigned v = static_cast<unsigned>(d);
290	294x	++it;
291
292	512x	for (int i = 0; i < 3 && it != end; ++i)
293		{
294	374x	d = hexdig_value(*it);
295	374x	if (d < 0)
296	156x	break;
297	218x	v = (v << 4) \| static_cast<unsigned>(d);
298	218x	++it;
299		}
300
301	294x	hi = static_cast<unsigned char>((v >> 8) & 0xff);
302	294x	lo = static_cast<unsigned char>(v & 0xff);
303	294x	return true;
304		}
305
306		// Check if a hex word could be 0..255 if interpreted as decimal
307		bool
308	17x	maybe_octet(unsigned char const* p) noexcept
309		{
310	17x	unsigned short word = static_cast<unsigned short>(p[0]) * 256 +
311	17x	static_cast<unsigned short>(p[1]);
312	17x	if (word > 0x255)
313	1x	return false;
314	16x	if (((word >> 4) & 0xf) > 9)
315	1x	return false;
316	15x	if ((word & 0xf) > 9)
317	1x	return false;
318	14x	return true;
319		}
320
321		} // namespace
322
323		static std::error_code
324	140x	parse_ipv6_impl(std::string_view s, ipv6_address& addr) noexcept
325		{
326	140x	auto it = s.data();
327	140x	auto const end = it + s.size();
328
329	140x	int n = 8; // words needed
330	140x	int b = -1; // value of n when '::' seen
331	140x	bool c = false; // need colon
332	140x	auto prev = it;
333	140x	ipv6_address::bytes_type bytes{};
334		unsigned char hi, lo;
335
336		for (;;)
337		{
338	533x	if (it == end)
339		{
340	84x	if (b != -1)
341		{
342		// end in "::"
343	78x	break;
344		}
345		// not enough words
346	6x	return std::make_error_code(std::errc::invalid_argument);
347		}
348
349	449x	if (*it == ':')
350		{
351	233x	++it;
352	233x	if (it == end)
353		{
354		// expected ':'
355	7x	return std::make_error_code(std::errc::invalid_argument);
356		}
357	226x	if (*it == ':')
358		{
359	109x	if (b == -1)
360		{
361		// first "::"
362	108x	++it;
363	108x	--n;
364	108x	b = n;
365	108x	if (n == 0)
366	1x	break;
367	107x	c = false;
368	107x	continue;
369		}
370		// extra "::" found
371	1x	return std::make_error_code(std::errc::invalid_argument);
372		}
373	117x	if (c)
374		{
375	114x	prev = it;
376	114x	if (!parse_h16(it, end, hi, lo))
377	2x	return std::make_error_code(std::errc::invalid_argument);
378	112x	bytes[2 * (8 - n) + 0] = hi;
379	112x	bytes[2 * (8 - n) + 1] = lo;
380	112x	--n;
381	112x	if (n == 0)
382	7x	break;
383	105x	continue;
384		}
385		// expected h16
386	3x	return std::make_error_code(std::errc::invalid_argument);
387		}
388
389	216x	if (*it == '.')
390		{
391	21x	if (b == -1 && n > 1)
392		{
393		// not enough h16
394	14x	return std::make_error_code(std::errc::invalid_argument);
395		}
396	17x	if (!maybe_octet(&bytes[std::size_t(2) * std::size_t(7 - n)]))
397		{
398		// invalid octet
399	3x	return std::make_error_code(std::errc::invalid_argument);
400		}
401		// rewind the h16 and parse it as IPv4
402	14x	it = prev;
403	14x	auto [v4ec, v4] = make_ipv4_address(
404	14x	std::string_view(it, static_cast<std::size_t>(end - it)));
405	14x	if (v4ec)
406	7x	return v4ec;
407		// Must consume exactly the IPv4 address portion
408		// Re-parse to find where it ends
409	7x	auto v4_it = it;
410	81x	while (v4_it != end &&
411	74x	(v4_it == '.' \|\| (v4_it >= '0' && *v4_it <= '9')))
412	74x	++v4_it;
413		// Verify it parsed correctly by re-parsing the exact substring
414	7x	auto [ckec, v4_check] = make_ipv4_address(
415	7x	std::string_view(it, static_cast<std::size_t>(v4_it - it)));
416	−	if (ckec) // LCOV_EXCL_LINE prefix of a parsed tail cannot fail
417	−	return ckec; // LCOV_EXCL_LINE prefix of a parsed tail cannot fail
418	7x	it = v4_it;
419	7x	auto const b4 = v4_check.to_bytes();
420	7x	bytes[2 * (7 - n) + 0] = b4[0];
421	7x	bytes[2 * (7 - n) + 1] = b4[1];
422	7x	bytes[2 * (7 - n) + 2] = b4[2];
423	7x	bytes[2 * (7 - n) + 3] = b4[3];
424	7x	--n;
425	7x	break;
426		}
427
428	195x	auto d = hexdig_value(*it);
429	195x	if (b != -1 && d < 0)
430		{
431		// ends in "::"
432	3x	break;
433		}
434
435	192x	if (!c)
436		{
437	190x	prev = it;
438	190x	if (!parse_h16(it, end, hi, lo))
439	8x	return std::make_error_code(std::errc::invalid_argument);
440	182x	bytes[2 * (8 - n) + 0] = hi;
441	182x	bytes[2 * (8 - n) + 1] = lo;
442	182x	--n;
443	182x	if (n == 0)
444	1x	break;
445	181x	c = true;
446	181x	continue;
447		}
448
449		// ':' divides a word
450	2x	return std::make_error_code(std::errc::invalid_argument);
451	393x	}
452
453		// Must have consumed entire string
454	97x	if (it != end)
455	6x	return std::make_error_code(std::errc::invalid_argument);
456
457	91x	if (b == -1)
458		{
459	3x	addr = ipv6_address{bytes};
460	3x	return {};
461		}
462
463	88x	if (b == n)
464		{
465		// "::" last
466	5x	auto const i = 2 * (7 - n);
467	5x	std::memset(&bytes[i], 0, 16 - i);
468		}
469	83x	else if (b == 7)
470		{
471		// "::" first
472	22x	auto const i = 2 * (b - n);
473	22x	std::memmove(&bytes[16 - i], &bytes[2], i);
474	22x	std::memset(&bytes[0], 0, 16 - i);
475		}
476		else
477		{
478		// "::" in middle
479	61x	auto const i0 = 2 * (7 - b);
480	61x	auto const i1 = 2 * (b - n);
481	61x	std::memmove(&bytes[16 - i1], &bytes[i0 + 2], i1);
482	61x	std::memset(&bytes[i0], 0, 16 - (i0 + i1));
483		}
484
485	88x	addr = ipv6_address{bytes};
486	88x	return {};
487		}
488
489		namespace {
490
491		// Strict decimal: full consumption, no sign, must fit uint32
492		bool
493	21x	parse_zone_numeric(std::string_view s, std::uint32_t& out) noexcept
494		{
495	21x	if (s.empty())
496	1x	return false;
497	20x	std::uint64_t v = 0;
498	53x	for (char c : s)
499		{
500	38x	if (c < '0' \|\| c > '9')
501	4x	return false;
502	34x	v = v * 10 + static_cast<unsigned>(c - '0');
503	34x	if (v > 0xffffffffull)
504	1x	return false;
505		}
506	15x	out = static_cast<std::uint32_t>(v);
507	15x	return true;
508		}
509
510		// Numeric everywhere; interface names via the system where the
511		// platform names interfaces (Windows zones are numeric). An unknown
512		// name is an error, never a silent zone 0.
513		bool
514	21x	parse_zone(std::string_view s, std::uint32_t& out) noexcept
515		{
516	21x	if (parse_zone_numeric(s, out))
517	15x	return true;
518		#if BOOST_COROSIO_POSIX
519		char name[IF_NAMESIZE];
520	6x	if (s.empty() \|\| s.size() >= sizeof(name))
521	1x	return false;
522	5x	std::memcpy(name, s.data(), s.size());
523	5x	name[s.size()] = '\0';
524	5x	auto idx = if_nametoindex(name);
525	5x	if (idx == 0)
526	4x	return false;
527	1x	out = static_cast<std::uint32_t>(idx);
528	1x	return true;
529		#else
530		return false;
531		#endif
532		}
533
534		} // namespace
535
536		capy::io_result<ipv6_address>
537	145x	make_ipv6_address(std::string_view s) noexcept
538		{
539	145x	std::uint32_t scope_id = 0;
540	145x	if (auto pos = s.find('%'); pos != std::string_view::npos)
541		{
542	21x	if (!parse_zone(s.substr(pos + 1), scope_id))
543		return {
544	5x	std::make_error_code(std::errc::invalid_argument),
545	5x	ipv6_address{}};
546	16x	s = s.substr(0, pos);
547		}
548	140x	ipv6_address addr;
549	140x	if (auto ec = parse_ipv6_impl(s, addr))
550	49x	return {ec, ipv6_address{}};
551	91x	return {std::error_code{}, ipv6_address(addr.to_bytes(), scope_id)};
552		}
553
554		} // namespace boost::corosio
555