src/corosio/src/ipv4_address.cpp

100.0% Lines (99 / 99) 100.0% Functions (15 / 15)

[ ] prev/next file

ipv4_address.cpp

f(x) Functions (15)

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/ipv4_address.hpp>
11
12		#include <ostream>
13		#include <stdexcept>
14
15		namespace boost::corosio {
16
17	8096x	ipv4_address::ipv4_address(uint_type u) noexcept : addr_(u) {}
18
19	27264x	ipv4_address::ipv4_address(bytes_type const& bytes) noexcept
20		{
21	27264x	addr_ = (static_cast<std::uint32_t>(bytes[0]) << 24) \|
22	27264x	(static_cast<std::uint32_t>(bytes[1]) << 16) \|
23	27264x	(static_cast<std::uint32_t>(bytes[2]) << 8) \|
24	27264x	(static_cast<std::uint32_t>(bytes[3]));
25	27264x	}
26
27		auto
28	10997x	ipv4_address::to_bytes() const noexcept -> bytes_type
29		{
30		bytes_type bytes;
31	10997x	bytes[0] = static_cast<unsigned char>((addr_ >> 24) & 0xff);
32	10997x	bytes[1] = static_cast<unsigned char>((addr_ >> 16) & 0xff);
33	10997x	bytes[2] = static_cast<unsigned char>((addr_ >> 8) & 0xff);
34	10997x	bytes[3] = static_cast<unsigned char>(addr_ & 0xff);
35	10997x	return bytes;
36		}
37
38		auto
39	30x	ipv4_address::to_uint() const noexcept -> uint_type
40		{
41	30x	return addr_;
42		}
43
44		std::string
45	24x	ipv4_address::to_string() const
46		{
47		char buf[max_str_len];
48	24x	auto n = print_impl(buf);
49	48x	return std::string(buf, n);
50		}
51
52		std::string_view
53	8x	ipv4_address::to_buffer(char* dest, std::size_t dest_size) const
54		{
55	8x	if (dest_size < max_str_len)
56	1x	throw std::length_error("buffer too small for IPv4 address");
57	7x	auto n = print_impl(dest);
58	7x	return std::string_view(dest, n);
59		}
60
61		bool
62	9x	ipv4_address::is_loopback() const noexcept
63		{
64	9x	return (addr_ & 0xFF000000) == 0x7F000000;
65		}
66
67		bool
68	8x	ipv4_address::is_unspecified() const noexcept
69		{
70	8x	return addr_ == 0;
71		}
72
73		bool
74	6x	ipv4_address::is_multicast() const noexcept
75		{
76	6x	return (addr_ & 0xF0000000) == 0xE0000000;
77		}
78
79		std::ostream&
80	2x	operator<<(std::ostream& os, ipv4_address const& addr)
81		{
82		char buf[ipv4_address::max_str_len];
83	2x	os << addr.to_buffer(buf, sizeof(buf));
84	2x	return os;
85		}
86
87		std::size_t
88	31x	ipv4_address::print_impl(char* dest) const noexcept
89		{
90	31x	auto const start = dest;
91	124x	auto const write = [](char*& dest, unsigned char v) {
92	124x	if (v >= 100)
93		{
94	44x	*dest++ = '0' + v / 100;
95	44x	v %= 100;
96	44x	*dest++ = '0' + v / 10;
97	44x	v %= 10;
98		}
99	80x	else if (v >= 10)
100		{
101	5x	*dest++ = '0' + v / 10;
102	5x	v %= 10;
103		}
104	124x	*dest++ = '0' + v;
105	124x	};
106	31x	write(dest, static_cast<unsigned char>((addr_ >> 24) & 0xff));
107	31x	*dest++ = '.';
108	31x	write(dest, static_cast<unsigned char>((addr_ >> 16) & 0xff));
109	31x	*dest++ = '.';
110	31x	write(dest, static_cast<unsigned char>((addr_ >> 8) & 0xff));
111	31x	*dest++ = '.';
112	31x	write(dest, static_cast<unsigned char>(addr_ & 0xff));
113	31x	return static_cast<std::size_t>(dest - start);
114		}
115
116		namespace {
117
118		// Parse a decimal octet (0-255), no leading zeros except "0"
119		// Returns true on success, advances `it`
120		bool
121	449x	parse_dec_octet(char const& it, char const end, unsigned char& octet) noexcept
122		{
123	449x	if (it == end)
124	4x	return false;
125
126	445x	char c = *it;
127	445x	if (c < '0' \|\| c > '9')
128	32x	return false;
129
130	413x	unsigned v = static_cast<unsigned>(c - '0');
131	413x	++it;
132
133	413x	if (v == 0)
134		{
135		// "0" is valid, but "00", "01", etc. are not
136	55x	if (it != end && it >= '0' && it <= '9')
137	3x	return false;
138	52x	octet = 0;
139	52x	return true;
140		}
141
142		// First digit was 1-9, can have more
143	358x	if (it != end && it >= '0' && it <= '9')
144		{
145	116x	v = v * 10 + static_cast<unsigned>(*it - '0');
146	116x	++it;
147
148	116x	if (it != end && it >= '0' && it <= '9')
149		{
150	113x	v = v * 10 + static_cast<unsigned>(*it - '0');
151	113x	++it;
152
153		// Can't have more than 3 digits
154	113x	if (it != end && it >= '0' && it <= '9')
155	3x	return false;
156		}
157		}
158
159	355x	if (v > 255)
160	9x	return false;
161
162	346x	octet = static_cast<unsigned char>(v);
163	346x	return true;
164		}
165
166		} // namespace
167
168		static std::error_code
169	149x	parse_ipv4_impl(std::string_view s, ipv4_address& addr) noexcept
170		{
171	149x	auto it = s.data();
172	149x	auto const end = it + s.size();
173
174		unsigned char octets[4];
175
176		// Parse first octet
177	149x	if (!parse_dec_octet(it, end, octets[0]))
178	42x	return std::make_error_code(std::errc::invalid_argument);
179
180		// Parse remaining octets
181	398x	for (int i = 1; i < 4; ++i)
182		{
183	309x	if (it == end \|\| *it != '.')
184	9x	return std::make_error_code(std::errc::invalid_argument);
185	300x	++it; // skip '.'
186
187	300x	if (!parse_dec_octet(it, end, octets[i]))
188	9x	return std::make_error_code(std::errc::invalid_argument);
189		}
190
191		// Must have consumed entire string
192	89x	if (it != end)
193	10x	return std::make_error_code(std::errc::invalid_argument);
194
195	158x	addr = ipv4_address(
196	79x	ipv4_address::bytes_type{{octets[0], octets[1], octets[2], octets[3]}});
197
198	79x	return {};
199		}
200
201		capy::results<ipv4_address>
202	149x	make_ipv4_address(std::string_view s) noexcept
203		{
204	149x	ipv4_address addr;
205	149x	if (auto ec = parse_ipv4_impl(s, addr))
206	70x	return {ec, ipv4_address{}};
207	79x	return {std::error_code{}, addr};
208		}
209
210		} // namespace boost::corosio
211