X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=folly%2FIPAddress.cpp;h=2ef69d64bda0e2c8341b4e3e012aad6ec3bdaccc;hb=2c8c7ee0d43110856d9974a925f374a772786bc5;hp=78fcdbb49c3ccfdee2625f535c0a64be8ba60c7a;hpb=275ca94d04e44f28cfa411668eb1c1dd8db90b80;p=folly.git diff --git a/folly/IPAddress.cpp b/folly/IPAddress.cpp index 78fcdbb4..2ef69d64 100644 --- a/folly/IPAddress.cpp +++ b/folly/IPAddress.cpp @@ -1,5 +1,5 @@ /* - * Copyright 2015 Facebook, Inc. + * Copyright 2017 Facebook, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -21,7 +21,9 @@ #include #include +#include #include +#include using std::ostream; using std::string; @@ -44,6 +46,10 @@ void toAppend(IPAddress addr, fbstring* result) { result->append(addr.str()); } +bool IPAddress::validate(StringPiece ip) noexcept { + return IPAddressV4::validate(ip) || IPAddressV6::validate(ip); +} + // public static IPAddressV4 IPAddress::createIPv4(const IPAddress& addr) { if (addr.isV4()) { @@ -63,9 +69,10 @@ IPAddressV6 IPAddress::createIPv6(const IPAddress& addr) { } // public static -CIDRNetwork IPAddress::createNetwork(StringPiece ipSlashCidr, - int defaultCidr, /* = -1 */ - bool applyMask /* = true */) { +CIDRNetwork IPAddress::createNetwork( + StringPiece ipSlashCidr, + int defaultCidr, /* = -1 */ + bool applyMask /* = true */) { if (defaultCidr > std::numeric_limits::max()) { throw std::range_error("defaultCidr must be <= UINT8_MAX"); } @@ -75,29 +82,36 @@ CIDRNetwork IPAddress::createNetwork(StringPiece ipSlashCidr, if (elemCount == 0 || // weird invalid string elemCount > 2) { // invalid string (IP/CIDR/extras) - throw IPAddressFormatException("Invalid ipSlashCidr specified. ", - "Expected IP/CIDR format, got ", - "'", ipSlashCidr, "'"); + throw IPAddressFormatException(sformat( + "Invalid ipSlashCidr specified. Expected IP/CIDR format, got '{}'", + ipSlashCidr)); } IPAddress subnet(vec.at(0)); - uint8_t cidr = (defaultCidr > -1) ? defaultCidr : (subnet.isV4() ? 32 : 128); + auto cidr = + uint8_t((defaultCidr > -1) ? defaultCidr : (subnet.isV4() ? 32 : 128)); if (elemCount == 2) { try { cidr = to(vec.at(1)); } catch (...) { - throw IPAddressFormatException("Mask value ", - "'", vec.at(1), "' not a valid mask"); + throw IPAddressFormatException( + sformat("Mask value '{}' not a valid mask", vec.at(1))); } } if (cidr > subnet.bitCount()) { - throw IPAddressFormatException("CIDR value '", cidr, "' ", - "is > network bit count ", - "'", subnet.bitCount(), "'"); + throw IPAddressFormatException(sformat( + "CIDR value '{}' is > network bit count '{}'", + cidr, + subnet.bitCount())); } return std::make_pair(applyMask ? subnet.mask(cidr) : subnet, cidr); } +// public static +std::string IPAddress::networkToString(const CIDRNetwork& network) { + return sformat("{}/{}", network.first.str(), network.second); +} + // public static IPAddress IPAddress::fromBinary(ByteRange bytes) { if (bytes.size() == 4) { @@ -106,8 +120,20 @@ IPAddress IPAddress::fromBinary(ByteRange bytes) { return IPAddress(IPAddressV6::fromBinary(bytes)); } else { string hexval = detail::Bytes::toHex(bytes.data(), bytes.size()); - throw IPAddressFormatException("Invalid address with hex value ", - "'", hexval, "'"); + throw IPAddressFormatException( + sformat("Invalid address with hex value '{}'", hexval)); + } +} + +Expected 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); } } @@ -120,75 +146,45 @@ IPAddress IPAddress::fromLongHBO(uint32_t src) { } // default constructor -IPAddress::IPAddress() - : addr_() - , family_(AF_UNSPEC) -{ -} +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("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("Invalid IP address '", str, "'")); } + *this = std::move(maybeIp.value()); +} +Expected 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 sockaddr constructor -IPAddress::IPAddress(const sockaddr* addr) - : addr_() - , family_(AF_UNSPEC) -{ +IPAddress::IPAddress(const sockaddr* addr) : addr_(), family_(AF_UNSPEC) { if (addr == nullptr) { throw IPAddressFormatException("sockaddr == nullptr"); } family_ = addr->sa_family; switch (addr->sa_family) { case AF_INET: { - const sockaddr_in *v4addr = reinterpret_cast(addr); + const sockaddr_in* v4addr = reinterpret_cast(addr); addr_.ipV4Addr = IPAddressV4(v4addr->sin_addr); break; } case AF_INET6: { - const sockaddr_in6 *v6addr = reinterpret_cast(addr); + const sockaddr_in6* v6addr = reinterpret_cast(addr); addr_.ipV6Addr = IPAddressV6(*v6addr); break; } @@ -198,42 +194,30 @@ IPAddress::IPAddress(const sockaddr* addr) } // public ipv4 constructor -IPAddress::IPAddress(const IPAddressV4 ipV4Addr) - : addr_(ipV4Addr) - , family_(AF_INET) -{ -} +IPAddress::IPAddress(const IPAddressV4 ipV4Addr) noexcept + : addr_(ipV4Addr), family_(AF_INET) {} // public ipv4 constructor -IPAddress::IPAddress(const in_addr ipV4Addr) - : addr_(IPAddressV4(ipV4Addr)) - , family_(AF_INET) -{ -} +IPAddress::IPAddress(const in_addr ipV4Addr) noexcept + : addr_(IPAddressV4(ipV4Addr)), family_(AF_INET) {} // public ipv6 constructor -IPAddress::IPAddress(const IPAddressV6& ipV6Addr) - : addr_(ipV6Addr) - , family_(AF_INET6) -{ -} +IPAddress::IPAddress(const IPAddressV6& ipV6Addr) noexcept + : addr_(ipV6Addr), family_(AF_INET6) {} // public ipv6 constructor -IPAddress::IPAddress(const in6_addr& ipV6Addr) - : addr_(IPAddressV6(ipV6Addr)) - , family_(AF_INET6) -{ -} +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; @@ -273,8 +257,8 @@ bool IPAddress::inSubnet(const IPAddress& subnet, uint8_t cidr) const { } // public -bool IPAddress::inSubnetWithMask(const IPAddress& subnet, - ByteRange mask) const { +bool IPAddress::inSubnetWithMask(const IPAddress& subnet, ByteRange mask) + const { auto mkByteArray4 = [&]() -> ByteArray4 { ByteArray4 ba{{0}}; std::memcpy(ba.data(), mask.begin(), std::min(mask.size(), 4)); @@ -312,8 +296,9 @@ bool IPAddress::inSubnetWithMask(const IPAddress& subnet, uint8_t IPAddress::getNthMSByte(size_t byteIndex) const { const auto highestIndex = byteCount() - 1; if (byteIndex > highestIndex) { - throw std::invalid_argument(to("Byte index must be <= ", - to(highestIndex), " for addresses of type :", + throw std::invalid_argument(sformat( + "Byte index must be <= {} for addresses of type: {}", + highestIndex, detail::familyNameStr(family()))); } if (isV4()) { @@ -378,28 +363,39 @@ bool operator<(const IPAddress& addr1, const IPAddress& addr2) { return false; } -CIDRNetwork -IPAddress::longestCommonPrefix(const CIDRNetwork& one, const CIDRNetwork& two) { +CIDRNetwork IPAddress::longestCommonPrefix( + const CIDRNetwork& one, + const CIDRNetwork& two) { if (one.first.family() != two.first.family()) { - throw std::invalid_argument(to("Can't compute " - "longest common prefix between addresses of different families. " - "Passed: ", detail::familyNameStr(one.first.family()), " and ", - detail::familyNameStr(two.first.family()))); + throw std::invalid_argument(sformat( + "Can't compute longest common prefix between addresses of different" + "families. Passed: {} and {}", + detail::familyNameStr(one.first.family()), + detail::familyNameStr(two.first.family()))); } if (one.first.isV4()) { auto prefix = IPAddressV4::longestCommonPrefix( - {one.first.asV4(), one.second}, - {two.first.asV4(), two.second}); + {one.first.asV4(), one.second}, {two.first.asV4(), two.second}); return {IPAddress(prefix.first), prefix.second}; } else if (one.first.isV6()) { auto prefix = IPAddressV6::longestCommonPrefix( - {one.first.asV6(), one.second}, - {two.first.asV6(), two.second}); + {one.first.asV6(), one.second}, {two.first.asV6(), two.second}); return {IPAddress(prefix.first), prefix.second}; } else { throw std::invalid_argument("Unknown address family"); } - return {IPAddress(0), 0}; } -} // folly +[[noreturn]] void IPAddress::asV4Throw() const { + auto fam = detail::familyNameStr(family()); + throw InvalidAddressFamilyException( + sformat("Can't convert address with family {} to AF_INET address", fam)); +} + +[[noreturn]] void IPAddress::asV6Throw() const { + auto fam = detail::familyNameStr(family()); + throw InvalidAddressFamilyException( + sformat("Can't convert address with family {} to AF_INET6 address", fam)); +} + +} // namespace folly