1 /*
2 * Copyright (c) Facebook, Inc. and its affiliates.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <folly/IPAddress.h>
18
19 #include <limits>
20 #include <ostream>
21 #include <string>
22 #include <vector>
23
24 #include <fmt/core.h>
25
26 #include <folly/String.h>
27 #include <folly/detail/IPAddressSource.h>
28
29 using std::ostream;
30 using std::string;
31 using std::vector;
32
33 namespace folly {
34
35 // free functions
hash_value(const IPAddress & addr)36 size_t hash_value(const IPAddress& addr) {
37 return addr.hash();
38 }
operator <<(ostream & os,const IPAddress & addr)39 ostream& operator<<(ostream& os, const IPAddress& addr) {
40 os << addr.str();
41 return os;
42 }
toAppend(IPAddress addr,string * result)43 void toAppend(IPAddress addr, string* result) {
44 result->append(addr.str());
45 }
toAppend(IPAddress addr,fbstring * result)46 void toAppend(IPAddress addr, fbstring* result) {
47 result->append(addr.str());
48 }
49
validate(StringPiece ip)50 bool IPAddress::validate(StringPiece ip) noexcept {
51 return IPAddressV4::validate(ip) || IPAddressV6::validate(ip);
52 }
53
54 // public static
createIPv4(const IPAddress & addr)55 IPAddressV4 IPAddress::createIPv4(const IPAddress& addr) {
56 if (addr.isV4()) {
57 return addr.asV4();
58 } else {
59 return addr.asV6().createIPv4();
60 }
61 }
62
63 // public static
createIPv6(const IPAddress & addr)64 IPAddressV6 IPAddress::createIPv6(const IPAddress& addr) {
65 if (addr.isV6()) {
66 return addr.asV6();
67 } else {
68 return addr.asV4().createIPv6();
69 }
70 }
71
72 namespace {
splitIpSlashCidr(StringPiece ipSlashCidr)73 vector<string> splitIpSlashCidr(StringPiece ipSlashCidr) {
74 vector<string> vec;
75 split("/", ipSlashCidr, vec);
76 return vec;
77 }
78 } // namespace
79
80 // public static
createNetwork(StringPiece ipSlashCidr,int defaultCidr,bool applyMask)81 CIDRNetwork IPAddress::createNetwork(
82 StringPiece ipSlashCidr,
83 int defaultCidr, /* = -1 */
84 bool applyMask /* = true */) {
85 auto const ret =
86 IPAddress::tryCreateNetwork(ipSlashCidr, defaultCidr, applyMask);
87
88 if (ret.hasValue()) {
89 return ret.value();
90 }
91
92 if (ret.error() == CIDRNetworkError::INVALID_DEFAULT_CIDR) {
93 throw std::range_error("defaultCidr must be <= UINT8_MAX");
94 }
95
96 if (ret.error() == CIDRNetworkError::INVALID_IP_SLASH_CIDR) {
97 throw IPAddressFormatException(fmt::format(
98 "Invalid ipSlashCidr specified. Expected IP/CIDR format, got '{}'",
99 ipSlashCidr));
100 }
101
102 // Handler the remaining error cases. We re-parse the ip/mask pair
103 // to make error messages more meaningful
104 auto const vec = splitIpSlashCidr(ipSlashCidr);
105
106 switch (ret.error()) {
107 case CIDRNetworkError::INVALID_IP:
108 CHECK_GE(vec.size(), 1);
109 throw IPAddressFormatException(
110 fmt::format("Invalid IP address {}", vec.at(0)));
111 case CIDRNetworkError::INVALID_CIDR:
112 CHECK_GE(vec.size(), 2);
113 throw IPAddressFormatException(
114 fmt::format("Mask value '{}' not a valid mask", vec.at(1)));
115 case CIDRNetworkError::CIDR_MISMATCH: {
116 auto const subnet = IPAddress::tryFromString(vec.at(0)).value();
117 auto cidr = static_cast<uint8_t>(
118 (defaultCidr > -1) ? defaultCidr : (subnet.isV4() ? 32 : 128));
119
120 throw IPAddressFormatException(fmt::format(
121 "CIDR value '{}' is > network bit count '{}'",
122 vec.size() == 2 ? vec.at(1) : to<string>(cidr),
123 subnet.bitCount()));
124 }
125 case CIDRNetworkError::INVALID_DEFAULT_CIDR:
126 case CIDRNetworkError::INVALID_IP_SLASH_CIDR:
127 default:
128 // unreachable
129 break;
130 }
131
132 CHECK(0);
133
134 return CIDRNetwork{};
135 }
136
137 // public static
tryCreateNetwork(StringPiece ipSlashCidr,int defaultCidr,bool applyMask)138 Expected<CIDRNetwork, CIDRNetworkError> IPAddress::tryCreateNetwork(
139 StringPiece ipSlashCidr, int defaultCidr, bool applyMask) {
140 if (defaultCidr > std::numeric_limits<uint8_t>::max()) {
141 return makeUnexpected(CIDRNetworkError::INVALID_DEFAULT_CIDR);
142 }
143
144 auto const vec = splitIpSlashCidr(ipSlashCidr);
145 auto const elemCount = vec.size();
146
147 if (elemCount == 0 || // weird invalid string
148 elemCount > 2) { // invalid string (IP/CIDR/extras)
149 return makeUnexpected(CIDRNetworkError::INVALID_IP_SLASH_CIDR);
150 }
151
152 auto const subnet = IPAddress::tryFromString(vec.at(0));
153 if (subnet.hasError()) {
154 return makeUnexpected(CIDRNetworkError::INVALID_IP);
155 }
156
157 auto cidr = static_cast<uint8_t>(
158 (defaultCidr > -1) ? defaultCidr : (subnet.value().isV4() ? 32 : 128));
159
160 if (elemCount == 2) {
161 auto const maybeCidr = tryTo<uint8_t>(vec.at(1));
162 if (maybeCidr.hasError()) {
163 return makeUnexpected(CIDRNetworkError::INVALID_CIDR);
164 }
165 cidr = maybeCidr.value();
166 }
167
168 if (cidr > subnet.value().bitCount()) {
169 return makeUnexpected(CIDRNetworkError::CIDR_MISMATCH);
170 }
171
172 return std::make_pair(
173 applyMask ? subnet.value().mask(cidr) : subnet.value(), cidr);
174 }
175
176 // public static
networkToString(const CIDRNetwork & network)177 std::string IPAddress::networkToString(const CIDRNetwork& network) {
178 return fmt::format("{}/{}", network.first.str(), network.second);
179 }
180
181 // public static
fromBinary(ByteRange bytes)182 IPAddress IPAddress::fromBinary(ByteRange bytes) {
183 if (bytes.size() == 4) {
184 return IPAddress(IPAddressV4::fromBinary(bytes));
185 } else if (bytes.size() == 16) {
186 return IPAddress(IPAddressV6::fromBinary(bytes));
187 } else {
188 string hexval = detail::Bytes::toHex(bytes.data(), bytes.size());
189 throw IPAddressFormatException(
190 fmt::format("Invalid address with hex value '{}'", hexval));
191 }
192 }
193
tryFromBinary(ByteRange bytes)194 Expected<IPAddress, IPAddressFormatError> IPAddress::tryFromBinary(
195 ByteRange bytes) noexcept {
196 // Check IPv6 first since it's our main protocol.
197 if (bytes.size() == 16) {
198 return IPAddressV6::tryFromBinary(bytes);
199 } else if (bytes.size() == 4) {
200 return IPAddressV4::tryFromBinary(bytes);
201 } else {
202 return makeUnexpected(IPAddressFormatError::UNSUPPORTED_ADDR_FAMILY);
203 }
204 }
205
206 // public static
fromLong(uint32_t src)207 IPAddress IPAddress::fromLong(uint32_t src) {
208 return IPAddress(IPAddressV4::fromLong(src));
209 }
fromLongHBO(uint32_t src)210 IPAddress IPAddress::fromLongHBO(uint32_t src) {
211 return IPAddress(IPAddressV4::fromLongHBO(src));
212 }
213
214 // default constructor
IPAddress()215 IPAddress::IPAddress() : addr_(), family_(AF_UNSPEC) {}
216
217 // public string constructor
IPAddress(StringPiece str)218 IPAddress::IPAddress(StringPiece str) : addr_(), family_(AF_UNSPEC) {
219 auto maybeIp = tryFromString(str);
220 if (maybeIp.hasError()) {
221 throw IPAddressFormatException(
222 to<std::string>("Invalid IP address '", str, "'"));
223 }
224 *this = maybeIp.value();
225 }
226
tryFromString(StringPiece str)227 Expected<IPAddress, IPAddressFormatError> IPAddress::tryFromString(
228 StringPiece str) noexcept {
229 // need to check for V4 address second, since IPv4-mapped IPv6 addresses may
230 // contain a period
231 if (str.find(':') != string::npos) {
232 return IPAddressV6::tryFromString(str);
233 } else if (str.find('.') != string::npos) {
234 return IPAddressV4::tryFromString(str);
235 } else {
236 return makeUnexpected(IPAddressFormatError::UNSUPPORTED_ADDR_FAMILY);
237 }
238 }
239
240 // public sockaddr constructor
IPAddress(const sockaddr * addr)241 IPAddress::IPAddress(const sockaddr* addr) : addr_(), family_(AF_UNSPEC) {
242 if (addr == nullptr) {
243 throw IPAddressFormatException("sockaddr == nullptr");
244 }
245 family_ = addr->sa_family;
246 switch (addr->sa_family) {
247 case AF_INET: {
248 auto v4addr = reinterpret_cast<const sockaddr_in*>(addr);
249 addr_.ipV4Addr = IPAddressV4(v4addr->sin_addr);
250 break;
251 }
252 case AF_INET6: {
253 auto v6addr = reinterpret_cast<const sockaddr_in6*>(addr);
254 addr_.ipV6Addr = IPAddressV6(*v6addr);
255 break;
256 }
257 default:
258 throw InvalidAddressFamilyException(addr->sa_family);
259 }
260 }
261
262 // public ipv4 constructor
IPAddress(const IPAddressV4 ipV4Addr)263 IPAddress::IPAddress(const IPAddressV4 ipV4Addr) noexcept
264 : addr_(ipV4Addr), family_(AF_INET) {}
265
266 // public ipv4 constructor
IPAddress(const in_addr ipV4Addr)267 IPAddress::IPAddress(const in_addr ipV4Addr) noexcept
268 : addr_(IPAddressV4(ipV4Addr)), family_(AF_INET) {}
269
270 // public ipv6 constructor
IPAddress(const IPAddressV6 & ipV6Addr)271 IPAddress::IPAddress(const IPAddressV6& ipV6Addr) noexcept
272 : addr_(ipV6Addr), family_(AF_INET6) {}
273
274 // public ipv6 constructor
IPAddress(const in6_addr & ipV6Addr)275 IPAddress::IPAddress(const in6_addr& ipV6Addr) noexcept
276 : addr_(IPAddressV6(ipV6Addr)), family_(AF_INET6) {}
277
278 // Assign from V4 address
operator =(const IPAddressV4 & ipv4_addr)279 IPAddress& IPAddress::operator=(const IPAddressV4& ipv4_addr) noexcept {
280 addr_ = IPAddressV46(ipv4_addr);
281 family_ = AF_INET;
282 return *this;
283 }
284
285 // Assign from V6 address
operator =(const IPAddressV6 & ipv6_addr)286 IPAddress& IPAddress::operator=(const IPAddressV6& ipv6_addr) noexcept {
287 addr_ = IPAddressV46(ipv6_addr);
288 family_ = AF_INET6;
289 return *this;
290 }
291
292 // public
inSubnet(StringPiece cidrNetwork) const293 bool IPAddress::inSubnet(StringPiece cidrNetwork) const {
294 auto subnetInfo = IPAddress::createNetwork(cidrNetwork);
295 return inSubnet(subnetInfo.first, subnetInfo.second);
296 }
297
298 // public
inSubnet(const IPAddress & subnet,uint8_t cidr) const299 bool IPAddress::inSubnet(const IPAddress& subnet, uint8_t cidr) const {
300 if (bitCount() == subnet.bitCount()) {
301 if (isV4()) {
302 return asV4().inSubnet(subnet.asV4(), cidr);
303 } else {
304 return asV6().inSubnet(subnet.asV6(), cidr);
305 }
306 }
307 // an IPv4 address can never belong in a IPv6 subnet unless the IPv6 is a 6to4
308 // address and vice-versa
309 if (isV6()) {
310 const IPAddressV6& v6addr = asV6();
311 const IPAddressV4& v4subnet = subnet.asV4();
312 if (v6addr.is6To4()) {
313 return v6addr.getIPv4For6To4().inSubnet(v4subnet, cidr);
314 }
315 } else if (subnet.isV6()) {
316 const IPAddressV6& v6subnet = subnet.asV6();
317 const IPAddressV4& v4addr = asV4();
318 if (v6subnet.is6To4()) {
319 return v4addr.inSubnet(v6subnet.getIPv4For6To4(), cidr);
320 }
321 }
322 return false;
323 }
324
325 // public
inSubnetWithMask(const IPAddress & subnet,ByteRange mask) const326 bool IPAddress::inSubnetWithMask(
327 const IPAddress& subnet, ByteRange mask) const {
328 auto mkByteArray4 = [&]() -> ByteArray4 {
329 ByteArray4 ba{{0}};
330 std::memcpy(ba.data(), mask.begin(), std::min<size_t>(mask.size(), 4));
331 return ba;
332 };
333
334 if (bitCount() == subnet.bitCount()) {
335 if (isV4()) {
336 return asV4().inSubnetWithMask(subnet.asV4(), mkByteArray4());
337 } else {
338 ByteArray16 ba{{0}};
339 std::memcpy(ba.data(), mask.begin(), std::min<size_t>(mask.size(), 16));
340 return asV6().inSubnetWithMask(subnet.asV6(), ba);
341 }
342 }
343
344 // an IPv4 address can never belong in a IPv6 subnet unless the IPv6 is a 6to4
345 // address and vice-versa
346 if (isV6()) {
347 const IPAddressV6& v6addr = asV6();
348 const IPAddressV4& v4subnet = subnet.asV4();
349 if (v6addr.is6To4()) {
350 return v6addr.getIPv4For6To4().inSubnetWithMask(v4subnet, mkByteArray4());
351 }
352 } else if (subnet.isV6()) {
353 const IPAddressV6& v6subnet = subnet.asV6();
354 const IPAddressV4& v4addr = asV4();
355 if (v6subnet.is6To4()) {
356 return v4addr.inSubnetWithMask(v6subnet.getIPv4For6To4(), mkByteArray4());
357 }
358 }
359 return false;
360 }
361
getNthMSByte(size_t byteIndex) const362 uint8_t IPAddress::getNthMSByte(size_t byteIndex) const {
363 const auto highestIndex = byteCount() - 1;
364 if (byteIndex > highestIndex) {
365 throw std::invalid_argument(fmt::format(
366 "Byte index must be <= {} for addresses of type: {}",
367 highestIndex,
368 detail::familyNameStr(family())));
369 }
370 if (isV4()) {
371 return asV4().bytes()[byteIndex];
372 }
373 return asV6().bytes()[byteIndex];
374 }
375
376 // public
operator ==(const IPAddress & addr1,const IPAddress & addr2)377 bool operator==(const IPAddress& addr1, const IPAddress& addr2) {
378 if (addr1.empty() || addr2.empty()) {
379 return addr1.empty() == addr2.empty();
380 }
381 if (addr1.family() == addr2.family()) {
382 if (addr1.isV6()) {
383 return (addr1.asV6() == addr2.asV6());
384 } else if (addr1.isV4()) {
385 return (addr1.asV4() == addr2.asV4());
386 } else {
387 CHECK_EQ(addr1.family(), AF_UNSPEC);
388 // Two default initialized AF_UNSPEC addresses should be considered equal.
389 // AF_UNSPEC is the only other value for which an IPAddress can be
390 // created, in the default constructor case.
391 return true;
392 }
393 }
394 // addr1 is v4 mapped v6 address, addr2 is v4
395 if (addr1.isIPv4Mapped() && addr2.isV4()) {
396 if (IPAddress::createIPv4(addr1) == addr2.asV4()) {
397 return true;
398 }
399 }
400 // addr2 is v4 mapped v6 address, addr1 is v4
401 if (addr2.isIPv4Mapped() && addr1.isV4()) {
402 if (IPAddress::createIPv4(addr2) == addr1.asV4()) {
403 return true;
404 }
405 }
406 // we only compare IPv4 and IPv6 addresses
407 return false;
408 }
409
operator <(const IPAddress & addr1,const IPAddress & addr2)410 bool operator<(const IPAddress& addr1, const IPAddress& addr2) {
411 if (addr1.empty() || addr2.empty()) {
412 return addr1.empty() < addr2.empty();
413 }
414 if (addr1.family() == addr2.family()) {
415 if (addr1.isV6()) {
416 return (addr1.asV6() < addr2.asV6());
417 } else if (addr1.isV4()) {
418 return (addr1.asV4() < addr2.asV4());
419 } else {
420 CHECK_EQ(addr1.family(), AF_UNSPEC);
421 // Two default initialized AF_UNSPEC addresses can not be less than each
422 // other. AF_UNSPEC is the only other value for which an IPAddress can be
423 // created, in the default constructor case.
424 return false;
425 }
426 }
427 if (addr1.isV6()) {
428 // means addr2 is v4, convert it to a mapped v6 address and compare
429 return addr1.asV6() < addr2.asV4().createIPv6();
430 }
431 if (addr2.isV6()) {
432 // means addr2 is v6, convert addr1 to v4 mapped and compare
433 return addr1.asV4().createIPv6() < addr2.asV6();
434 }
435 return false;
436 }
437
longestCommonPrefix(const CIDRNetwork & one,const CIDRNetwork & two)438 CIDRNetwork IPAddress::longestCommonPrefix(
439 const CIDRNetwork& one, const CIDRNetwork& two) {
440 if (one.first.family() != two.first.family()) {
441 throw std::invalid_argument(fmt::format(
442 "Can't compute longest common prefix between addresses of different"
443 "families. Passed: {} and {}",
444 detail::familyNameStr(one.first.family()),
445 detail::familyNameStr(two.first.family())));
446 }
447 if (one.first.isV4()) {
448 auto prefix = IPAddressV4::longestCommonPrefix(
449 {one.first.asV4(), one.second}, {two.first.asV4(), two.second});
450 return {IPAddress(prefix.first), prefix.second};
451 } else if (one.first.isV6()) {
452 auto prefix = IPAddressV6::longestCommonPrefix(
453 {one.first.asV6(), one.second}, {two.first.asV6(), two.second});
454 return {IPAddress(prefix.first), prefix.second};
455 } else {
456 throw std::invalid_argument("Unknown address family");
457 }
458 }
459
460 // clang-format off
asV4Throw() const461 [[noreturn]] void IPAddress::asV4Throw() const {
462 auto fam = detail::familyNameStr(family());
463 throw InvalidAddressFamilyException(
464 fmt::format("Can't convert address with family {} to AF_INET address", fam));
465 }
466
asV6Throw() const467 [[noreturn]] void IPAddress::asV6Throw() const {
468 auto fam = detail::familyNameStr(family());
469 throw InvalidAddressFamilyException(
470 fmt::format("Can't convert address with family {} to AF_INET6 address", fam));
471 }
472 // clang-format on
473
474 } // namespace folly
475