/*
- * Copyright 2017 Facebook, Inc.
+ * Copyright 2014-present Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-
#include <folly/IPAddress.h>
#include <limits>
result->append(addr.str());
}
-bool IPAddress::validate(StringPiece ip) {
+bool IPAddress::validate(StringPiece ip) noexcept {
return IPAddressV4::validate(ip) || IPAddressV6::validate(ip);
}
}
}
+namespace {
+vector<string> splitIpSlashCidr(StringPiece ipSlashCidr) {
+ vector<string> vec;
+ split("/", ipSlashCidr, vec);
+ return vec;
+}
+} // namespace
+
// public static
CIDRNetwork IPAddress::createNetwork(
StringPiece ipSlashCidr,
int defaultCidr, /* = -1 */
bool applyMask /* = true */) {
- if (defaultCidr > std::numeric_limits<uint8_t>::max()) {
+ auto const ret =
+ IPAddress::tryCreateNetwork(ipSlashCidr, defaultCidr, applyMask);
+
+ if (ret.hasValue()) {
+ return ret.value();
+ }
+
+ if (ret.error() == CIDRNetworkError::INVALID_DEFAULT_CIDR) {
throw std::range_error("defaultCidr must be <= UINT8_MAX");
}
- vector<string> vec;
- split("/", ipSlashCidr, vec);
- vector<string>::size_type elemCount = vec.size();
- if (elemCount == 0 || // weird invalid string
- elemCount > 2) { // invalid string (IP/CIDR/extras)
+ if (ret.error() == CIDRNetworkError::INVALID_IP_SLASH_CIDR) {
throw IPAddressFormatException(sformat(
"Invalid ipSlashCidr specified. Expected IP/CIDR format, got '{}'",
ipSlashCidr));
}
- IPAddress subnet(vec.at(0));
- auto cidr =
- uint8_t((defaultCidr > -1) ? defaultCidr : (subnet.isV4() ? 32 : 128));
- if (elemCount == 2) {
- try {
- cidr = to<uint8_t>(vec.at(1));
- } catch (...) {
+ // Handler the remaining error cases. We re-parse the ip/mask pair
+ // to make error messages more meaningful
+ auto const vec = splitIpSlashCidr(ipSlashCidr);
+
+ switch (ret.error()) {
+ case CIDRNetworkError::INVALID_IP:
+ CHECK_GE(vec.size(), 1);
+ throw IPAddressFormatException(
+ sformat("Invalid IP address {}", vec.at(0)));
+ case CIDRNetworkError::INVALID_CIDR:
+ CHECK_GE(vec.size(), 2);
throw IPAddressFormatException(
sformat("Mask value '{}' not a valid mask", vec.at(1)));
+ case CIDRNetworkError::CIDR_MISMATCH: {
+ auto const subnet = IPAddress::tryFromString(vec.at(0)).value();
+ auto cidr = static_cast<uint8_t>(
+ (defaultCidr > -1) ? defaultCidr : (subnet.isV4() ? 32 : 128));
+
+ throw IPAddressFormatException(sformat(
+ "CIDR value '{}' is > network bit count '{}'",
+ vec.size() == 2 ? vec.at(1) : to<string>(cidr),
+ subnet.bitCount()));
}
+ default:
+ // unreachable
+ break;
}
- if (cidr > subnet.bitCount()) {
- throw IPAddressFormatException(sformat(
- "CIDR value '{}' is > network bit count '{}'",
- cidr,
- subnet.bitCount()));
+
+ CHECK(0);
+
+ return CIDRNetwork{};
+}
+
+// public static
+Expected<CIDRNetwork, CIDRNetworkError> IPAddress::tryCreateNetwork(
+ StringPiece ipSlashCidr,
+ int defaultCidr,
+ bool applyMask) {
+ if (defaultCidr > std::numeric_limits<uint8_t>::max()) {
+ return makeUnexpected(CIDRNetworkError::INVALID_DEFAULT_CIDR);
}
- return std::make_pair(applyMask ? subnet.mask(cidr) : subnet, cidr);
+
+ auto const vec = splitIpSlashCidr(ipSlashCidr);
+ auto const elemCount = vec.size();
+
+ if (elemCount == 0 || // weird invalid string
+ elemCount > 2) { // invalid string (IP/CIDR/extras)
+ return makeUnexpected(CIDRNetworkError::INVALID_IP_SLASH_CIDR);
+ }
+
+ auto const subnet = IPAddress::tryFromString(vec.at(0));
+ if (subnet.hasError()) {
+ return makeUnexpected(CIDRNetworkError::INVALID_IP);
+ }
+
+ auto cidr = static_cast<uint8_t>(
+ (defaultCidr > -1) ? defaultCidr : (subnet.value().isV4() ? 32 : 128));
+
+ if (elemCount == 2) {
+ auto const maybeCidr = tryTo<uint8_t>(vec.at(1));
+ if (maybeCidr.hasError()) {
+ return makeUnexpected(CIDRNetworkError::INVALID_CIDR);
+ }
+ cidr = maybeCidr.value();
+ }
+
+ if (cidr > subnet.value().bitCount()) {
+ return makeUnexpected(CIDRNetworkError::CIDR_MISMATCH);
+ }
+
+ return std::make_pair(
+ applyMask ? subnet.value().mask(cidr) : subnet.value(), cidr);
}
// public static
}
}
+Expected<IPAddress, IPAddressFormatError> IPAddress::tryFromBinary(
+ ByteRange bytes) noexcept {
+ // Check IPv6 first since it's our main protocol.
+ if (bytes.size() == 16) {
+ return IPAddressV6::tryFromBinary(bytes);
+ } else if (bytes.size() == 4) {
+ return IPAddressV4::tryFromBinary(bytes);
+ } else {
+ return makeUnexpected(IPAddressFormatError::UNSUPPORTED_ADDR_FAMILY);
+ }
+}
+
// public static
IPAddress IPAddress::fromLong(uint32_t src) {
return IPAddress(IPAddressV4::fromLong(src));
IPAddress::IPAddress() : addr_(), family_(AF_UNSPEC) {}
// public string constructor
-IPAddress::IPAddress(StringPiece addr) : addr_(), family_(AF_UNSPEC) {
- string ip = addr.str(); // inet_pton() needs NUL-terminated string
- auto throwFormatException = [&](const string& msg) {
- throw IPAddressFormatException(sformat("Invalid IP '{}': {}", ip, msg));
- };
-
- if (ip.size() < 2) {
- throwFormatException("address too short");
- }
- if (ip.front() == '[' && ip.back() == ']') {
- ip = ip.substr(1, ip.size() - 2);
+IPAddress::IPAddress(StringPiece str) : addr_(), family_(AF_UNSPEC) {
+ auto maybeIp = tryFromString(str);
+ if (maybeIp.hasError()) {
+ throw IPAddressFormatException(
+ to<std::string>("Invalid IP address '", str, "'"));
}
+ *this = std::move(maybeIp.value());
+}
+Expected<IPAddress, IPAddressFormatError> IPAddress::tryFromString(
+ StringPiece str) noexcept {
// need to check for V4 address second, since IPv4-mapped IPv6 addresses may
// contain a period
- if (ip.find(':') != string::npos) {
- struct addrinfo* result;
- struct addrinfo hints;
- memset(&hints, 0, sizeof(hints));
- hints.ai_family = AF_INET6;
- hints.ai_socktype = SOCK_STREAM;
- hints.ai_flags = AI_NUMERICHOST;
- if (!getaddrinfo(ip.c_str(), nullptr, &hints, &result)) {
- struct sockaddr_in6* ipAddr = (struct sockaddr_in6*)result->ai_addr;
- addr_ = IPAddressV46(IPAddressV6(*ipAddr));
- family_ = AF_INET6;
- freeaddrinfo(result);
- } else {
- throwFormatException("getsockaddr failed for V6 address");
- }
- } else if (ip.find('.') != string::npos) {
- in_addr ipAddr;
- if (inet_pton(AF_INET, ip.c_str(), &ipAddr) != 1) {
- throwFormatException("inet_pton failed for V4 address");
- }
- addr_ = IPAddressV46(IPAddressV4(ipAddr));
- family_ = AF_INET;
+ if (str.find(':') != string::npos) {
+ return IPAddressV6::tryFromString(str);
+ } else if (str.find('.') != string::npos) {
+ return IPAddressV4::tryFromString(str);
} else {
- throwFormatException("invalid address format");
+ return makeUnexpected(IPAddressFormatError::UNSUPPORTED_ADDR_FAMILY);
}
}
}
// public ipv4 constructor
-IPAddress::IPAddress(const IPAddressV4 ipV4Addr)
+IPAddress::IPAddress(const IPAddressV4 ipV4Addr) noexcept
: addr_(ipV4Addr), family_(AF_INET) {}
// public ipv4 constructor
-IPAddress::IPAddress(const in_addr ipV4Addr)
+IPAddress::IPAddress(const in_addr ipV4Addr) noexcept
: addr_(IPAddressV4(ipV4Addr)), family_(AF_INET) {}
// public ipv6 constructor
-IPAddress::IPAddress(const IPAddressV6& ipV6Addr)
+IPAddress::IPAddress(const IPAddressV6& ipV6Addr) noexcept
: addr_(ipV6Addr), family_(AF_INET6) {}
// public ipv6 constructor
-IPAddress::IPAddress(const in6_addr& ipV6Addr)
+IPAddress::IPAddress(const in6_addr& ipV6Addr) noexcept
: addr_(IPAddressV6(ipV6Addr)), family_(AF_INET6) {}
// Assign from V4 address
-IPAddress& IPAddress::operator=(const IPAddressV4& ipv4_addr) {
+IPAddress& IPAddress::operator=(const IPAddressV4& ipv4_addr) noexcept {
addr_ = IPAddressV46(ipv4_addr);
family_ = AF_INET;
return *this;
}
// Assign from V6 address
-IPAddress& IPAddress::operator=(const IPAddressV6& ipv6_addr) {
+IPAddress& IPAddress::operator=(const IPAddressV6& ipv6_addr) noexcept {
addr_ = IPAddressV46(ipv6_addr);
family_ = AF_INET6;
return *this;