Line data Source code
1 : //
2 : // Copyright (c) 2019 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/boostorg/url
8 : //
9 :
10 : #ifndef BOOST_URL_IMPL_IPV6_ADDRESS_IPP
11 : #define BOOST_URL_IMPL_IPV6_ADDRESS_IPP
12 :
13 : #include <boost/url/detail/config.hpp>
14 : #include <boost/url/ipv6_address.hpp>
15 : #include <boost/url/ipv4_address.hpp>
16 : #include <boost/url/rfc/ipv6_address_rule.hpp>
17 : #include <boost/url/detail/except.hpp>
18 : #include <boost/url/grammar/parse.hpp>
19 : #include <cstring>
20 :
21 : namespace boost {
22 : namespace urls {
23 :
24 210 : ipv6_address::
25 : ipv6_address(
26 210 : bytes_type const& bytes) noexcept
27 : {
28 210 : std::memcpy(&addr_,
29 210 : bytes.data(), 16);
30 210 : }
31 :
32 4 : ipv6_address::
33 : ipv6_address(
34 4 : ipv4_address const& addr) noexcept
35 : {
36 4 : auto const v = addr.to_bytes();
37 4 : ipv6_address::bytes_type bytes = {
38 : { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
39 4 : 0xff, 0xff, v[0], v[1], v[2], v[3] } };
40 4 : std::memcpy(&addr_, bytes.data(), 16);
41 4 : }
42 :
43 58 : ipv6_address::
44 : ipv6_address(
45 58 : core::string_view s)
46 : : ipv6_address(
47 58 : parse_ipv6_address(s
48 58 : ).value(BOOST_URL_POS))
49 : {
50 57 : }
51 :
52 : core::string_view
53 14 : ipv6_address::
54 : to_buffer(
55 : char* dest,
56 : std::size_t dest_size) const
57 : {
58 14 : if(dest_size < max_str_len)
59 1 : detail::throw_length_error();
60 13 : auto n = print_impl(dest);
61 13 : return core::string_view(dest, n);
62 : }
63 :
64 : bool
65 3 : ipv6_address::
66 : is_loopback() const noexcept
67 : {
68 3 : return *this == loopback();
69 : }
70 :
71 : bool
72 3 : ipv6_address::
73 : is_unspecified() const noexcept
74 : {
75 3 : return *this == ipv6_address();
76 : }
77 :
78 : bool
79 56 : ipv6_address::
80 : is_v4_mapped() const noexcept
81 : {
82 : return
83 103 : addr_[ 0] == 0 && addr_[ 1] == 0 &&
84 31 : addr_[ 2] == 0 && addr_[ 3] == 0 &&
85 29 : addr_[ 4] == 0 && addr_[ 5] == 0 &&
86 27 : addr_[ 6] == 0 && addr_[ 7] == 0 &&
87 25 : addr_[ 8] == 0 && addr_[ 9] == 0 &&
88 115 : addr_[10] == 0xff &&
89 68 : addr_[11] == 0xff;
90 : }
91 :
92 : ipv6_address
93 5 : ipv6_address::
94 : loopback() noexcept
95 : {
96 5 : ipv6_address a;
97 5 : a.addr_[15] = 1;
98 5 : return a;
99 : }
100 :
101 : std::size_t
102 51 : ipv6_address::
103 : print_impl(
104 : char* dest) const noexcept
105 : {
106 : auto const count_zeroes =
107 169 : []( unsigned char const* first,
108 : unsigned char const* const last)
109 : {
110 169 : std::size_t n = 0;
111 448 : while(first != last)
112 : {
113 425 : if( first[0] != 0 ||
114 364 : first[1] != 0)
115 : break;
116 279 : n += 2;
117 279 : first += 2;
118 : }
119 169 : return n;
120 : };
121 : auto const print_hex =
122 135 : []( char* dest,
123 : unsigned short v)
124 : {
125 135 : char const* const dig =
126 : "0123456789abcdef";
127 135 : if(v >= 0x1000)
128 : {
129 48 : *dest++ = dig[v>>12];
130 48 : v &= 0x0fff;
131 48 : *dest++ = dig[v>>8];
132 48 : v &= 0x0ff;
133 48 : *dest++ = dig[v>>4];
134 48 : v &= 0x0f;
135 48 : *dest++ = dig[v];
136 : }
137 87 : else if(v >= 0x100)
138 : {
139 2 : *dest++ = dig[v>>8];
140 2 : v &= 0x0ff;
141 2 : *dest++ = dig[v>>4];
142 2 : v &= 0x0f;
143 2 : *dest++ = dig[v];
144 : }
145 85 : else if(v >= 0x10)
146 : {
147 1 : *dest++ = dig[v>>4];
148 1 : v &= 0x0f;
149 1 : *dest++ = dig[v];
150 : }
151 : else
152 : {
153 84 : *dest++ = dig[v];
154 : }
155 135 : return dest;
156 : };
157 51 : auto const dest0 = dest;
158 : // find longest run of zeroes
159 51 : std::size_t best_len = 0;
160 51 : int best_pos = -1;
161 51 : auto it = addr_.data();
162 : auto const v4 =
163 51 : is_v4_mapped();
164 93 : auto const end = v4 ?
165 9 : (it + addr_.size() - 4)
166 93 : : it + addr_.size();
167 220 : while(it != end)
168 : {
169 169 : auto n = count_zeroes(
170 : it, end);
171 169 : if(n == 0)
172 : {
173 111 : it += 2;
174 111 : continue;
175 : }
176 58 : if(n > best_len)
177 : {
178 52 : best_pos = static_cast<
179 52 : int>(it - addr_.data());
180 52 : best_len = n;
181 : }
182 58 : it += n;
183 : }
184 51 : it = addr_.data();
185 51 : if(best_pos != 0)
186 : {
187 30 : unsigned short v =
188 30 : (it[0] * 256U) + it[1];
189 30 : dest = print_hex(dest, v);
190 30 : it += 2;
191 : }
192 : else
193 : {
194 21 : *dest++ = ':';
195 21 : it += best_len;
196 21 : if(it == end)
197 2 : *dest++ = ':';
198 : }
199 181 : while(it != end)
200 : {
201 130 : *dest++ = ':';
202 130 : if(it - addr_.data() ==
203 130 : best_pos)
204 : {
205 25 : it += best_len;
206 25 : if(it == end)
207 15 : *dest++ = ':';
208 25 : continue;
209 : }
210 105 : unsigned short v =
211 105 : (it[0] * 256U) + it[1];
212 105 : dest = print_hex(dest, v);
213 105 : it += 2;
214 : }
215 51 : if(v4)
216 : {
217 : ipv4_address::bytes_type bytes;
218 9 : bytes[0] = it[0];
219 9 : bytes[1] = it[1];
220 9 : bytes[2] = it[2];
221 9 : bytes[3] = it[3];
222 9 : ipv4_address a(bytes);
223 9 : *dest++ = ':';
224 9 : dest += a.print_impl(dest);
225 : }
226 51 : return dest - dest0;
227 : }
228 :
229 : void
230 38 : ipv6_address::
231 : to_string_impl(
232 : string_token::arg& t) const
233 : {
234 : char buf[max_str_len];
235 38 : auto const n = print_impl(buf);
236 38 : char* dest = t.prepare(n);
237 38 : std::memcpy(dest, buf, n);
238 38 : }
239 :
240 : //------------------------------------------------
241 :
242 : auto
243 204 : parse_ipv6_address(
244 : core::string_view s) noexcept ->
245 : system::result<ipv6_address>
246 : {
247 : return grammar::parse(
248 204 : s, ipv6_address_rule);
249 : }
250 :
251 : } // urls
252 : } // boost
253 :
254 : #endif
|
