From: Yedidya Feldblum Date: Tue, 8 Aug 2017 21:40:04 +0000 (-0700) Subject: Apply clang-format to folly/**/*Address*.* X-Git-Tag: v2017.08.14.00~5 X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=0b856bd5556ab370e029ff8f2a490db7dd4f3940;p=folly.git Apply clang-format to folly/**/*Address*.* Summary: [Folly] Apply `clang-format` to `folly/**/*Address*.*`. Reviewed By: Orvid Differential Revision: D5581523 fbshipit-source-id: 97b5270e43e279e7deb9606524d5fee844a50649 --- diff --git a/folly/IPAddress.cpp b/folly/IPAddress.cpp index 505e769d..bb79617b 100644 --- a/folly/IPAddress.cpp +++ b/folly/IPAddress.cpp @@ -69,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"); } @@ -133,18 +134,11 @@ 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 +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)); }; @@ -186,22 +180,19 @@ IPAddress::IPAddress(StringPiece addr) } // 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; } @@ -212,31 +203,19 @@ IPAddress::IPAddress(const sockaddr* addr) // public ipv4 constructor IPAddress::IPAddress(const IPAddressV4 ipV4Addr) - : addr_(ipV4Addr) - , family_(AF_INET) -{ -} + : addr_(ipV4Addr), family_(AF_INET) {} // public ipv4 constructor IPAddress::IPAddress(const in_addr ipV4Addr) - : addr_(IPAddressV4(ipV4Addr)) - , family_(AF_INET) -{ -} + : addr_(IPAddressV4(ipV4Addr)), family_(AF_INET) {} // public ipv6 constructor IPAddress::IPAddress(const IPAddressV6& ipV6Addr) - : addr_(ipV6Addr) - , family_(AF_INET6) -{ -} + : addr_(ipV6Addr), family_(AF_INET6) {} // public ipv6 constructor IPAddress::IPAddress(const in6_addr& ipV6Addr) - : addr_(IPAddressV6(ipV6Addr)) - , family_(AF_INET6) -{ -} + : addr_(IPAddressV6(ipV6Addr)), family_(AF_INET6) {} // Assign from V4 address IPAddress& IPAddress::operator=(const IPAddressV4& ipv4_addr) { @@ -286,8 +265,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)); @@ -392,8 +371,9 @@ 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(sformat( "Can't compute longest common prefix between addresses of different" @@ -403,13 +383,11 @@ IPAddress::longestCommonPrefix(const CIDRNetwork& one, const CIDRNetwork& two) { } 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"); diff --git a/folly/IPAddress.h b/folly/IPAddress.h index 853fcd60..4f453027 100644 --- a/folly/IPAddress.h +++ b/folly/IPAddress.h @@ -95,7 +95,9 @@ class IPAddress { * @return pair with IPAddress network and uint8_t mask */ static CIDRNetwork createNetwork( - StringPiece ipSlashCidr, int defaultCidr = -1, bool mask = true); + StringPiece ipSlashCidr, + int defaultCidr = -1, + bool mask = true); /** * Return a string representation of a CIDR block created with createNetwork. @@ -122,8 +124,9 @@ class IPAddress { // Given 2 IPAddress,mask pairs extract the longest common IPAddress, // mask pair - static CIDRNetwork longestCommonPrefix(const CIDRNetwork& one, - const CIDRNetwork& two); + static CIDRNetwork longestCommonPrefix( + const CIDRNetwork& one, + const CIDRNetwork& two); /** * Constructs an uninitialized IPAddress. @@ -188,10 +191,12 @@ class IPAddress { } // Return sa_family_t of IPAddress - sa_family_t family() const { return family_; } + sa_family_t family() const { + return family_; + } // Populate sockaddr_storage with an appropriate value - int toSockaddrStorage(sockaddr_storage *dest, uint16_t port = 0) const { + int toSockaddrStorage(sockaddr_storage* dest, uint16_t port = 0) const { if (dest == nullptr) { throw IPAddressFormatException("dest must not be null"); } @@ -199,7 +204,7 @@ class IPAddress { dest->ss_family = family(); if (isV4()) { - sockaddr_in *sin = reinterpret_cast(dest); + sockaddr_in* sin = reinterpret_cast(dest); sin->sin_addr = asV4().toAddr(); sin->sin_port = port; #if defined(__APPLE__) @@ -207,7 +212,7 @@ class IPAddress { #endif return sizeof(*sin); } else if (isV6()) { - sockaddr_in6 *sin = reinterpret_cast(dest); + sockaddr_in6* sin = reinterpret_cast(dest); sin->sin6_addr = asV6().toAddr(); sin->sin6_port = port; sin->sin6_scope_id = asV6().getScopeId(); @@ -260,16 +265,24 @@ class IPAddress { } // @return true if address is uninitialized - bool empty() const { return (family_ == AF_UNSPEC); } + bool empty() const { + return (family_ == AF_UNSPEC); + } // @return true if address is initialized - explicit operator bool() const { return !empty(); } + explicit operator bool() const { + return !empty(); + } // @return true if this is an IPAddressV4 instance - bool isV4() const { return (family_ == AF_INET); } + bool isV4() const { + return (family_ == AF_INET); + } // @return true if this is an IPAddressV6 instance - bool isV6() const { return (family_ == AF_INET6); } + bool isV6() const { + return (family_ == AF_INET6); + } // @return true if this address is all zeros bool isZero() const { @@ -284,17 +297,17 @@ class IPAddress { size_t byteCount() const { return bitCount() / 8; } - //get nth most significant bit - 0 indexed + // get nth most significant bit - 0 indexed bool getNthMSBit(size_t bitIndex) const { return detail::getNthMSBitImpl(*this, bitIndex, family()); } - //get nth most significant byte - 0 indexed + // get nth most significant byte - 0 indexed uint8_t getNthMSByte(size_t byteIndex) const; - //get nth bit - 0 indexed + // get nth bit - 0 indexed bool getNthLSBit(size_t bitIndex) const { return getNthMSBit(bitCount() - bitIndex - 1); } - //get nth byte - 0 indexed + // get nth byte - 0 indexed uint8_t getNthLSByte(size_t byteIndex) const { return getNthMSByte(byteCount() - byteIndex - 1); } @@ -408,8 +421,8 @@ class IPAddress { IPAddressV46() { std::memset(this, 0, sizeof(IPAddressV46)); } - explicit IPAddressV46(const IPAddressV4& addr): ipV4Addr(addr) {} - explicit IPAddressV46(const IPAddressV6& addr): ipV6Addr(addr) {} + explicit IPAddressV46(const IPAddressV4& addr) : ipV4Addr(addr) {} + explicit IPAddressV46(const IPAddressV6& addr) : ipV6Addr(addr) {} } IPAddressV46; IPAddressV46 addr_; sa_family_t family_; diff --git a/folly/IPAddressV4.cpp b/folly/IPAddressV4.cpp index 3e7704e0..c373e092 100644 --- a/folly/IPAddressV4.cpp +++ b/folly/IPAddressV4.cpp @@ -29,7 +29,6 @@ using std::string; namespace folly { - // free functions size_t hash_value(const IPAddressV4& addr) { return addr.hash(); @@ -85,19 +84,13 @@ uint32_t IPAddressV4::toLongHBO(StringPiece ip) { } // public default constructor -IPAddressV4::IPAddressV4() { -} +IPAddressV4::IPAddressV4() {} // ByteArray4 constructor -IPAddressV4::IPAddressV4(const ByteArray4& src) - : addr_(src) -{ -} +IPAddressV4::IPAddressV4(const ByteArray4& src) : addr_(src) {} // public string constructor -IPAddressV4::IPAddressV4(StringPiece addr) - : addr_() -{ +IPAddressV4::IPAddressV4(StringPiece addr) : addr_() { auto ip = addr.str(); if (inet_pton(AF_INET, ip.c_str(), &addr_.inAddr_) != 1) { throw IPAddressFormatException(sformat("Invalid IPv4 address '{}'", addr)); @@ -105,10 +98,7 @@ IPAddressV4::IPAddressV4(StringPiece addr) } // in_addr constructor -IPAddressV4::IPAddressV4(const in_addr src) - : addr_(src) -{ -} +IPAddressV4::IPAddressV4(const in_addr src) : addr_(src) {} // public void IPAddressV4::setFromBinary(ByteRange bytes) { @@ -172,11 +162,11 @@ bool IPAddressV4::inSubnet(StringPiece cidrNetwork) const { } // public -bool IPAddressV4::inSubnetWithMask(const IPAddressV4& subnet, - const ByteArray4 cidrMask) const { - const ByteArray4 mask = detail::Bytes::mask(toByteArray(), cidrMask); - const ByteArray4 subMask = detail::Bytes::mask(subnet.toByteArray(), - cidrMask); +bool IPAddressV4::inSubnetWithMask( + const IPAddressV4& subnet, + const ByteArray4 cidrMask) const { + const auto mask = detail::Bytes::mask(toByteArray(), cidrMask); + const auto subMask = detail::Bytes::mask(subnet.toByteArray(), cidrMask); return (mask == subMask); } @@ -196,24 +186,26 @@ bool IPAddressV4::isLinkLocal() const { bool IPAddressV4::isNonroutable() const { auto ip = toLongHBO(); return isPrivate() || - (ip <= 0x00FFFFFF) || // 0.0.0.0-0.255.255.255 + (/* align */ true && ip <= 0x00FFFFFF) || // 0.0.0.0-0.255.255.255 (ip >= 0xC0000000 && ip <= 0xC00000FF) || // 192.0.0.0-192.0.0.255 (ip >= 0xC0000200 && ip <= 0xC00002FF) || // 192.0.2.0-192.0.2.255 (ip >= 0xC6120000 && ip <= 0xC613FFFF) || // 198.18.0.0-198.19.255.255 (ip >= 0xC6336400 && ip <= 0xC63364FF) || // 198.51.100.0-198.51.100.255 (ip >= 0xCB007100 && ip <= 0xCB0071FF) || // 203.0.113.0-203.0.113.255 - (ip >= 0xE0000000 && ip <= 0xFFFFFFFF); // 224.0.0.0-255.255.255.255 + (ip >= 0xE0000000 && ip <= 0xFFFFFFFF) || // 224.0.0.0-255.255.255.255 + false; } // public bool IPAddressV4::isPrivate() const { auto ip = toLongHBO(); - return + return // some ranges below (ip >= 0x0A000000 && ip <= 0x0AFFFFFF) || // 10.0.0.0-10.255.255.255 (ip >= 0x7F000000 && ip <= 0x7FFFFFFF) || // 127.0.0.0-127.255.255.255 (ip >= 0xA9FE0000 && ip <= 0xA9FEFFFF) || // 169.254.0.0-169.254.255.255 (ip >= 0xAC100000 && ip <= 0xAC1FFFFF) || // 172.16.0.0-172.31.255.255 - (ip >= 0xC0A80000 && ip <= 0xC0A8FFFF); // 192.168.0.0-192.168.255.255 + (ip >= 0xC0A80000 && ip <= 0xC0A8FFFF) || // 192.168.0.0-192.168.255.255 + false; } // public diff --git a/folly/IPAddressV4.h b/folly/IPAddressV4.h index 626c974f..93651577 100644 --- a/folly/IPAddressV4.h +++ b/folly/IPAddressV4.h @@ -80,7 +80,7 @@ class IPAddressV4 { * Returns the address as a Range. */ ByteRange toBinary() const { - return ByteRange((const unsigned char *) &addr_.inAddr_.s_addr, 4); + return ByteRange((const unsigned char*)&addr_.inAddr_.s_addr, 4); } /** @@ -140,7 +140,9 @@ class IPAddressV4 { * @see IPAddress#bitCount * @returns 32 */ - static size_t bitCount() { return 32; } + static size_t bitCount() { + return 32; + } /** * @See IPAddress#toJson @@ -197,7 +199,9 @@ class IPAddressV4 { std::string toInverseArpaName() const; // return underlying in_addr structure - in_addr toAddr() const { return addr_.inAddr_; } + in_addr toAddr() const { + return addr_.inAddr_; + } sockaddr_in toSockAddr() const { sockaddr_in addr; @@ -214,13 +218,17 @@ class IPAddressV4 { } // @see IPAddress#toFullyQualified - std::string toFullyQualified() const { return str(); } + std::string toFullyQualified() const { + return str(); + } // @see IPAddress#toFullyQualifiedAppend void toFullyQualifiedAppend(std::string& out) const; // @see IPAddress#version - uint8_t version() const { return 4; } + uint8_t version() const { + return 4; + } /** * Return the mask associated with the given number of bits. @@ -238,35 +246,40 @@ class IPAddressV4 { const CIDRNetworkV4& one, const CIDRNetworkV4& two); // Number of bytes in the address representation. - static size_t byteCount() { return 4; } - //get nth most significant bit - 0 indexed + static size_t byteCount() { + return 4; + } + // get nth most significant bit - 0 indexed bool getNthMSBit(size_t bitIndex) const { return detail::getNthMSBitImpl(*this, bitIndex, AF_INET); } - //get nth most significant byte - 0 indexed + // get nth most significant byte - 0 indexed uint8_t getNthMSByte(size_t byteIndex) const; - //get nth bit - 0 indexed + // get nth bit - 0 indexed bool getNthLSBit(size_t bitIndex) const { return getNthMSBit(bitCount() - bitIndex - 1); } - //get nth byte - 0 indexed + // get nth byte - 0 indexed uint8_t getNthLSByte(size_t byteIndex) const { return getNthMSByte(byteCount() - byteIndex - 1); } - const unsigned char* bytes() const { return addr_.bytes_.data(); } + const unsigned char* bytes() const { + return addr_.bytes_.data(); + } private: union AddressStorage { - static_assert(sizeof(in_addr) == sizeof(ByteArray4), - "size of in_addr and ByteArray4 are different"); + static_assert( + sizeof(in_addr) == sizeof(ByteArray4), + "size of in_addr and ByteArray4 are different"); in_addr inAddr_; ByteArray4 bytes_; AddressStorage() { std::memset(this, 0, sizeof(AddressStorage)); } - explicit AddressStorage(const ByteArray4 bytes): bytes_(bytes) {} - explicit AddressStorage(const in_addr addr): inAddr_(addr) {} + explicit AddressStorage(const ByteArray4 bytes) : bytes_(bytes) {} + explicit AddressStorage(const in_addr addr) : inAddr_(addr) {} } addr_; /** diff --git a/folly/IPAddressV6.cpp b/folly/IPAddressV6.cpp index e77ea540..70f5c883 100644 --- a/folly/IPAddressV6.cpp +++ b/folly/IPAddressV6.cpp @@ -77,8 +77,7 @@ bool IPAddressV6::validate(StringPiece ip) { } // public default constructor -IPAddressV6::IPAddressV6() { -} +IPAddressV6::IPAddressV6() {} // public string constructor IPAddressV6::IPAddressV6(StringPiece addr) { @@ -110,28 +109,17 @@ IPAddressV6::IPAddressV6(StringPiece addr) { } // in6_addr constructor -IPAddressV6::IPAddressV6(const in6_addr& src) - : addr_(src) -{ -} +IPAddressV6::IPAddressV6(const in6_addr& src) : addr_(src) {} // sockaddr_in6 constructor IPAddressV6::IPAddressV6(const sockaddr_in6& src) - : addr_(src.sin6_addr) - , scope_(uint16_t(src.sin6_scope_id)) -{ -} + : addr_(src.sin6_addr), scope_(uint16_t(src.sin6_scope_id)) {} // ByteArray16 constructor -IPAddressV6::IPAddressV6(const ByteArray16& src) - : addr_(src) -{ -} +IPAddressV6::IPAddressV6(const ByteArray16& src) : addr_(src) {} // link-local constructor -IPAddressV6::IPAddressV6(LinkLocalTag, MacAddress mac) - : addr_(mac) { -} +IPAddressV6::IPAddressV6(LinkLocalTag, MacAddress mac) : addr_(mac) {} IPAddressV6::AddressStorage::AddressStorage(MacAddress mac) { // The link-local address uses modified EUI-64 format, @@ -228,9 +216,8 @@ static inline uint16_t unpack(uint8_t lobyte, uint8_t hibyte) { // given a src string, unpack count*2 bytes into dest // dest must have as much storage as count -static inline void unpackInto(const unsigned char* src, - uint16_t* dest, - size_t count) { +static inline void +unpackInto(const unsigned char* src, uint16_t* dest, size_t count) { for (size_t i = 0, hi = 1, lo = 0; i < count; i++) { dest[i] = unpack(src[hi], src[lo]); hi += 2; @@ -245,7 +232,7 @@ IPAddressV4 IPAddressV6::getIPv4For6To4() const { sformat("Invalid IP '{}': not a 6to4 address", str())); } // convert 16x8 bytes into first 4x16 bytes - uint16_t ints[4] = {0,0,0,0}; + uint16_t ints[4] = {0, 0, 0, 0}; unpackInto(bytes(), ints, 4); // repack into 4x8 union { @@ -281,7 +268,7 @@ bool IPAddressV6::isIPv4Mapped() const { // public IPAddressV6::Type IPAddressV6::type() const { // convert 16x8 bytes into first 2x16 bytes - uint16_t ints[2] = {0,0}; + uint16_t ints[2] = {0, 0}; unpackInto(bytes(), ints, 2); if ((((uint32_t)ints[0] << 16) | ints[1]) == IPAddressV6::PREFIX_TEREDO) { @@ -327,11 +314,11 @@ bool IPAddressV6::inSubnet(StringPiece cidrNetwork) const { } // public -bool IPAddressV6::inSubnetWithMask(const IPAddressV6& subnet, - const ByteArray16& cidrMask) const { - const ByteArray16 mask = detail::Bytes::mask(toByteArray(), cidrMask); - const ByteArray16 subMask = detail::Bytes::mask(subnet.toByteArray(), - cidrMask); +bool IPAddressV6::inSubnetWithMask( + const IPAddressV6& subnet, + const ByteArray16& cidrMask) const { + const auto mask = detail::Bytes::mask(toByteArray(), cidrMask); + const auto subMask = detail::Bytes::mask(subnet.toByteArray(), cidrMask); return (mask == subMask); } @@ -347,11 +334,11 @@ bool IPAddressV6::isLoopback() const { bool IPAddressV6::isRoutable() const { return - // 2000::/3 is the only assigned global unicast block - inBinarySubnet({{0x20, 0x00}}, 3) || - // ffxe::/16 are global scope multicast addresses, - // which are eligible to be routed over the internet - (isMulticast() && getMulticastScope() == 0xe); + // 2000::/3 is the only assigned global unicast block + inBinarySubnet({{0x20, 0x00}}, 3) || + // ffxe::/16 are global scope multicast addresses, + // which are eligible to be routed over the internet + (isMulticast() && getMulticastScope() == 0xe); } bool IPAddressV6::isLinkLocalBroadcast() const { @@ -392,11 +379,24 @@ IPAddressV6 IPAddressV6::getSolicitedNodeAddress() const { // addresses DCHECK(!isMulticast()); - uint8_t bytes[16] = { 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x01, 0xff, 0x00, 0x00, 0x00 }; - bytes[13] = addr_.bytes_[13]; - bytes[14] = addr_.bytes_[14]; - bytes[15] = addr_.bytes_[15]; + uint8_t bytes[16] = { + 0xff, + 0x02, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x01, + 0xff, + addr_.bytes_[13], + addr_.bytes_[14], + addr_.bytes_[15], + }; return IPAddressV6::fromBinary(ByteRange(bytes, 16)); } @@ -504,8 +504,9 @@ CIDRNetworkV6 IPAddressV6::longestCommonPrefix( } // protected -bool IPAddressV6::inBinarySubnet(const std::array addr, - size_t numBits) const { +bool IPAddressV6::inBinarySubnet( + const std::array addr, + size_t numBits) const { auto masked = mask(numBits); return (std::memcmp(addr.data(), masked.bytes(), 2) == 0); } diff --git a/folly/IPAddressV6.h b/folly/IPAddressV6.h index c4003202..8590993c 100644 --- a/folly/IPAddressV6.h +++ b/folly/IPAddressV6.h @@ -69,7 +69,9 @@ class IPAddressV6 { public: // V6 Address Type enum Type { - TEREDO, T6TO4, NORMAL, + TEREDO, + T6TO4, + NORMAL, }; // A constructor parameter to indicate that we should create a link-local // IPAddressV6. @@ -86,7 +88,7 @@ class IPAddressV6 { // Size of std::string returned by toFullyQualified. static constexpr size_t kToFullyQualifiedSize = - 8 /*words*/ * 4 /*hex chars per word*/ + 7 /*separators*/; + 8 /*words*/ * 4 /*hex chars per word*/ + 7 /*separators*/; // returns true iff the input string can be parsed as an ipv6-address static bool validate(StringPiece ip); @@ -112,7 +114,7 @@ class IPAddressV6 { * Returns the address as a Range. */ ByteRange toBinary() const { - return ByteRange((const unsigned char *) &addr_.in6Addr_.s6_addr, 16); + return ByteRange((const unsigned char*)&addr_.in6Addr_.s6_addr, 16); } /** @@ -171,7 +173,9 @@ class IPAddressV6 { * @see IPAddress#bitCount * @returns 128 */ - static size_t bitCount() { return 128; } + static size_t bitCount() { + return 128; + } /** * @see IPAddress#toJson @@ -188,8 +192,8 @@ class IPAddressV6 { bool inSubnet(const IPAddressV6& subnet, uint8_t cidr) const { return inSubnetWithMask(subnet, fetchMask(cidr)); } - bool inSubnetWithMask(const IPAddressV6& subnet, - const ByteArray16& mask) const; + bool inSubnetWithMask(const IPAddressV6& subnet, const ByteArray16& mask) + const; // @see IPAddress#isLoopback bool isLoopback() const; @@ -256,9 +260,13 @@ class IPAddressV6 { IPAddressV6 mask(size_t numBits) const; // return underlying in6_addr structure - in6_addr toAddr() const { return addr_.in6Addr_; } + in6_addr toAddr() const { + return addr_.in6Addr_; + } - uint16_t getScopeId() const { return scope_; } + uint16_t getScopeId() const { + return scope_; + } void setScopeId(uint16_t scope) { scope_ = scope; } @@ -290,7 +298,9 @@ class IPAddressV6 { std::string str() const; // @see IPAddress#version - uint8_t version() const { return 6; } + uint8_t version() const { + return 6; + } /** * Return the solicited-node multicast address for this address. @@ -312,32 +322,35 @@ class IPAddressV6 { const CIDRNetworkV6& one, const CIDRNetworkV6& two); // Number of bytes in the address representation. - static constexpr size_t byteCount() { return 16; } + static constexpr size_t byteCount() { + return 16; + } - //get nth most significant bit - 0 indexed + // get nth most significant bit - 0 indexed bool getNthMSBit(size_t bitIndex) const { return detail::getNthMSBitImpl(*this, bitIndex, AF_INET6); } - //get nth most significant byte - 0 indexed + // get nth most significant byte - 0 indexed uint8_t getNthMSByte(size_t byteIndex) const; - //get nth bit - 0 indexed + // get nth bit - 0 indexed bool getNthLSBit(size_t bitIndex) const { return getNthMSBit(bitCount() - bitIndex - 1); } - //get nth byte - 0 indexed + // get nth byte - 0 indexed uint8_t getNthLSByte(size_t byteIndex) const { return getNthMSByte(byteCount() - byteIndex - 1); } - const unsigned char* bytes() const { return addr_.in6Addr_.s6_addr; } + const unsigned char* bytes() const { + return addr_.in6Addr_.s6_addr; + } protected: /** * Helper that returns true if the address is in the binary subnet specified * by addr. */ - bool inBinarySubnet(const std::array addr, - size_t numBits) const; + bool inBinarySubnet(const std::array addr, size_t numBits) const; private: auto tie() const { @@ -371,8 +384,8 @@ class IPAddressV6 { AddressStorage() { std::memset(this, 0, sizeof(AddressStorage)); } - explicit AddressStorage(const ByteArray16& bytes): bytes_(bytes) {} - explicit AddressStorage(const in6_addr& addr): in6Addr_(addr) {} + explicit AddressStorage(const ByteArray16& bytes) : bytes_(bytes) {} + explicit AddressStorage(const in6_addr& addr) : in6Addr_(addr) {} explicit AddressStorage(MacAddress mac); } addr_; diff --git a/folly/MacAddress.cpp b/folly/MacAddress.cpp index 2ee684b1..c806d9b7 100644 --- a/folly/MacAddress.cpp +++ b/folly/MacAddress.cpp @@ -73,9 +73,7 @@ string MacAddress::toString() const { void MacAddress::parse(StringPiece str) { // Helper function to convert a single hex char into an integer - auto isSeparatorChar = [](char c) { - return c == ':' || c == '-'; - }; + auto isSeparatorChar = [](char c) { return c == ':' || c == '-'; }; uint8_t parsed[SIZE]; auto p = str.begin(); diff --git a/folly/MacAddress.h b/folly/MacAddress.h index 27450751..ef7c3ac1 100644 --- a/folly/MacAddress.h +++ b/folly/MacAddress.h @@ -222,8 +222,9 @@ class MacAddress { /* Define toAppend() so to will work */ template -typename std::enable_if::value>::type -toAppend(MacAddress address, Tgt* result) { +typename std::enable_if::value>::type toAppend( + MacAddress address, + Tgt* result) { toAppend(address.toString(), result); } diff --git a/folly/SocketAddress.cpp b/folly/SocketAddress.cpp index a07b02f1..6cb5a7a0 100644 --- a/folly/SocketAddress.cpp +++ b/folly/SocketAddress.cpp @@ -15,7 +15,7 @@ */ #ifndef __STDC_FORMAT_MACROS - #define __STDC_FORMAT_MACROS +#define __STDC_FORMAT_MACROS #endif #include @@ -61,18 +61,15 @@ struct ScopedAddrInfo { */ struct HostAndPort { HostAndPort(const char* str, bool hostRequired) - : host(nullptr), - port(nullptr), - allocated(nullptr) { - + : host(nullptr), port(nullptr), allocated(nullptr) { // Look for the last colon const char* colon = strrchr(str, ':'); if (colon == nullptr) { // No colon, just a port number. if (hostRequired) { throw std::invalid_argument( - "expected a host and port string of the " - "form \":\""); + "expected a host and port string of the " + "form \":\""); } port = str; return; @@ -85,7 +82,7 @@ struct HostAndPort { throw std::bad_alloc(); } - char *allocatedColon = allocated + (colon - str); + char* allocatedColon = allocated + (colon - str); *allocatedColon = '\0'; host = allocated; port = allocatedColon + 1; @@ -115,7 +112,7 @@ bool SocketAddress::isPrivateAddress() const { auto family = getFamily(); if (family == AF_INET || family == AF_INET6) { return storage_.addr.isPrivate() || - (storage_.addr.isV6() && storage_.addr.asV6().isLinkLocal()); + (storage_.addr.isV6() && storage_.addr.asV6().isLinkLocal()); } else if (external_) { // Unix addresses are always local to a host. Return true, // since this conforms to the semantics of returning true for IP loopback @@ -167,8 +164,8 @@ void SocketAddress::setFromLocalPort(const char* port) { void SocketAddress::setFromLocalIpPort(const char* addressAndPort) { HostAndPort hp(addressAndPort, false); - ScopedAddrInfo results(getAddrInfo(hp.host, hp.port, - AI_NUMERICHOST | AI_ADDRCONFIG)); + ScopedAddrInfo results( + getAddrInfo(hp.host, hp.port, AI_NUMERICHOST | AI_ADDRCONFIG)); setFromLocalAddr(results.info); } @@ -263,49 +260,50 @@ void SocketAddress::setFromSockaddr(const struct sockaddr* address) { // to be able to distinguish anonymous addresses from addresses // in Linux's abstract namespace. throw std::invalid_argument( - "SocketAddress::setFromSockaddr(): the address " - "length must be explicitly specified when " - "setting AF_UNIX addresses"); + "SocketAddress::setFromSockaddr(): the address " + "length must be explicitly specified when " + "setting AF_UNIX addresses"); } else { throw std::invalid_argument( - "SocketAddress::setFromSockaddr() called " - "with unsupported address type"); + "SocketAddress::setFromSockaddr() called " + "with unsupported address type"); } setFromIpAddrPort(folly::IPAddress(address), port); } -void SocketAddress::setFromSockaddr(const struct sockaddr* address, - socklen_t addrlen) { +void SocketAddress::setFromSockaddr( + const struct sockaddr* address, + socklen_t addrlen) { // Check the length to make sure we can access address->sa_family - if (addrlen < (offsetof(struct sockaddr, sa_family) + - sizeof(address->sa_family))) { + if (addrlen < + (offsetof(struct sockaddr, sa_family) + sizeof(address->sa_family))) { throw std::invalid_argument( - "SocketAddress::setFromSockaddr() called " - "with length too short for a sockaddr"); + "SocketAddress::setFromSockaddr() called " + "with length too short for a sockaddr"); } if (address->sa_family == AF_INET) { if (addrlen < sizeof(struct sockaddr_in)) { throw std::invalid_argument( - "SocketAddress::setFromSockaddr() called " - "with length too short for a sockaddr_in"); + "SocketAddress::setFromSockaddr() called " + "with length too short for a sockaddr_in"); } setFromSockaddr(reinterpret_cast(address)); } else if (address->sa_family == AF_INET6) { if (addrlen < sizeof(struct sockaddr_in6)) { throw std::invalid_argument( - "SocketAddress::setFromSockaddr() called " - "with length too short for a sockaddr_in6"); + "SocketAddress::setFromSockaddr() called " + "with length too short for a sockaddr_in6"); } setFromSockaddr(reinterpret_cast(address)); } else if (address->sa_family == AF_UNIX) { - setFromSockaddr(reinterpret_cast(address), - addrlen); + setFromSockaddr( + reinterpret_cast(address), addrlen); } else { throw std::invalid_argument( - "SocketAddress::setFromSockaddr() called " - "with unsupported address type"); + "SocketAddress::setFromSockaddr() called " + "with unsupported address type"); } } @@ -319,13 +317,14 @@ void SocketAddress::setFromSockaddr(const struct sockaddr_in6* address) { setFromSockaddr((sockaddr*)address); } -void SocketAddress::setFromSockaddr(const struct sockaddr_un* address, - socklen_t addrlen) { +void SocketAddress::setFromSockaddr( + const struct sockaddr_un* address, + socklen_t addrlen) { assert(address->sun_family == AF_UNIX); if (addrlen > sizeof(struct sockaddr_un)) { throw std::invalid_argument( - "SocketAddress::setFromSockaddr() called " - "with length too long for a sockaddr_un"); + "SocketAddress::setFromSockaddr() called " + "with length too long for a sockaddr_un"); } if (!external_) { @@ -337,7 +336,7 @@ void SocketAddress::setFromSockaddr(const struct sockaddr_un* address, // Fill the rest with 0s, just for safety if (addrlen < sizeof(struct sockaddr_un)) { - char *p = reinterpret_cast(storage_.un.addr); + char* p = reinterpret_cast(storage_.un.addr); memset(p + addrlen, 0, sizeof(struct sockaddr_un) - addrlen); } } @@ -362,8 +361,8 @@ socklen_t SocketAddress::getActualSize() const { return sizeof(struct sockaddr_in6); default: throw std::invalid_argument( - "SocketAddress::getActualSize() called " - "with unrecognized address family"); + "SocketAddress::getActualSize() called " + "with unrecognized address family"); } } @@ -400,8 +399,8 @@ uint16_t SocketAddress::getPort() const { return port_; default: throw std::invalid_argument( - "SocketAddress::getPort() called on non-IP " - "address"); + "SocketAddress::getPort() called on non-IP " + "address"); } } @@ -413,16 +412,16 @@ void SocketAddress::setPort(uint16_t port) { return; default: throw std::invalid_argument( - "SocketAddress::setPort() called on non-IP " - "address"); + "SocketAddress::setPort() called on non-IP " + "address"); } } void SocketAddress::convertToIPv4() { if (!tryConvertToIPv4()) { throw std::invalid_argument( - "convertToIPv4() called on an addresse that is " - "not an IPv4-mapped address"); + "convertToIPv4() called on an addresse that is " + "not an IPv4-mapped address"); } } @@ -451,8 +450,8 @@ std::string SocketAddress::getHostStr() const { std::string SocketAddress::getPath() const { if (!external_) { throw std::invalid_argument( - "SocketAddress: attempting to get path " - "for a non-Unix address"); + "SocketAddress: attempting to get path " + "for a non-Unix address"); } if (storage_.un.pathLength() == 0) { @@ -488,16 +487,14 @@ std::string SocketAddress::describe() const { switch (getFamily()) { case AF_UNSPEC: return ""; - case AF_INET: - { + case AF_INET: { char buf[NI_MAXHOST + 16]; getAddressStr(buf, sizeof(buf)); size_t iplen = strlen(buf); snprintf(buf + iplen, sizeof(buf) - iplen, ":%" PRIu16, getPort()); return buf; } - case AF_INET6: - { + case AF_INET6: { char buf[NI_MAXHOST + 18]; buf[0] = '['; getAddressStr(buf + 1, sizeof(buf) - 1); @@ -505,11 +502,9 @@ std::string SocketAddress::describe() const { snprintf(buf + iplen, sizeof(buf) - iplen, "]:%" PRIu16, getPort()); return buf; } - default: - { + default: { char buf[64]; - snprintf(buf, sizeof(buf), "", - getFamily()); + snprintf(buf, sizeof(buf), "", getFamily()); return buf; } } @@ -521,8 +516,7 @@ bool SocketAddress::operator==(const SocketAddress& other) const { } if (external_) { // anonymous addresses are never equal to any other addresses - if (storage_.un.pathLength() == 0 || - other.storage_.un.pathLength() == 0) { + if (storage_.un.pathLength() == 0 || other.storage_.un.pathLength() == 0) { return false; } @@ -539,16 +533,16 @@ bool SocketAddress::operator==(const SocketAddress& other) const { switch (getFamily()) { case AF_INET: case AF_INET6: - return (other.storage_.addr == storage_.addr) && - (other.port_ == port_); + return (other.storage_.addr == storage_.addr) && (other.port_ == port_); default: throw std::invalid_argument( - "SocketAddress: unsupported address family " - "for comparison"); + "SocketAddress: unsupported address family " + "for comparison"); } } -bool SocketAddress::prefixMatch(const SocketAddress& other, +bool SocketAddress::prefixMatch( + const SocketAddress& other, unsigned prefixLength) const { if (other.getFamily() != getFamily()) { return false; @@ -558,11 +552,9 @@ bool SocketAddress::prefixMatch(const SocketAddress& other, case AF_INET: mask_length = 32; FOLLY_FALLTHROUGH; - case AF_INET6: - { + case AF_INET6: { auto prefix = folly::IPAddress::longestCommonPrefix( - {storage_.addr, mask_length}, - {other.storage_.addr, mask_length}); + {storage_.addr, mask_length}, {other.storage_.addr, mask_length}); return prefix.second >= prefixLength; } default: @@ -570,13 +562,12 @@ bool SocketAddress::prefixMatch(const SocketAddress& other, } } - size_t SocketAddress::hash() const { size_t seed = folly::hash::twang_mix64(getFamily()); if (external_) { enum { kUnixPathMax = sizeof(storage_.un.addr->sun_path) }; - const char *path = storage_.un.addr->sun_path; + const char* path = storage_.un.addr->sun_path; auto pathLength = storage_.un.pathLength(); // TODO: this probably could be made more efficient for (off_t n = 0; n < pathLength; ++n) { @@ -597,16 +588,15 @@ size_t SocketAddress::hash() const { case AF_UNSPEC: default: throw std::invalid_argument( - "SocketAddress: unsupported address family " - "for hashing"); + "SocketAddress: unsupported address family " + "for hashing"); } return seed; } -struct addrinfo* SocketAddress::getAddrInfo(const char* host, - uint16_t port, - int flags) { +struct addrinfo* +SocketAddress::getAddrInfo(const char* host, uint16_t port, int flags) { // getaddrinfo() requires the port number as a string char portString[sizeof("65535")]; snprintf(portString, sizeof(portString), "%" PRIu16, port); @@ -614,16 +604,15 @@ struct addrinfo* SocketAddress::getAddrInfo(const char* host, return getAddrInfo(host, portString, flags); } -struct addrinfo* SocketAddress::getAddrInfo(const char* host, - const char* port, - int flags) { +struct addrinfo* +SocketAddress::getAddrInfo(const char* host, const char* port, int flags) { struct addrinfo hints; memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_flags = AI_PASSIVE | AI_NUMERICSERV | flags; - struct addrinfo *results; + struct addrinfo* results; int error = getaddrinfo(host, port, &hints, &results); if (error != 0) { auto os = folly::sformat( @@ -674,19 +663,24 @@ std::string SocketAddress::getIpString(int flags) const { return std::string(addrString); } -void SocketAddress::getIpString(char *buf, size_t buflen, int flags) const { +void SocketAddress::getIpString(char* buf, size_t buflen, int flags) const { auto family = getFamily(); - if (family != AF_INET && - family != AF_INET6) { + if (family != AF_INET && family != AF_INET6) { throw std::invalid_argument( - "SocketAddress: attempting to get IP address " - "for a non-IP address"); + "SocketAddress: attempting to get IP address " + "for a non-IP address"); } sockaddr_storage tmp_sock; storage_.addr.toSockaddrStorage(&tmp_sock, port_); - int rc = getnameinfo((sockaddr*)&tmp_sock, sizeof(sockaddr_storage), - buf, buflen, nullptr, 0, flags); + int rc = getnameinfo( + (sockaddr*)&tmp_sock, + sizeof(sockaddr_storage), + buf, + buflen, + nullptr, + 0, + flags); if (rc != 0) { auto os = sformat( "getnameinfo() failed in getIpString() error = {}", gai_strerror(rc)); @@ -697,8 +691,8 @@ void SocketAddress::getIpString(char *buf, size_t buflen, int flags) const { void SocketAddress::updateUnixAddressLength(socklen_t addrlen) { if (addrlen < offsetof(struct sockaddr_un, sun_path)) { throw std::invalid_argument( - "SocketAddress: attempted to set a Unix socket " - "with a length too short for a sockaddr_un"); + "SocketAddress: attempted to set a Unix socket " + "with a length too short for a sockaddr_un"); } storage_.un.len = addrlen; @@ -755,13 +749,12 @@ bool SocketAddress::operator<(const SocketAddress& other) const { return port_ < other.port_; } - return - storage_.addr < other.storage_.addr; + return storage_.addr < other.storage_.addr; } case AF_UNSPEC: default: throw std::invalid_argument( - "SocketAddress: unsupported address family for comparing"); + "SocketAddress: unsupported address family for comparing"); } } diff --git a/folly/SocketAddress.h b/folly/SocketAddress.h index 06c69883..31d441f7 100644 --- a/folly/SocketAddress.h +++ b/folly/SocketAddress.h @@ -47,8 +47,7 @@ class SocketAddress { * This is potentially a very slow operation, so is disabled by * default. */ - SocketAddress(const char* host, uint16_t port, - bool allowNameLookup = false) { + SocketAddress(const char* host, uint16_t port, bool allowNameLookup = false) { // Initialize the address family first, // since setFromHostPort() and setFromIpPort() will check it. @@ -59,8 +58,10 @@ class SocketAddress { } } - SocketAddress(const std::string& host, uint16_t port, - bool allowNameLookup = false) { + SocketAddress( + const std::string& host, + uint16_t port, + bool allowNameLookup = false) { // Initialize the address family first, // since setFromHostPort() and setFromIpPort() will check it. @@ -342,8 +343,7 @@ class SocketAddress { * enough for the full address type required by * address->sa_family. */ - void setFromSockaddr(const struct sockaddr* address, - socklen_t addrlen); + void setFromSockaddr(const struct sockaddr* address, socklen_t addrlen); /** * Initialize this SocketAddress from a struct sockaddr_in. @@ -367,9 +367,7 @@ class SocketAddress { * the valid bytes of sun_path, not including any NUL * terminator. */ - void setFromSockaddr(const struct sockaddr_un* address, - socklen_t addrlen); - + void setFromSockaddr(const struct sockaddr_un* address, socklen_t addrlen); /** * Fill in a given sockaddr_storage with the ip or unix address. @@ -445,8 +443,7 @@ class SocketAddress { * Return true if this is an IPv4-mapped IPv6 address. */ bool isIPv4Mapped() const { - return (getFamily() == AF_INET6 && - storage_.addr.isIPv4Mapped()); + return (getFamily() == AF_INET6 && storage_.addr.isIPv4Mapped()); } /** @@ -540,7 +537,7 @@ class SocketAddress { * the heap. */ struct ExternalUnixAddr { - struct sockaddr_un *addr; + struct sockaddr_un* addr; socklen_t len; socklen_t pathLength() const { @@ -552,12 +549,12 @@ class SocketAddress { addr->sun_family = AF_UNIX; len = 0; } - void init(const ExternalUnixAddr &other) { + void init(const ExternalUnixAddr& other) { addr = new struct sockaddr_un; len = other.len; memcpy(addr, other.addr, size_t(len)); } - void copy(const ExternalUnixAddr &other) { + void copy(const ExternalUnixAddr& other) { len = other.len; memcpy(addr, other.addr, size_t(len)); } @@ -572,7 +569,7 @@ class SocketAddress { void setFromLocalAddr(const struct addrinfo* results); void setFromSocket(int socket, int (*fn)(int, struct sockaddr*, socklen_t*)); std::string getIpString(int flags) const; - void getIpString(char *buf, size_t buflen, int flags) const; + void getIpString(char* buf, size_t buflen, int flags) const; void updateUnixAddressLength(socklen_t addrlen); @@ -603,7 +600,6 @@ class SocketAddress { size_t hash_value(const SocketAddress& address); std::ostream& operator<<(std::ostream& os, const SocketAddress& addr); - } namespace std { @@ -611,10 +607,8 @@ namespace std { // Provide an implementation for std::hash template <> struct hash { - size_t operator()( - const folly::SocketAddress& addr) const { + size_t operator()(const folly::SocketAddress& addr) const { return addr.hash(); } }; - } diff --git a/folly/detail/IPAddress.cpp b/folly/detail/IPAddress.cpp index 3076f29b..c84814fb 100644 --- a/folly/detail/IPAddress.cpp +++ b/folly/detail/IPAddress.cpp @@ -18,7 +18,8 @@ #include -namespace folly { namespace detail { +namespace folly { +namespace detail { std::string familyNameStrDefault(sa_family_t family) { return sformat("sa_family_t({})", family); @@ -30,5 +31,5 @@ std::string familyNameStrDefault(sa_family_t family) { bitCount, familyNameStr(family))); } - -}} +} // namespace detail +} // namespace folly diff --git a/folly/detail/IPAddress.h b/folly/detail/IPAddress.h index bc13a2ec..8b2c5867 100644 --- a/folly/detail/IPAddress.h +++ b/folly/detail/IPAddress.h @@ -22,7 +22,8 @@ #include -namespace folly { namespace detail { +namespace folly { +namespace detail { std::string familyNameStrDefault(sa_family_t family); @@ -49,8 +50,8 @@ getNthMSBitImpl(const IPAddrType& ip, size_t bitIndex, sa_family_t family) { if (bitIndex >= ip.bitCount()) { getNthMSBitImplThrow(ip.bitCount(), family); } - //Underlying bytes are in n/w byte order + // Underlying bytes are in n/w byte order return (ip.getNthMSByte(bitIndex / 8) & (0x80 >> (bitIndex % 8))) != 0; } - -}} // folly::detail +} // namespace detail +} // namespace folly diff --git a/folly/test/IPAddressBenchmark.cpp b/folly/test/IPAddressBenchmark.cpp index 254c725f..4e1cf14a 100644 --- a/folly/test/IPAddressBenchmark.cpp +++ b/folly/test/IPAddressBenchmark.cpp @@ -30,11 +30,8 @@ BENCHMARK(ipv4_to_string_inet_ntop, iters) { char outputString[INET_ADDRSTRLEN] = {0}; while (iters--) { - const char* val = inet_ntop( - AF_INET, - &ip, - outputString, - sizeof(outputString)); + const char* val = + inet_ntop(AF_INET, &ip, outputString, sizeof(outputString)); } } @@ -78,11 +75,8 @@ BENCHMARK(ipv6_to_string_inet_ntop, iters) { bool checkResult = (iters == 1); while (iters--) { - const char* val = inet_ntop( - AF_INET6, - &ip, - outputString, - sizeof(outputString)); + const char* val = + inet_ntop(AF_INET6, &ip, outputString, sizeof(outputString)); } } @@ -135,7 +129,7 @@ BENCHMARK_RELATIVE(ipv6_append_to_fully_qualified_port, iters) { // ipv6_append_to_fully_qualified_port 178.73% 84.35ns 11.86M // ============================================================================ -int main(int argc, char *argv[]) { +int main(int argc, char* argv[]) { gflags::ParseCommandLineFlags(&argc, &argv, true); runBenchmarks(); return 0; diff --git a/folly/test/IPAddressTest.cpp b/folly/test/IPAddressTest.cpp index 5417dd60..cc108184 100644 --- a/folly/test/IPAddressTest.cpp +++ b/folly/test/IPAddressTest.cpp @@ -244,7 +244,7 @@ TEST(IPAddress, InvalidAddressFamilyExceptions) { sockaddr_in addr; addr.sin_family = AF_UNSPEC; - EXPECT_THROW(IPAddress((sockaddr *)&addr), InvalidAddressFamilyException); + EXPECT_THROW(IPAddress((sockaddr*)&addr), InvalidAddressFamilyException); } } @@ -284,14 +284,14 @@ TEST(IPAddress, CreateNetwork) { // test empty string EXPECT_THROW(IPAddress::createNetwork(""), IPAddressFormatException); // test multi slash string - EXPECT_THROW(IPAddress::createNetwork("192.168.0.1/24/36"), - IPAddressFormatException); + EXPECT_THROW( + IPAddress::createNetwork("192.168.0.1/24/36"), IPAddressFormatException); // test no slash string with default IPv4 { auto net = IPAddress::createNetwork("192.168.0.1"); ASSERT_TRUE(net.first.isV4()); EXPECT_EQ("192.168.0.1", net.first.str()); - EXPECT_EQ(32, net.second); // auto-detected + EXPECT_EQ(32, net.second); // auto-detected net = IPAddress::createNetwork("192.168.0.1", -1, false); ASSERT_TRUE(net.first.isV4()); EXPECT_EQ("192.168.0.1", net.first.str()); @@ -305,9 +305,8 @@ TEST(IPAddress, CreateNetwork) { EXPECT_EQ(128, net.second); } // test no slash string with invalid default - EXPECT_THROW(IPAddress::createNetwork("192.168.0.1", 33), - IPAddressFormatException); - + EXPECT_THROW( + IPAddress::createNetwork("192.168.0.1", 33), IPAddressFormatException); } // test assignment operators @@ -450,7 +449,7 @@ TEST(IPAddress, CtorSockaddr) { addr.sin_family = AF_INET; addr.sin_addr = sin_addr; - IPAddress ipAddr((sockaddr *)&addr); + IPAddress ipAddr((sockaddr*)&addr); EXPECT_TRUE(ipAddr.isV4()); EXPECT_EQ("126.131.128.23", ipAddr.str()); } @@ -460,21 +459,20 @@ TEST(IPAddress, CtorSockaddr) { sockaddr_in6 addr; memset(&addr, 0, sizeof(addr)); in6_addr sin_addr; - ByteArray16 sec{{ - // 2620:0:1cfe:face:b00c::3 - 38,32,0,0,28,254,250,206,176,12,0,0,0,0,0,3 - }}; + // 2620:0:1cfe:face:b00c::3 + ByteArray16 sec{ + {38, 32, 0, 0, 28, 254, 250, 206, 176, 12, 0, 0, 0, 0, 0, 3}}; std::memcpy(sin_addr.s6_addr, sec.data(), 16); addr.sin6_family = AF_INET6; addr.sin6_addr = sin_addr; - IPAddress ipAddr((sockaddr *)&addr); + IPAddress ipAddr((sockaddr*)&addr); EXPECT_TRUE(ipAddr.isV6()); EXPECT_EQ("2620:0:1cfe:face:b00c::3", ipAddr.str()); } // test nullptr exception { - sockaddr *addr = nullptr; + sockaddr* addr = nullptr; EXPECT_THROW(IPAddress((const sockaddr*)addr), IPAddressFormatException); } // test invalid family exception @@ -486,7 +484,7 @@ TEST(IPAddress, CtorSockaddr) { addr.sin_family = AF_UNSPEC; addr.sin_addr = sin_addr; - EXPECT_THROW(IPAddress((sockaddr *)&addr), IPAddressFormatException); + EXPECT_THROW(IPAddress((sockaddr*)&addr), IPAddressFormatException); } } @@ -519,7 +517,7 @@ TEST(IPAddress, ToSockaddrStorage) { } // test nullptr exception { - sockaddr_storage *out = nullptr; + sockaddr_storage* out = nullptr; IPAddress addr("127.0.0.1"); EXPECT_THROW(addr.toSockaddrStorage(out), IPAddressFormatException); } @@ -546,9 +544,16 @@ TEST(IPAddress, ToString) { EXPECT_EQ("1:2::3", folly::to(addr_1_2_3)); // Test a combination of all the above arguments - EXPECT_EQ("1:2::3 - 10.0.0.1 - ::1 - 10.1.2.3", - folly::to(addr_1_2_3, " - ", addr_10_0_0_1, - " - ", addr_1, " - ", addr_10_1_2_3)); + EXPECT_EQ( + "1:2::3 - 10.0.0.1 - ::1 - 10.1.2.3", + folly::to( + addr_1_2_3, + " - ", + addr_10_0_0_1, + " - ", + addr_1, + " - ", + addr_10_1_2_3)); } TEST(IPaddress, toInverseArpaName) { @@ -584,8 +589,9 @@ TEST_P(IPAddressCtorTest, InvalidCreation) { // Test that invalid binary values throw an exception TEST_P(IPAddressCtorBinaryTest, InvalidBinary) { auto bin = GetParam(); - EXPECT_THROW(IPAddress::fromBinary(ByteRange(&bin[0], bin.size())), - IPAddressFormatException); + EXPECT_THROW( + IPAddress::fromBinary(ByteRange(&bin[0], bin.size())), + IPAddressFormatException); } TEST(IPAddressSource, ToHex) { @@ -716,9 +722,9 @@ TEST(IPAddress, InSubnetWith6to4) { } static const vector ipv4Strs = { - "127.0.0.1", - "198.168.0.1", - "8.8.0.0", + "127.0.0.1", + "198.168.0.1", + "8.8.0.0", }; TEST(IPAddress, getIPv6For6To4) { for (auto ipv4Str : ipv4Strs) { @@ -732,9 +738,9 @@ TEST(IPAddress, getIPv6For6To4) { } } -static const vector > invalidMasks = { - {"127.0.0.1", 33}, - {"::1", 129}, +static const vector> invalidMasks = { + {"127.0.0.1", 33}, + {"::1", 129}, }; TEST(IPAddress, InvalidMask) { for (auto& tc : invalidMasks) { @@ -743,11 +749,11 @@ TEST(IPAddress, InvalidMask) { } } -static const vector > v6types = { - {"::1", IPAddressV6::Type::NORMAL}, - {"2620:0:1cfe:face:b00c::3", IPAddressV6::Type::NORMAL}, - {"2001:0000:4136:e378:8000:63bf:3fff:fdd2", IPAddressV6::Type::TEREDO}, - {"2002:c000:022a::", IPAddressV6::Type::T6TO4}, +static const vector> v6types = { + {"::1", IPAddressV6::Type::NORMAL}, + {"2620:0:1cfe:face:b00c::3", IPAddressV6::Type::NORMAL}, + {"2001:0000:4136:e378:8000:63bf:3fff:fdd2", IPAddressV6::Type::TEREDO}, + {"2002:c000:022a::", IPAddressV6::Type::T6TO4}, }; TEST(IPAddress, V6Types) { auto mkName = [&](const IPAddressV6::Type t) -> string { @@ -786,11 +792,11 @@ TEST(IPAddress, V6Types) { } } -static const vector > provideToLong = { - {"0.0.0.0", 0}, - {"10.0.0.0", 167772160}, - {"126.131.128.23", 2122547223}, - {"192.168.0.0", 3232235520}, +static const vector> provideToLong = { + {"0.0.0.0", 0}, + {"10.0.0.0", 167772160}, + {"126.131.128.23", 2122547223}, + {"192.168.0.0", 3232235520}, }; TEST(IPAddress, ToLong) { for (auto& tc : provideToLong) { @@ -837,12 +843,12 @@ TEST(IPAddress, fromBinaryV4) { } uint8_t data[20]; - EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 3)), - IPAddressFormatException); - EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 16)), - IPAddressFormatException); - EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 20)), - IPAddressFormatException); + EXPECT_THROW( + IPAddressV4::fromBinary(ByteRange(data, 3)), IPAddressFormatException); + EXPECT_THROW( + IPAddressV4::fromBinary(ByteRange(data, 16)), IPAddressFormatException); + EXPECT_THROW( + IPAddressV4::fromBinary(ByteRange(data, 20)), IPAddressFormatException); } TEST(IPAddress, toBinaryV4) { @@ -861,22 +867,44 @@ TEST(IPAddress, toBinaryV4) { } } -static const vector > > provideBinary16Bytes = { - {"::0", - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}, - {"1::2", - {0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}}, - {"fe80::0012:34ff:fe56:78ab", - {0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x12, 0x34, 0xff, 0xfe, 0x56, 0x78, 0xab}}, - {"2001:db8:1234:5678:90ab:cdef:8765:4321", - {0x20, 0x01, 0x0d, 0xb8, 0x12, 0x34, 0x56, 0x78, - 0x90, 0xab, 0xcd, 0xef, 0x87, 0x65, 0x43, 0x21}}, - {"::ffff:0:c0a8:1", - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xff, 0xff, 0x00, 0x00, 0xc0, 0xa8, 0x00, 0x01}}, +using ByteArray8 = std::array; + +static auto join8 = [](std::array parts) { + ByteArray16 _return; + std::memcpy(_return.data(), parts.data(), _return.size()); + return _return; +}; + +static const vector> provideBinary16Bytes = { + make_pair( + "::0", + join8({{ + ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}, + ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}, + }})), + make_pair( + "1::2", + join8({{ + ByteArray8{{0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}, + ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}}, + }})), + make_pair( + "fe80::0012:34ff:fe56:78ab", + join8( + {{ByteArray8{{0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}, + ByteArray8{{0x00, 0x12, 0x34, 0xff, 0xfe, 0x56, 0x78, 0xab}}}})), + make_pair( + "2001:db8:1234:5678:90ab:cdef:8765:4321", + join8({{ + ByteArray8{{0x20, 0x01, 0x0d, 0xb8, 0x12, 0x34, 0x56, 0x78}}, + ByteArray8{{0x90, 0xab, 0xcd, 0xef, 0x87, 0x65, 0x43, 0x21}}, + }})), + make_pair( + "::ffff:0:c0a8:1", + join8({{ + ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}, + ByteArray8{{0xff, 0xff, 0x00, 0x00, 0xc0, 0xa8, 0x00, 0x01}}, + }})), }; TEST(IPAddress, fromBinaryV6) { @@ -899,12 +927,12 @@ TEST(IPAddress, fromBinaryV6) { } uint8_t data[20]; - EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 3)), - IPAddressFormatException); - EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 4)), - IPAddressFormatException); - EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 20)), - IPAddressFormatException); + EXPECT_THROW( + IPAddressV6::fromBinary(ByteRange(data, 3)), IPAddressFormatException); + EXPECT_THROW( + IPAddressV6::fromBinary(ByteRange(data, 4)), IPAddressFormatException); + EXPECT_THROW( + IPAddressV6::fromBinary(ByteRange(data, 20)), IPAddressFormatException); } TEST(IPAddress, toBinaryV6) { @@ -973,13 +1001,15 @@ TEST_P(IPAddressFlagTest, IsLinkLocalBroadcast) { TEST(IPAddress, SolicitedNodeAddress) { // An example from RFC 4291 section 2.7.1 - EXPECT_EQ(IPAddressV6("ff02::1:ff0e:8c6c"), - IPAddressV6("4037::01:800:200e:8c6c").getSolicitedNodeAddress()); + EXPECT_EQ( + IPAddressV6("ff02::1:ff0e:8c6c"), + IPAddressV6("4037::01:800:200e:8c6c").getSolicitedNodeAddress()); // An example from wikipedia // (http://en.wikipedia.org/wiki/Solicited-node_multicast_address) - EXPECT_EQ(IPAddressV6("ff02::1:ff28:9c5a"), - IPAddressV6("fe80::2aa:ff:fe28:9c5a").getSolicitedNodeAddress()); + EXPECT_EQ( + IPAddressV6("ff02::1:ff28:9c5a"), + IPAddressV6("fe80::2aa:ff:fe28:9c5a").getSolicitedNodeAddress()); } TEST_P(IPAddressByteAccessorTest, CheckBytes) { @@ -988,42 +1018,46 @@ TEST_P(IPAddressByteAccessorTest, CheckBytes) { size_t i = 0; for (auto byitr = addrData.bytes.begin(); i < ip.byteCount(); ++i, ++byitr) { EXPECT_EQ(*byitr, ip.getNthMSByte(i)); - EXPECT_EQ(*byitr, ip.isV4() ? - ip.asV4().getNthMSByte(i) : ip.asV6().getNthMSByte(i)); + EXPECT_EQ( + *byitr, + ip.isV4() ? ip.asV4().getNthMSByte(i) : ip.asV6().getNthMSByte(i)); } i = 0; - for (auto byritr = addrData.bytes.rbegin(); i < ip.byteCount(); ++i, - ++byritr) { + for (auto byritr = addrData.bytes.rbegin(); i < ip.byteCount(); + ++i, ++byritr) { EXPECT_EQ(*byritr, ip.getNthLSByte(i)); - EXPECT_EQ(*byritr, ip.isV4() ? - ip.asV4().getNthLSByte(i) : ip.asV6().getNthLSByte(i)); + EXPECT_EQ( + *byritr, + ip.isV4() ? ip.asV4().getNthLSByte(i) : ip.asV6().getNthLSByte(i)); } } TEST_P(IPAddressBitAccessorTest, CheckBits) { auto addrData = GetParam(); auto littleEndianAddrData = addrData.bytes; - //IPAddress stores address data in n/w byte order. + // IPAddress stores address data in n/w byte order. reverse(littleEndianAddrData.begin(), littleEndianAddrData.end()); - //Bit iterator goes from LSBit to MSBit - //We will traverse the IPAddress bits from 0 to bitCount -1 + // Bit iterator goes from LSBit to MSBit + // We will traverse the IPAddress bits from 0 to bitCount -1 auto bitr = folly::makeBitIterator(littleEndianAddrData.begin()); IPAddress ip(addrData.address); for (size_t i = 0; i < ip.bitCount(); ++i) { auto msbIndex = ip.bitCount() - i - 1; EXPECT_EQ(*bitr, ip.getNthMSBit(msbIndex)); - EXPECT_EQ(*bitr, ip.isV4() ? ip.asV4().getNthMSBit(msbIndex) : - ip.asV6().getNthMSBit(msbIndex)); + EXPECT_EQ( + *bitr, + ip.isV4() ? ip.asV4().getNthMSBit(msbIndex) + : ip.asV6().getNthMSBit(msbIndex)); EXPECT_EQ(*bitr, ip.getNthLSBit(i)); - EXPECT_EQ(*bitr, ip.isV4() ? ip.asV4().getNthLSBit(i) : - ip.asV6().getNthLSBit(i)); + EXPECT_EQ( + *bitr, ip.isV4() ? ip.asV4().getNthLSBit(i) : ip.asV6().getNthLSBit(i)); ++bitr; } } TEST(IPAddress, InvalidByteAccess) { IPAddress ip4("10.10.10.10"); - //MSByte, LSByte accessors are 0 indexed + // MSByte, LSByte accessors are 0 indexed EXPECT_THROW(ip4.getNthMSByte(ip4.byteCount()), std::invalid_argument); EXPECT_THROW(ip4.getNthLSByte(ip4.byteCount()), std::invalid_argument); EXPECT_THROW(ip4.getNthMSByte(-1), std::invalid_argument); @@ -1044,12 +1078,11 @@ TEST(IPAddress, InvalidByteAccess) { EXPECT_THROW(asV6.getNthLSByte(asV6.byteCount()), std::invalid_argument); EXPECT_THROW(asV6.getNthMSByte(-1), std::invalid_argument); EXPECT_THROW(asV6.getNthLSByte(-1), std::invalid_argument); - } TEST(IPAddress, InvalidBBitAccess) { IPAddress ip4("10.10.10.10"); - //MSByte, LSByte accessors are 0 indexed + // MSByte, LSByte accessors are 0 indexed EXPECT_THROW(ip4.getNthMSBit(ip4.bitCount()), std::invalid_argument); EXPECT_THROW(ip4.getNthLSBit(ip4.bitCount()), std::invalid_argument); EXPECT_THROW(ip4.getNthMSBit(-1), std::invalid_argument); @@ -1082,8 +1115,8 @@ TEST(IPAddress, StringFormat) { a6.s6_addr16[i] = t; #endif } - EXPECT_EQ("0123:4567:89ab:cdef:0123:4567:89ab:cdef", - detail::fastIpv6ToString(a6)); + EXPECT_EQ( + "0123:4567:89ab:cdef:0123:4567:89ab:cdef", detail::fastIpv6ToString(a6)); in_addr a4; a4.s_addr = htonl(0x01020304); @@ -1114,8 +1147,8 @@ TEST(IPAddress, LongestCommonPrefix) { IPAddress ip128("128.0.0.0"); IPAddress ip10dot10("10.10.0.0"); auto prefix = IPAddress::longestCommonPrefix({ip10, 8}, {ip128, 8}); - auto prefix4 = IPAddressV4::longestCommonPrefix({ip10.asV4(), 8}, - {ip128.asV4(), 8}); + auto prefix4 = + IPAddressV4::longestCommonPrefix({ip10.asV4(), 8}, {ip128.asV4(), 8}); // No bits match b/w 128/8 and 10/8 EXPECT_EQ(IPAddress("0.0.0.0"), prefix.first); EXPECT_EQ(0, prefix.second); @@ -1123,8 +1156,8 @@ TEST(IPAddress, LongestCommonPrefix) { EXPECT_EQ(0, prefix4.second); prefix = IPAddress::longestCommonPrefix({ip10, 8}, {ip10dot10, 16}); - prefix4 = IPAddressV4::longestCommonPrefix({ip10.asV4(), 8}, - {ip10dot10.asV4(), 16}); + prefix4 = IPAddressV4::longestCommonPrefix( + {ip10.asV4(), 8}, {ip10dot10.asV4(), 16}); // Between 10/8 and 10.10/16, 10/8 is the longest common match EXPECT_EQ(ip10, prefix.first); EXPECT_EQ(8, prefix.second); @@ -1132,8 +1165,8 @@ TEST(IPAddress, LongestCommonPrefix) { EXPECT_EQ(8, prefix4.second); prefix = IPAddress::longestCommonPrefix({ip11, 8}, {ip12, 8}); - prefix4 = IPAddressV4::longestCommonPrefix({ip11.asV4(), 8}, - {ip12.asV4(), 8}); + prefix4 = + IPAddressV4::longestCommonPrefix({ip11.asV4(), 8}, {ip12.asV4(), 8}); // 12 = 1100, 11 = 1011, longest match - 1000 = 8 EXPECT_EQ(IPAddress("8.0.0.0"), prefix.first); EXPECT_EQ(5, prefix.second); @@ -1142,19 +1175,19 @@ TEST(IPAddress, LongestCommonPrefix) { // Between 128/1 and 128/2, longest match 128/1 prefix = IPAddress::longestCommonPrefix({ip128, 1}, {ip128, 2}); - prefix4 = IPAddressV4::longestCommonPrefix({ip128.asV4(), 1}, - {ip128.asV4(), 2}); + prefix4 = + IPAddressV4::longestCommonPrefix({ip128.asV4(), 1}, {ip128.asV4(), 2}); EXPECT_EQ(ip128, prefix.first); EXPECT_EQ(1, prefix.second); EXPECT_EQ(ip128.asV4(), prefix4.first); EXPECT_EQ(1, prefix4.second); IPAddress ip6("2620:0:1cfe:face:b00c::3"); - prefix = IPAddress::longestCommonPrefix({ip6, ip6.bitCount()}, - {ip6, ip6.bitCount()}); + prefix = IPAddress::longestCommonPrefix( + {ip6, ip6.bitCount()}, {ip6, ip6.bitCount()}); auto prefix6 = IPAddressV6::longestCommonPrefix( - {ip6.asV6(), IPAddressV6::bitCount()}, - {ip6.asV6(), IPAddressV6::bitCount()}); + {ip6.asV6(), IPAddressV6::bitCount()}, + {ip6.asV6(), IPAddressV6::bitCount()}); // Longest common b/w me and myself is myself EXPECT_EQ(ip6, prefix.first); EXPECT_EQ(ip6.bitCount(), prefix.second); @@ -1164,61 +1197,63 @@ TEST(IPAddress, LongestCommonPrefix) { IPAddress ip6Zero("::"); prefix = IPAddress::longestCommonPrefix({ip6, ip6.bitCount()}, {ip6Zero, 0}); prefix6 = IPAddressV6::longestCommonPrefix( - {ip6.asV6(), IPAddressV6::bitCount()}, - {ip6Zero.asV6(), 0}); + {ip6.asV6(), IPAddressV6::bitCount()}, {ip6Zero.asV6(), 0}); // Longest common b/w :: (ipv6 equivalent of 0/0) is :: EXPECT_EQ(ip6Zero, prefix.first); EXPECT_EQ(0, prefix.second); // Exceptional cases - EXPECT_THROW(IPAddress::longestCommonPrefix({ip10, 8}, {ip6, 128}), - std::invalid_argument); - EXPECT_THROW(IPAddress::longestCommonPrefix({ip10, ip10.bitCount() + 1}, - {ip10, 8}), - std::invalid_argument); - EXPECT_THROW(IPAddressV4::longestCommonPrefix( - {ip10.asV4(), IPAddressV4::bitCount() + 1}, - {ip10.asV4(), 8}), - std::invalid_argument); - EXPECT_THROW(IPAddress::longestCommonPrefix({ip6, ip6.bitCount() + 1}, - {ip6, ip6.bitCount()}), - std::invalid_argument); - EXPECT_THROW(IPAddressV6::longestCommonPrefix( - {ip6.asV6(), IPAddressV6::bitCount() + 1}, - {ip6.asV6(), IPAddressV6::bitCount()}), - std::invalid_argument); - + EXPECT_THROW( + IPAddress::longestCommonPrefix({ip10, 8}, {ip6, 128}), + std::invalid_argument); + EXPECT_THROW( + IPAddress::longestCommonPrefix({ip10, ip10.bitCount() + 1}, {ip10, 8}), + std::invalid_argument); + EXPECT_THROW( + IPAddressV4::longestCommonPrefix( + {ip10.asV4(), IPAddressV4::bitCount() + 1}, {ip10.asV4(), 8}), + std::invalid_argument); + EXPECT_THROW( + IPAddress::longestCommonPrefix( + {ip6, ip6.bitCount() + 1}, {ip6, ip6.bitCount()}), + std::invalid_argument); + EXPECT_THROW( + IPAddressV6::longestCommonPrefix( + {ip6.asV6(), IPAddressV6::bitCount() + 1}, + {ip6.asV6(), IPAddressV6::bitCount()}), + std::invalid_argument); } static const vector validAddressProvider = { - AddressData("127.0.0.1", {127,0,0,1}, 4), - AddressData("69.63.189.16", {69,63,189,16}, 4), - AddressData("0.0.0.0", {0,0,0,0}, 4), - AddressData("::1", - {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}, 6), - AddressData("2620:0:1cfe:face:b00c::3", - {38,32,0,0,28,254,250,206,176,12,0,0,0,0,0,3}, 6), + AddressData("127.0.0.1", {127, 0, 0, 1}, 4), + AddressData("69.63.189.16", {69, 63, 189, 16}, 4), + AddressData("0.0.0.0", {0, 0, 0, 0}, 4), + AddressData("::1", {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}, 6), + AddressData( + "2620:0:1cfe:face:b00c::3", + {38, 32, 0, 0, 28, 254, 250, 206, 176, 12, 0, 0, 0, 0, 0, 3}, + 6), }; static const vector invalidAddressProvider = { - "", - "foo", - "1.1.1.256", - "1", - ":1", - "127.0.0.1,127.0.0.1", - "[1234]", + "", + "foo", + "1.1.1.256", + "1", + ":1", + "127.0.0.1,127.0.0.1", + "[1234]", }; static const vector invalidBinaryProvider = { - {0x31, 0x32, 0x37, 0x2e, 0x30, 0x30, 0x2e, 0x30, 0x2e, 0x31}, - // foo - {0x66, 0x6f, 0x6f}, - {0x00}, - {0x00, 0x00}, - {0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00}, - {0xff}, + {0x31, 0x32, 0x37, 0x2e, 0x30, 0x30, 0x2e, 0x30, 0x2e, 0x31}, + // foo + {0x66, 0x6f, 0x6f}, + {0x00}, + {0x00, 0x00}, + {0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00}, + {0xff}, }; static const uint8_t IS_LOCAL = AddressFlags::IS_LOCAL; @@ -1226,176 +1261,188 @@ static const uint8_t IS_NONROUTABLE = AddressFlags::IS_NONROUTABLE; static const uint8_t IS_PRIVATE = AddressFlags::IS_PRIVATE; static const uint8_t IS_ZERO = AddressFlags::IS_ZERO; static const uint8_t IS_LINK_LOCAL = - AddressFlags::IS_LINK_LOCAL | IS_NONROUTABLE; + AddressFlags::IS_LINK_LOCAL | IS_NONROUTABLE; static const uint8_t IS_PVT_NONROUTE = IS_NONROUTABLE | IS_PRIVATE; static const uint8_t IS_MULTICAST = AddressFlags::IS_MULTICAST; static const uint8_t IS_LINK_LOCAL_BROADCAST = -AddressFlags::IS_LINK_LOCAL_BROADCAST; + AddressFlags::IS_LINK_LOCAL_BROADCAST; static vector flagProvider = { - // public v4 - AddressFlags("69.63.176.1", 4, 0), - AddressFlags("128.12.65.3", 4, 0), - AddressFlags("192.0.1.0", 4, 0), - AddressFlags("198.51.101.0", 4, 0), - AddressFlags("203.0.114.0", 4, 0), - AddressFlags("128.12.64.115", 4, 0), - - // public v6 - AddressFlags("2620:0:1cfe:face:b00c::3", 6, 0), - - // localhost - AddressFlags("127.0.0.1", 4, IS_LOCAL | IS_PVT_NONROUTE), - AddressFlags("::1", 6, IS_LOCAL | IS_PVT_NONROUTE), - - // link-local v4 - AddressFlags("169.254.0.1", 4, IS_LINK_LOCAL | IS_PVT_NONROUTE), - - // private v4 - AddressFlags("10.0.0.0", 4, IS_PVT_NONROUTE), - AddressFlags("10.11.12.13", 4, IS_PVT_NONROUTE), - AddressFlags("10.255.255.255", 4, IS_PVT_NONROUTE), - AddressFlags("127.128.129.200", 4, IS_LOCAL | IS_PVT_NONROUTE), - AddressFlags("127.255.255.255", 4, IS_LOCAL | IS_PVT_NONROUTE), - AddressFlags("169.254.0.0", 4, IS_LINK_LOCAL | IS_PVT_NONROUTE), - AddressFlags("192.168.0.0", 4, IS_PVT_NONROUTE), - AddressFlags("192.168.200.255", 4, IS_PVT_NONROUTE), - AddressFlags("192.168.255.255", 4, IS_PVT_NONROUTE), - - // private v6 - AddressFlags("fd01:1637:1c56:66af::", 6, IS_PVT_NONROUTE), - - // non routable v4 - AddressFlags("0.0.0.0", 4, IS_NONROUTABLE | IS_ZERO), - AddressFlags("0.255.255.255", 4, IS_NONROUTABLE), - AddressFlags("192.0.0.0", 4, IS_NONROUTABLE), - AddressFlags("192.0.2.0", 4, IS_NONROUTABLE), - AddressFlags("198.18.0.0", 4, IS_NONROUTABLE), - AddressFlags("198.19.255.255", 4, IS_NONROUTABLE), - AddressFlags("198.51.100.0", 4, IS_NONROUTABLE), - AddressFlags("198.51.100.255", 4, IS_NONROUTABLE), - AddressFlags("203.0.113.0", 4, IS_NONROUTABLE), - AddressFlags("203.0.113.255", 4, IS_NONROUTABLE), - AddressFlags("224.0.0.0", 4, IS_NONROUTABLE | IS_MULTICAST), - AddressFlags("240.0.0.0", 4, IS_NONROUTABLE), - AddressFlags("224.0.0.0", 4, IS_NONROUTABLE), - // v4 link local broadcast - AddressFlags("255.255.255.255", 4, IS_NONROUTABLE | IS_LINK_LOCAL_BROADCAST), - - // non routable v6 - AddressFlags("1999::1", 6, IS_NONROUTABLE), - AddressFlags("0::0", 6, IS_NONROUTABLE | IS_ZERO), - AddressFlags("0::0:0", 6, IS_NONROUTABLE | IS_ZERO), - AddressFlags("0:0:0::0", 6, IS_NONROUTABLE | IS_ZERO), - - // link-local v6 - AddressFlags("fe80::0205:73ff:fef9:46fc", 6, IS_LINK_LOCAL), - AddressFlags("fe80::0012:34ff:fe56:7890", 6, IS_LINK_LOCAL), - - // multicast v4 - AddressFlags("224.0.0.1", 4, IS_MULTICAST | IS_NONROUTABLE) , - AddressFlags("224.0.0.251", 4, IS_MULTICAST | IS_NONROUTABLE), - AddressFlags("239.12.34.56", 4, IS_MULTICAST | IS_NONROUTABLE), - - // multicast v6 - AddressFlags("ff00::", 6, IS_MULTICAST | IS_NONROUTABLE), - AddressFlags("ff02:ffff::1", 6, IS_MULTICAST | IS_NONROUTABLE), - AddressFlags("ff02::101", 6, IS_MULTICAST | IS_NONROUTABLE), - AddressFlags("ff0e::101", 6, IS_MULTICAST), - // v6 link local broadcast - AddressFlags("ff02::1", 6, IS_NONROUTABLE | IS_LINK_LOCAL_BROADCAST), + // public v4 + AddressFlags("69.63.176.1", 4, 0), + AddressFlags("128.12.65.3", 4, 0), + AddressFlags("192.0.1.0", 4, 0), + AddressFlags("198.51.101.0", 4, 0), + AddressFlags("203.0.114.0", 4, 0), + AddressFlags("128.12.64.115", 4, 0), + + // public v6 + AddressFlags("2620:0:1cfe:face:b00c::3", 6, 0), + + // localhost + AddressFlags("127.0.0.1", 4, IS_LOCAL | IS_PVT_NONROUTE), + AddressFlags("::1", 6, IS_LOCAL | IS_PVT_NONROUTE), + + // link-local v4 + AddressFlags("169.254.0.1", 4, IS_LINK_LOCAL | IS_PVT_NONROUTE), + + // private v4 + AddressFlags("10.0.0.0", 4, IS_PVT_NONROUTE), + AddressFlags("10.11.12.13", 4, IS_PVT_NONROUTE), + AddressFlags("10.255.255.255", 4, IS_PVT_NONROUTE), + AddressFlags("127.128.129.200", 4, IS_LOCAL | IS_PVT_NONROUTE), + AddressFlags("127.255.255.255", 4, IS_LOCAL | IS_PVT_NONROUTE), + AddressFlags("169.254.0.0", 4, IS_LINK_LOCAL | IS_PVT_NONROUTE), + AddressFlags("192.168.0.0", 4, IS_PVT_NONROUTE), + AddressFlags("192.168.200.255", 4, IS_PVT_NONROUTE), + AddressFlags("192.168.255.255", 4, IS_PVT_NONROUTE), + + // private v6 + AddressFlags("fd01:1637:1c56:66af::", 6, IS_PVT_NONROUTE), + + // non routable v4 + AddressFlags("0.0.0.0", 4, IS_NONROUTABLE | IS_ZERO), + AddressFlags("0.255.255.255", 4, IS_NONROUTABLE), + AddressFlags("192.0.0.0", 4, IS_NONROUTABLE), + AddressFlags("192.0.2.0", 4, IS_NONROUTABLE), + AddressFlags("198.18.0.0", 4, IS_NONROUTABLE), + AddressFlags("198.19.255.255", 4, IS_NONROUTABLE), + AddressFlags("198.51.100.0", 4, IS_NONROUTABLE), + AddressFlags("198.51.100.255", 4, IS_NONROUTABLE), + AddressFlags("203.0.113.0", 4, IS_NONROUTABLE), + AddressFlags("203.0.113.255", 4, IS_NONROUTABLE), + AddressFlags("224.0.0.0", 4, IS_NONROUTABLE | IS_MULTICAST), + AddressFlags("240.0.0.0", 4, IS_NONROUTABLE), + AddressFlags("224.0.0.0", 4, IS_NONROUTABLE), + // v4 link local broadcast + AddressFlags( + "255.255.255.255", + 4, + IS_NONROUTABLE | IS_LINK_LOCAL_BROADCAST), + + // non routable v6 + AddressFlags("1999::1", 6, IS_NONROUTABLE), + AddressFlags("0::0", 6, IS_NONROUTABLE | IS_ZERO), + AddressFlags("0::0:0", 6, IS_NONROUTABLE | IS_ZERO), + AddressFlags("0:0:0::0", 6, IS_NONROUTABLE | IS_ZERO), + + // link-local v6 + AddressFlags("fe80::0205:73ff:fef9:46fc", 6, IS_LINK_LOCAL), + AddressFlags("fe80::0012:34ff:fe56:7890", 6, IS_LINK_LOCAL), + + // multicast v4 + AddressFlags("224.0.0.1", 4, IS_MULTICAST | IS_NONROUTABLE), + AddressFlags("224.0.0.251", 4, IS_MULTICAST | IS_NONROUTABLE), + AddressFlags("239.12.34.56", 4, IS_MULTICAST | IS_NONROUTABLE), + + // multicast v6 + AddressFlags("ff00::", 6, IS_MULTICAST | IS_NONROUTABLE), + AddressFlags("ff02:ffff::1", 6, IS_MULTICAST | IS_NONROUTABLE), + AddressFlags("ff02::101", 6, IS_MULTICAST | IS_NONROUTABLE), + AddressFlags("ff0e::101", 6, IS_MULTICAST), + // v6 link local broadcast + AddressFlags("ff02::1", 6, IS_NONROUTABLE | IS_LINK_LOCAL_BROADCAST), }; -static const vector > mapProvider = { - {"::ffff:192.0.2.128", "192.0.2.128"}, - {"192.0.2.128", "::ffff:192.0.2.128"}, - {"::FFFF:129.144.52.38", "129.144.52.38"}, - {"129.144.52.38", "::FFFF:129.144.52.38"}, - {"0:0:0:0:0:FFFF:222.1.41.90", "222.1.41.90"}, - {"::FFFF:222.1.41.90", "222.1.41.90"}, +static const vector> mapProvider = { + {"::ffff:192.0.2.128", "192.0.2.128"}, + {"192.0.2.128", "::ffff:192.0.2.128"}, + {"::FFFF:129.144.52.38", "129.144.52.38"}, + {"129.144.52.38", "::FFFF:129.144.52.38"}, + {"0:0:0:0:0:FFFF:222.1.41.90", "222.1.41.90"}, + {"::FFFF:222.1.41.90", "222.1.41.90"}, }; static const vector masksProvider = { - MaskData("255.255.255.255", 1, "128.0.0.0"), - MaskData("255.255.255.255", 2, "192.0.0.0"), - MaskData("192.0.2.42", 16, "192.0.0.0"), - MaskData("255.255.255.255", 24, "255.255.255.0"), - MaskData("255.255.255.255", 32, "255.255.255.255"), - MaskData("10.10.10.10", 0, "0.0.0.0"), - MaskData("::1", 64, "::"), - MaskData("2620:0:1cfe:face:b00c::3", 1, "::"), - MaskData("2620:0:1cfe:face:b00c::3", 3, "2000::"), - MaskData("2620:0:1cfe:face:b00c::3", 6, "2400::"), - MaskData("2620:0:1cfe:face:b00c::3", 7, "2600::"), - MaskData("2620:0:1cfe:face:b00c::3", 11, "2620::"), - MaskData("2620:0:1cfe:face:b00c::3", 36, "2620:0:1000::"), - MaskData("2620:0:1cfe:face:b00c::3", 37, "2620:0:1800::"), - MaskData("2620:0:1cfe:face:b00c::3", 38, "2620:0:1c00::"), - MaskData("2620:0:1cfe:face:b00c::3", 41, "2620:0:1c80::"), - MaskData("2620:0:1cfe:face:b00c::3", 42, "2620:0:1cc0::"), - MaskData("2620:0:1cfe:face:b00c::3", 43, "2620:0:1ce0::"), - MaskData("2620:0:1cfe:face:b00c::3", 44, "2620:0:1cf0::"), - MaskData("2620:0:1cfe:face:b00c::3", 45, "2620:0:1cf8::"), - MaskData("2620:0:1cfe:face:b00c::3", 46, "2620:0:1cfc::"), - MaskData("2620:0:1cfe:face:b00c::3", 47, "2620:0:1cfe::"), - MaskData("2620:0:1cfe:face:b00c::3", 49, "2620:0:1cfe:8000::"), - MaskData("2620:0:1cfe:face:b00c::3", 50, "2620:0:1cfe:c000::"), - MaskData("2620:0:1cfe:face:b00c::3", 51, "2620:0:1cfe:e000::"), - MaskData("2620:0:1cfe:face:b00c::3", 52, "2620:0:1cfe:f000::"), - MaskData("2620:0:1cfe:face:b00c::3", 53, "2620:0:1cfe:f800::"), - MaskData("2620:0:1cfe:face:b00c::3", 55, "2620:0:1cfe:fa00::"), - MaskData("2620:0:1cfe:face:b00c::3", 57, "2620:0:1cfe:fa80::"), - MaskData("2620:0:1cfe:face:b00c::3", 58, "2620:0:1cfe:fac0::"), - MaskData("2620:0:1cfe:face:b00c::3", 61, "2620:0:1cfe:fac8::"), - MaskData("2620:0:1cfe:face:b00c::3", 62, "2620:0:1cfe:facc::"), - MaskData("2620:0:1cfe:face:b00c::3", 63, "2620:0:1cfe:face::"), - MaskData("2620:0:1cfe:face:b00c::3", 65, "2620:0:1cfe:face:8000::"), - MaskData("2620:0:1cfe:face:b00c::3", 67, "2620:0:1cfe:face:a000::"), - MaskData("2620:0:1cfe:face:b00c::3", 68, "2620:0:1cfe:face:b000::"), - MaskData("2620:0:1cfe:face:b00c::3", 77, "2620:0:1cfe:face:b008::"), - MaskData("2620:0:1cfe:face:b00c::3", 78, "2620:0:1cfe:face:b00c::"), - MaskData("2620:0:1cfe:face:b00c::3", 127, "2620:0:1cfe:face:b00c::2"), - MaskData("2620:0:1cfe:face:b00c::3", 128, "2620:0:1cfe:face:b00c::3"), - MaskData("2620:0:1cfe:face:b00c::3", 0, "::") + MaskData("255.255.255.255", 1, "128.0.0.0"), + MaskData("255.255.255.255", 2, "192.0.0.0"), + MaskData("192.0.2.42", 16, "192.0.0.0"), + MaskData("255.255.255.255", 24, "255.255.255.0"), + MaskData("255.255.255.255", 32, "255.255.255.255"), + MaskData("10.10.10.10", 0, "0.0.0.0"), + MaskData("::1", 64, "::"), + MaskData("2620:0:1cfe:face:b00c::3", 1, "::"), + MaskData("2620:0:1cfe:face:b00c::3", 3, "2000::"), + MaskData("2620:0:1cfe:face:b00c::3", 6, "2400::"), + MaskData("2620:0:1cfe:face:b00c::3", 7, "2600::"), + MaskData("2620:0:1cfe:face:b00c::3", 11, "2620::"), + MaskData("2620:0:1cfe:face:b00c::3", 36, "2620:0:1000::"), + MaskData("2620:0:1cfe:face:b00c::3", 37, "2620:0:1800::"), + MaskData("2620:0:1cfe:face:b00c::3", 38, "2620:0:1c00::"), + MaskData("2620:0:1cfe:face:b00c::3", 41, "2620:0:1c80::"), + MaskData("2620:0:1cfe:face:b00c::3", 42, "2620:0:1cc0::"), + MaskData("2620:0:1cfe:face:b00c::3", 43, "2620:0:1ce0::"), + MaskData("2620:0:1cfe:face:b00c::3", 44, "2620:0:1cf0::"), + MaskData("2620:0:1cfe:face:b00c::3", 45, "2620:0:1cf8::"), + MaskData("2620:0:1cfe:face:b00c::3", 46, "2620:0:1cfc::"), + MaskData("2620:0:1cfe:face:b00c::3", 47, "2620:0:1cfe::"), + MaskData("2620:0:1cfe:face:b00c::3", 49, "2620:0:1cfe:8000::"), + MaskData("2620:0:1cfe:face:b00c::3", 50, "2620:0:1cfe:c000::"), + MaskData("2620:0:1cfe:face:b00c::3", 51, "2620:0:1cfe:e000::"), + MaskData("2620:0:1cfe:face:b00c::3", 52, "2620:0:1cfe:f000::"), + MaskData("2620:0:1cfe:face:b00c::3", 53, "2620:0:1cfe:f800::"), + MaskData("2620:0:1cfe:face:b00c::3", 55, "2620:0:1cfe:fa00::"), + MaskData("2620:0:1cfe:face:b00c::3", 57, "2620:0:1cfe:fa80::"), + MaskData("2620:0:1cfe:face:b00c::3", 58, "2620:0:1cfe:fac0::"), + MaskData("2620:0:1cfe:face:b00c::3", 61, "2620:0:1cfe:fac8::"), + MaskData("2620:0:1cfe:face:b00c::3", 62, "2620:0:1cfe:facc::"), + MaskData("2620:0:1cfe:face:b00c::3", 63, "2620:0:1cfe:face::"), + MaskData("2620:0:1cfe:face:b00c::3", 65, "2620:0:1cfe:face:8000::"), + MaskData("2620:0:1cfe:face:b00c::3", 67, "2620:0:1cfe:face:a000::"), + MaskData("2620:0:1cfe:face:b00c::3", 68, "2620:0:1cfe:face:b000::"), + MaskData("2620:0:1cfe:face:b00c::3", 77, "2620:0:1cfe:face:b008::"), + MaskData("2620:0:1cfe:face:b00c::3", 78, "2620:0:1cfe:face:b00c::"), + MaskData("2620:0:1cfe:face:b00c::3", 127, "2620:0:1cfe:face:b00c::2"), + MaskData("2620:0:1cfe:face:b00c::3", 128, "2620:0:1cfe:face:b00c::3"), + MaskData("2620:0:1cfe:face:b00c::3", 0, "::"), }; static const vector maskBoundaryProvider = { - MaskBoundaryData("10.1.1.1", 24, "10.1.1.1", true), - MaskBoundaryData("10.1.1.1", 8, "10.1.2.3", true), - MaskBoundaryData("2620:0:1cfe:face:b00c::1", 48, "2620:0:1cfe::", true), - // addresses that are NOT in the same subnet once mask is applied - MaskBoundaryData("10.1.1.1", 24, "10.1.2.1", false), - MaskBoundaryData("10.1.1.1", 16, "10.2.3.4", false), - MaskBoundaryData("2620:0:1cfe:face:b00c::1", 48, "2620:0:1cfc::", false), + MaskBoundaryData("10.1.1.1", 24, "10.1.1.1", true), + MaskBoundaryData("10.1.1.1", 8, "10.1.2.3", true), + MaskBoundaryData("2620:0:1cfe:face:b00c::1", 48, "2620:0:1cfe::", true), + // addresses that are NOT in the same subnet once mask is applied + MaskBoundaryData("10.1.1.1", 24, "10.1.2.1", false), + MaskBoundaryData("10.1.1.1", 16, "10.2.3.4", false), + MaskBoundaryData("2620:0:1cfe:face:b00c::1", 48, "2620:0:1cfc::", false), }; -INSTANTIATE_TEST_CASE_P(IPAddress, - IPAddressTest, - ::testing::ValuesIn(validAddressProvider)); -INSTANTIATE_TEST_CASE_P(IPAddress, - IPAddressFlagTest, - ::testing::ValuesIn(flagProvider)); -INSTANTIATE_TEST_CASE_P(IPAddress, - IPAddressMappedTest, - ::testing::ValuesIn(mapProvider)); -INSTANTIATE_TEST_CASE_P(IPAddress, - IPAddressCtorTest, - ::testing::ValuesIn(invalidAddressProvider)); -INSTANTIATE_TEST_CASE_P(IPAddress, - IPAddressCtorBinaryTest, - ::testing::ValuesIn(invalidBinaryProvider)); -INSTANTIATE_TEST_CASE_P(IPAddress, - IPAddressMaskTest, - ::testing::ValuesIn(masksProvider)); -INSTANTIATE_TEST_CASE_P(IPAddress, - IPAddressMaskBoundaryTest, - ::testing::ValuesIn(maskBoundaryProvider)); -INSTANTIATE_TEST_CASE_P(IPAddress, - IPAddressByteAccessorTest, - ::testing::ValuesIn(validAddressProvider)); -INSTANTIATE_TEST_CASE_P(IPAddress, - IPAddressBitAccessorTest, - ::testing::ValuesIn(validAddressProvider)); +INSTANTIATE_TEST_CASE_P( + IPAddress, + IPAddressTest, + ::testing::ValuesIn(validAddressProvider)); +INSTANTIATE_TEST_CASE_P( + IPAddress, + IPAddressFlagTest, + ::testing::ValuesIn(flagProvider)); +INSTANTIATE_TEST_CASE_P( + IPAddress, + IPAddressMappedTest, + ::testing::ValuesIn(mapProvider)); +INSTANTIATE_TEST_CASE_P( + IPAddress, + IPAddressCtorTest, + ::testing::ValuesIn(invalidAddressProvider)); +INSTANTIATE_TEST_CASE_P( + IPAddress, + IPAddressCtorBinaryTest, + ::testing::ValuesIn(invalidBinaryProvider)); +INSTANTIATE_TEST_CASE_P( + IPAddress, + IPAddressMaskTest, + ::testing::ValuesIn(masksProvider)); +INSTANTIATE_TEST_CASE_P( + IPAddress, + IPAddressMaskBoundaryTest, + ::testing::ValuesIn(maskBoundaryProvider)); +INSTANTIATE_TEST_CASE_P( + IPAddress, + IPAddressByteAccessorTest, + ::testing::ValuesIn(validAddressProvider)); +INSTANTIATE_TEST_CASE_P( + IPAddress, + IPAddressBitAccessorTest, + ::testing::ValuesIn(validAddressProvider)); TEST(IPAddressV4, fetchMask) { struct X : private IPAddressV4 { @@ -1420,63 +1467,55 @@ TEST(IPAddressV4, fetchMask) { } TEST(IPAddressV6, fetchMask) { - using ByteArray8 = std::array; - struct X : private IPAddressV6 { using IPAddressV6::fetchMask; }; - auto join = [](std::array parts) { - ByteArray16 _return; - std::memcpy(_return.data(), parts.data(), _return.size()); - return _return; - }; - EXPECT_THAT( X::fetchMask(0), - ::testing::ElementsAreArray(join({{ + ::testing::ElementsAreArray(join8({{ ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}, ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}, }}))); EXPECT_THAT( X::fetchMask(1), - ::testing::ElementsAreArray(join({{ + ::testing::ElementsAreArray(join8({{ ByteArray8{{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}, ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}, }}))); EXPECT_THAT( X::fetchMask(63), - ::testing::ElementsAreArray(join({{ + ::testing::ElementsAreArray(join8({{ ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe}}, ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}, }}))); EXPECT_THAT( X::fetchMask(64), - ::testing::ElementsAreArray(join({{ + ::testing::ElementsAreArray(join8({{ ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}}, ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}, }}))); EXPECT_THAT( X::fetchMask(65), - ::testing::ElementsAreArray(join({{ + ::testing::ElementsAreArray(join8({{ ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}}, ByteArray8{{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}, }}))); EXPECT_THAT( X::fetchMask(127), - ::testing::ElementsAreArray(join({{ + ::testing::ElementsAreArray(join8({{ ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}}, ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe}}, }}))); EXPECT_THAT( X::fetchMask(128), - ::testing::ElementsAreArray(join({{ + ::testing::ElementsAreArray(join8({{ ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}}, ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}}, }}))); diff --git a/folly/test/MacAddressTest.cpp b/folly/test/MacAddressTest.cpp index 6f013ea6..eef4b3e0 100644 --- a/folly/test/MacAddressTest.cpp +++ b/folly/test/MacAddressTest.cpp @@ -94,8 +94,8 @@ TEST(MacAddress, fromBinary) { } TEST(MacAddress, toString) { - EXPECT_EQ("12:34:56:78:9a:bc", - MacAddress::fromHBO(0x123456789abc).toString()); + EXPECT_EQ( + "12:34:56:78:9a:bc", MacAddress::fromHBO(0x123456789abc).toString()); EXPECT_EQ("12:34:56:78:9a:bc", MacAddress("12:34:56:78:9a:bc").toString()); EXPECT_EQ("01:23:45:67:89:ab", MacAddress("01-23-45-67-89-ab").toString()); EXPECT_EQ("01:23:45:67:89:ab", MacAddress("0123456789ab").toString()); @@ -131,10 +131,12 @@ TEST(MacAddress, attributes) { } TEST(MacAddress, createMulticast) { - EXPECT_EQ(MacAddress("33:33:00:01:00:03"), - MacAddress::createMulticast(IPAddressV6("ff02:dead:beef::1:3"))); - EXPECT_EQ(MacAddress("33:33:12:34:56:78"), - MacAddress::createMulticast(IPAddressV6("ff02::abcd:1234:5678"))); + EXPECT_EQ( + MacAddress("33:33:00:01:00:03"), + MacAddress::createMulticast(IPAddressV6("ff02:dead:beef::1:3"))); + EXPECT_EQ( + MacAddress("33:33:12:34:56:78"), + MacAddress::createMulticast(IPAddressV6("ff02::abcd:1234:5678"))); } void testCmp(const char* str1, const char* str2) { diff --git a/folly/test/SocketAddressTest.cpp b/folly/test/SocketAddressTest.cpp index 2af4370f..7fe8b791 100644 --- a/folly/test/SocketAddressTest.cpp +++ b/folly/test/SocketAddressTest.cpp @@ -20,6 +20,8 @@ #include #include +#include +#include #include #include #include @@ -66,12 +68,9 @@ TEST(SocketAddress, IPv4ToStringConversion) { SocketAddress addr; for (int pos = 0; pos < 4; ++pos) { for (int i = 0; i < 256; ++i) { - int fragments[] = {5,5,5,5}; + auto fragments = folly::make_array(5, 5, 5, 5); fragments[pos] = i; - std::ostringstream ss; - ss << fragments[0] << "." << fragments[1] << "." - << fragments[2] << "." << fragments[3]; - string ipString = ss.str(); + auto ipString = folly::join(".", fragments); addr.setFromIpPort(ipString, 1234); EXPECT_EQ(addr.getAddressStr(), ipString); } @@ -118,8 +117,7 @@ TEST(SocketAddress, SetFromInvalidIpv4) { // Try setting to an invalid value // Since setFromIpPort() shouldn't allow hostname lookups, setting to // "localhost" should fail, even if localhost is resolvable - EXPECT_THROW(addr.setFromIpPort("localhost", 1234), - std::runtime_error); + EXPECT_THROW(addr.setFromIpPort("localhost", 1234), std::runtime_error); // Make sure the address still has the old contents EXPECT_EQ(addr.getFamily(), AF_INET); @@ -416,8 +414,10 @@ TEST(SocketAddress, IsLoopback) { EXPECT_TRUE(addr.isLoopbackAddress()); } -void CheckPrefixMatch(const SocketAddress& first, - const SocketAddress& second, unsigned matchingPrefixLen) { +void CheckPrefixMatch( + const SocketAddress& first, + const SocketAddress& second, + unsigned matchingPrefixLen) { unsigned i; for (i = 0; i <= matchingPrefixLen; i++) { EXPECT_TRUE(first.prefixMatch(second, i)); @@ -468,7 +468,7 @@ TEST(SocketAddress, CheckComparatorBehavior) { // The following comparison are strict (so if first and second were // inverted that is ok. - //IP V4 + // IP V4 // port comparisions first.setFromIpPort("128.0.0.0", 0); @@ -539,10 +539,10 @@ TEST(SocketAddress, Unix) { // Test a path that is too large const char longPath[] = - "abcdefghijklmnopqrstuvwxyz0123456789" - "abcdefghijklmnopqrstuvwxyz0123456789" - "abcdefghijklmnopqrstuvwxyz0123456789" - "abcdefghijklmnopqrstuvwxyz0123456789"; + "abcdefghijklmnopqrstuvwxyz0123456789" + "abcdefghijklmnopqrstuvwxyz0123456789" + "abcdefghijklmnopqrstuvwxyz0123456789" + "abcdefghijklmnopqrstuvwxyz0123456789"; EXPECT_THROW(addr.setFromPath(longPath), std::invalid_argument); // The original address should still be the same EXPECT_EQ(addr.getFamily(), AF_UNIX); @@ -551,9 +551,9 @@ TEST(SocketAddress, Unix) { // Test a path that exactly fits in sockaddr_un // (not including the NUL terminator) const char exactLengthPath[] = - "abcdefghijklmnopqrstuvwxyz0123456789" - "abcdefghijklmnopqrstuvwxyz0123456789" - "abcdefghijklmnopqrstuvwxyz0123456789"; + "abcdefghijklmnopqrstuvwxyz0123456789" + "abcdefghijklmnopqrstuvwxyz0123456789" + "abcdefghijklmnopqrstuvwxyz0123456789"; addr.setFromPath(exactLengthPath); EXPECT_EQ(addr.describe(), exactLengthPath); @@ -661,22 +661,23 @@ TEST(SocketAddress, AnonymousUnix) { EXPECT_NE(addr0, addr0); } -#define REQUIRE_ERRNO(cond, msg) \ - if (!(cond)) { \ - int _requireErrnoCopy_ = errno; \ - std::ostringstream _requireMsg_; \ +#define REQUIRE_ERRNO(cond, msg) \ + if (!(cond)) { \ + int _requireErrnoCopy_ = errno; \ + std::ostringstream _requireMsg_; \ _requireMsg_ << (msg) << ": " << strerror(_requireErrnoCopy_); \ - ADD_FAILURE(); \ + ADD_FAILURE(); \ } -void testSetFromSocket(const SocketAddress *serverBindAddr, - const SocketAddress *clientBindAddr, - SocketAddress *listenAddrRet, - SocketAddress *acceptAddrRet, - SocketAddress *serverAddrRet, - SocketAddress *serverPeerAddrRet, - SocketAddress *clientAddrRet, - SocketAddress *clientPeerAddrRet) { +void testSetFromSocket( + const SocketAddress* serverBindAddr, + const SocketAddress* clientBindAddr, + SocketAddress* listenAddrRet, + SocketAddress* acceptAddrRet, + SocketAddress* serverAddrRet, + SocketAddress* serverPeerAddrRet, + SocketAddress* clientAddrRet, + SocketAddress* clientPeerAddrRet) { int listenSock = fsp::socket(serverBindAddr->getFamily(), SOCK_STREAM, 0); REQUIRE_ERRNO(listenSock > 0, "failed to create listen socket"); sockaddr_storage laddr; @@ -690,8 +691,8 @@ void testSetFromSocket(const SocketAddress *serverBindAddr, listenAddrRet->setFromLocalAddress(listenSock); SocketAddress listenPeerAddr; - EXPECT_THROW(listenPeerAddr.setFromPeerAddress(listenSock), - std::runtime_error); + EXPECT_THROW( + listenPeerAddr.setFromPeerAddress(listenSock), std::runtime_error); // Note that we use the family from serverBindAddr here, since we allow // clientBindAddr to be nullptr. @@ -701,21 +702,25 @@ void testSetFromSocket(const SocketAddress *serverBindAddr, sockaddr_storage clientAddr; clientBindAddr->getAddress(&clientAddr); - rc = bind(clientSock, reinterpret_cast(&clientAddr), - clientBindAddr->getActualSize()); + rc = bind( + clientSock, + reinterpret_cast(&clientAddr), + clientBindAddr->getActualSize()); REQUIRE_ERRNO(rc == 0, "failed to bind to client socket"); } sockaddr_storage listenAddr; listenAddrRet->getAddress(&listenAddr); - rc = connect(clientSock, reinterpret_cast(&listenAddr), - listenAddrRet->getActualSize()); + rc = connect( + clientSock, + reinterpret_cast(&listenAddr), + listenAddrRet->getActualSize()); REQUIRE_ERRNO(rc == 0, "failed to connect"); sockaddr_storage acceptAddr; socklen_t acceptAddrLen = sizeof(acceptAddr); - int serverSock = accept(listenSock, - reinterpret_cast(&acceptAddr), &acceptAddrLen); + int serverSock = accept( + listenSock, reinterpret_cast(&acceptAddr), &acceptAddrLen); REQUIRE_ERRNO(serverSock > 0, "failed to accept"); acceptAddrRet->setFromSockaddr( reinterpret_cast(&acceptAddr), acceptAddrLen); @@ -740,10 +745,15 @@ TEST(SocketAddress, SetFromSocketIPv4) { SocketAddress clientAddr; SocketAddress clientPeerAddr; - testSetFromSocket(&serverBindAddr, &clientBindAddr, - &listenAddr, &acceptAddr, - &serverAddr, &serverPeerAddr, - &clientAddr, &clientPeerAddr); + testSetFromSocket( + &serverBindAddr, + &clientBindAddr, + &listenAddr, + &acceptAddr, + &serverAddr, + &serverPeerAddr, + &clientAddr, + &clientPeerAddr); // The server socket's local address should have the same port as the listen // address. The IP will be different, since the listening socket is @@ -781,10 +791,15 @@ TEST(SocketAddress, SetFromSocketUnixAbstract) { SocketAddress clientAddr; SocketAddress clientPeerAddr; - testSetFromSocket(&serverBindAddr, &clientBindAddr, - &listenAddr, &acceptAddr, - &serverAddr, &serverPeerAddr, - &clientAddr, &clientPeerAddr); + testSetFromSocket( + &serverBindAddr, + &clientBindAddr, + &listenAddr, + &acceptAddr, + &serverAddr, + &serverPeerAddr, + &clientAddr, + &clientPeerAddr); // The server socket's local address should be the same as the listen // address. @@ -820,10 +835,15 @@ TEST(SocketAddress, SetFromSocketUnixExplicit) { serverBindAddr.setFromPath(serverPath.c_str()); clientBindAddr.setFromPath(clientPath.c_str()); - testSetFromSocket(&serverBindAddr, &clientBindAddr, - &listenAddr, &acceptAddr, - &serverAddr, &serverPeerAddr, - &clientAddr, &clientPeerAddr); + testSetFromSocket( + &serverBindAddr, + &clientBindAddr, + &listenAddr, + &acceptAddr, + &serverAddr, + &serverPeerAddr, + &clientAddr, + &clientPeerAddr); } catch (...) { // Remove the socket files after we are done unlink(serverPath.c_str()); @@ -861,10 +881,15 @@ TEST(SocketAddress, SetFromSocketUnixAnonymous) { try { serverBindAddr.setFromPath(serverPath.c_str()); - testSetFromSocket(&serverBindAddr, nullptr, - &listenAddr, &acceptAddr, - &serverAddr, &serverPeerAddr, - &clientAddr, &clientPeerAddr); + testSetFromSocket( + &serverBindAddr, + nullptr, + &listenAddr, + &acceptAddr, + &serverAddr, + &serverPeerAddr, + &clientAddr, + &clientPeerAddr); } catch (...) { // Remove the socket file after we are done unlink(serverPath.c_str()); diff --git a/folly/test/SocketAddressTestHelper.cpp b/folly/test/SocketAddressTestHelper.cpp index 5fe349e1..f0324335 100644 --- a/folly/test/SocketAddressTestHelper.cpp +++ b/folly/test/SocketAddressTestHelper.cpp @@ -47,5 +47,4 @@ bool SocketAddressTestHelper::isFamilyOfAddrEnabled(const char* addr) { freeaddrinfo(resultsp); return !err; } - } diff --git a/folly/test/SocketAddressTestHelper.h b/folly/test/SocketAddressTestHelper.h index a5a34e59..062837f1 100644 --- a/folly/test/SocketAddressTestHelper.h +++ b/folly/test/SocketAddressTestHelper.h @@ -20,28 +20,25 @@ namespace folly { class SocketAddressTestHelper { public: - static constexpr const char* kLoopbackAddrIPv4 = "127.0.0.1"; static constexpr const char* kLoopbackAddrIPv6 = "::1"; // https://developers.google.com/speed/public-dns/docs/using?hl=en static constexpr const char* kGooglePublicDnsAName = - "google-public-dns-a.google.com"; + "google-public-dns-a.google.com"; static constexpr const char* kGooglePublicDnsBName = - "google-public-dns-b.google.com"; + "google-public-dns-b.google.com"; static constexpr const char* kGooglePublicDnsAAddrIPv4 = "8.8.8.8"; static constexpr const char* kGooglePublicDnsBAddrIPv4 = "8.8.4.4"; static constexpr const char* kGooglePublicDnsAAddrIPv6 = - "2001:4860:4860::8888"; + "2001:4860:4860::8888"; static constexpr const char* kGooglePublicDnsBAddrIPv6 = - "2001:4860:4860::8844"; + "2001:4860:4860::8844"; static bool isIPv4Enabled(); static bool isIPv6Enabled(); private: - static bool isFamilyOfAddrEnabled(const char* addr); }; - }