proxygen: folly::IPAddressV6 Class Reference

#include <IPAddressV6.h>

Classes
union	AddressStorage

Public Types
enum	Type { TEREDO, T6TO4, NORMAL }

enum	LinkLocalTag { LINK_LOCAL }

typedef std::runtime_error	TypeError

Public Member Functions
ByteRange	toBinary () const

	IPAddressV6 ()

	IPAddressV6 (StringPiece ip)

	IPAddressV6 (const ByteArray16 &src) noexcept

	IPAddressV6 (const in6_addr &src) noexcept

	IPAddressV6 (const sockaddr_in6 &src) noexcept

	IPAddressV6 (LinkLocalTag tag, MacAddress mac)

IPAddressV4	createIPv4 () const

IPAddressV4	getIPv4For6To4 () const

bool	is6To4 () const

bool	isTeredo () const

bool	isIPv4Mapped () const

Type	type () const

std::string	toJson () const

size_t	hash () const

bool	inSubnet (StringPiece cidrNetwork) const

bool	inSubnet (const IPAddressV6 &subnet, uint8_t cidr) const

bool	inSubnetWithMask (const IPAddressV6 &subnet, const ByteArray16 &mask) const

bool	isLoopback () const

bool	isNonroutable () const

bool	isRoutable () const

bool	isPrivate () const

bool	isLinkLocal () const

Optional< MacAddress >	getMacAddressFromLinkLocal () const

Optional< MacAddress >	getMacAddressFromEUI64 () const

bool	isMulticast () const

uint8_t	getMulticastFlags () const

uint8_t	getMulticastScope () const

bool	isZero () const

bool	isLinkLocalBroadcast () const

IPAddressV6	mask (size_t numBits) const

in6_addr	toAddr () const

uint16_t	getScopeId () const

void	setScopeId (uint16_t scope)

sockaddr_in6	toSockAddr () const

ByteArray16	toByteArray () const

std::string	toFullyQualified () const

void	toFullyQualifiedAppend (std::string &out) const

std::string	toInverseArpaName () const

std::string	str () const

uint8_t	version () const

IPAddressV6	getSolicitedNodeAddress () const

bool	getNthMSBit (size_t bitIndex) const

uint8_t	getNthMSByte (size_t byteIndex) const

bool	getNthLSBit (size_t bitIndex) const

uint8_t	getNthLSByte (size_t byteIndex) const

const unsigned char *	bytes () const

Static Public Member Functions
static bool	validate (StringPiece ip) noexcept

static IPAddressV6	fromBinary (ByteRange bytes)

static Expected< IPAddressV6, IPAddressFormatError >	tryFromBinary (ByteRange bytes) noexcept

static Expected< IPAddressV6, IPAddressFormatError >	tryFromString (StringPiece str) noexcept

static IPAddressV6	fromInverseArpaName (const std::string &arpaname)

static constexpr size_t	bitCount ()

static const ByteArray16	fetchMask (size_t numBits)

static CIDRNetworkV6	longestCommonPrefix (const CIDRNetworkV6 &one, const CIDRNetworkV6 &two)

static constexpr size_t	byteCount ()

Static Public Attributes
static const uint32_t	PREFIX_TEREDO = 0x20010000

static const uint32_t	PREFIX_6TO4 = 0x2002

static constexpr size_t	kToFullyQualifiedSize

Protected Member Functions
bool	inBinarySubnet (const std::array< uint8_t, 2 > addr, size_t numBits) const

Private Member Functions
auto	tie () const

Expected< Unit, IPAddressFormatError >	trySetFromBinary (ByteRange bytes) noexcept

Private Attributes
union folly::IPAddressV6::AddressStorage	addr_

uint16_t	scope_ {0}

Friends
bool	operator== (const IPAddressV6 &a, const IPAddressV6 &b)

bool	operator!= (const IPAddressV6 &a, const IPAddressV6 &b)

bool	operator< (const IPAddressV6 &a, const IPAddressV6 &b)

bool	operator> (const IPAddressV6 &a, const IPAddressV6 &b)

bool	operator<= (const IPAddressV6 &a, const IPAddressV6 &b)

bool	operator>= (const IPAddressV6 &a, const IPAddressV6 &b)

Detailed Description

IPv6 variation of IPAddress.

Added methods: createIPv4, getIPv4For6To4, is6To4, isTeredo, isIPv4Mapped, tryCreateIPv4, type

See also: IPAddress

Notes on scope ID parsing:

getaddrinfo() uses if_nametoindex() to convert interface names into a numerical index. For instance, "fe80::202:c9ff:fec1:ee08%eth0" may return scope ID 2 on some hosts, but other numbers on other hosts. It will fail entirely on hosts without an eth0 interface.

Serializing / Deserializing IPAddressB6's on different hosts that use link-local scoping probably won't work.

Definition at line 71 of file IPAddressV6.h.

Member Typedef Documentation

typedef std::runtime_error folly::IPAddressV6::TypeError

Definition at line 85 of file IPAddressV6.h.

Member Enumeration Documentation

enum folly::IPAddressV6::LinkLocalTag

Enumerator
LINK_LOCAL

Definition at line 81 of file IPAddressV6.h.

                     {
     LINK_LOCAL,
   };

enum folly::IPAddressV6::Type

Enumerator
TEREDO
T6TO4
NORMAL

Definition at line 74 of file IPAddressV6.h.

             {
     TEREDO,
     T6TO4,
     NORMAL,
   };

Constructor & Destructor Documentation

folly::IPAddressV6::IPAddressV6 ( )

Default constructor for IPAddressV6.

The address value will be ::0

Definition at line 70 of file IPAddressV6.cpp.

Referenced by fromInverseArpaName(), longestCommonPrefix(), mask(), toBinary(), and tryFromString().

70 {}

folly::IPAddressV6::IPAddressV6 ( StringPiece ip )

explicit

Definition at line 73 of file IPAddressV6.cpp.

References folly::gen::move, and tryFromString().

                                          {
   auto maybeIp = tryFromString(addr);
   if (maybeIp.hasError()) {
     throw IPAddressFormatException(
         to<std::string>("Invalid IPv6 address '", addr, "'"));
   }
   *this = std::move(maybeIp.value());
 }

folly::IPAddressV6::IPAddressV6 ( const ByteArray16 & src )

explicitnoexcept

Definition at line 119 of file IPAddressV6.cpp.

119 : addr_(src) {}

folly::IPAddressV6::addr_

union folly::IPAddressV6::AddressStorage addr_

folly::IPAddressV6::IPAddressV6 ( const in6_addr & src )

explicitnoexcept

Definition at line 112 of file IPAddressV6.cpp.

112 : addr_(src) {}

folly::IPAddressV6::addr_

union folly::IPAddressV6::AddressStorage addr_

folly::IPAddressV6::IPAddressV6 ( const sockaddr_in6 & src )

explicitnoexcept

Definition at line 115 of file IPAddressV6.cpp.

116 : addr_(src.sin6_addr), scope_(uint16_t(src.sin6_scope_id)) {}

folly::IPAddressV6::scope_

uint16_t scope_

Definition: IPAddressV6.h:417

uint16_t

Definition: ConstexprMathBenchmark.cpp:182

folly::IPAddressV6::addr_

union folly::IPAddressV6::AddressStorage addr_

folly::IPAddressV6::IPAddressV6	(	LinkLocalTag	tag,
		MacAddress	mac
	)

Create a link-local IPAddressV6 from the specified ethernet MAC address.

Definition at line 122 of file IPAddressV6.cpp.

122 : addr_(mac) {}

folly::IPAddressV6::addr_

union folly::IPAddressV6::AddressStorage addr_

Member Function Documentation

static constexpr size_t folly::IPAddressV6::bitCount ( )

inlinestatic

See also: IPAddress::bitCount

Returns: 128

Definition at line 189 of file IPAddressV6.h.

References hash(), inSubnet(), string, and toJson().

Referenced by fetchMask(), getNthLSBit(), mask(), and TEST().

                                      {
     return 128;
   }

static constexpr size_t folly::IPAddressV6::byteCount ( )

inlinestatic

Definition at line 348 of file IPAddressV6.h.

Referenced by getNthLSByte(), and getNthMSByte().

                                       {
     return 16;
   }

const unsigned char* folly::IPAddressV6::bytes ( ) const

inline

Definition at line 367 of file IPAddressV6.h.

References addr, addr_, folly::IPAddressV6::AddressStorage::in6Addr_, and inBinarySubnet().

Referenced by createIPv4(), folly::MacAddress::createMulticast(), getIPv4For6To4(), getMacAddressFromEUI64(), getNthMSByte(), getSolicitedNodeAddress(), isIPv4Mapped(), isZero(), str(), toByteArray(), toInverseArpaName(), tryFromBinary(), trySetFromBinary(), and type().

                                      {
     return addr_.in6Addr_.s6_addr;
   }

IPAddressV4 folly::IPAddressV6::createIPv4 ( ) const

Definition at line 227 of file IPAddressV6.cpp.

References bytes(), isIPv4Mapped(), and folly::detail::Bytes::mkAddress4().

Referenced by isLoopback(), isPrivate(), and toBinary().

                                           {
   if (!isIPv4Mapped()) {
     throw IPAddressFormatException("addr is not v4-to-v6-mapped");
   }
   const unsigned char* by = bytes();
   return IPAddressV4(detail::Bytes::mkAddress4(&by[12]));
 }

const ByteArray16 folly::IPAddressV6::fetchMask ( size_t numBits )

static

Return the mask associated with the given number of bits. If for instance numBits was 24 (e.g. /24) then the V4 mask returned should be {0xff, 0xff, 0xff, 0x00}.

Parameters

[in] numBits bitmask to retrieve

Exceptions

abort if numBits == 0 or numBits > bitCount()

Returns: mask associated with numBits

Definition at line 501 of file IPAddressV6.cpp.

References folly::Endian::big(), bitCount(), and uint64_t.

Referenced by inSubnet(), mask(), TEST(), and version().

                                                        {
   static const size_t bits = bitCount();
   if (numBits > bits) {
     throw IPAddressFormatException("IPv6 addresses are 128 bits.");
   }
   if (numBits == 0) {
     return {{0}};
   }
   constexpr auto _0s = uint64_t(0);
   constexpr auto _1s = ~_0s;
   auto const fragment = Endian::big(_1s << ((128 - numBits) % 64));
   auto const hi = numBits <= 64 ? fragment : _1s;
   auto const lo = numBits <= 64 ? _0s : fragment;
   uint64_t const parts[] = {hi, lo};
   ByteArray16 arr;
   std::memcpy(arr.data(), parts, sizeof(parts));
   return arr;
 }

IPAddressV6 folly::IPAddressV6::fromBinary ( ByteRange bytes )

static

Create a new IPAddress instance from the provided binary data.

Exceptions

IPAddressFormatException if the input length is not 16 bytes.

Definition at line 168 of file IPAddressV6.cpp.

References folly::Range< Iter >::size(), and tryFromBinary().

Referenced by getSolicitedNodeAddress(), TEST(), TEST_P(), and folly::toAppend().

                                                    {
   auto maybeIp = tryFromBinary(bytes);
   if (maybeIp.hasError()) {
     throw IPAddressFormatException(to<std::string>(
         "Invalid IPv6 binary data: length must be 16 bytes, got ",
         bytes.size()));
   }
   return maybeIp.value();
 }

IPAddressV6 folly::IPAddressV6::fromInverseArpaName ( const std::string & arpaname )

static

Create a new IPAddress instance from the ip6.arpa representation.

Exceptions

IPAddressFormatException if the input is not a valid ip6.arpa representation

Definition at line 199 of file IPAddressV6.cpp.

References count, i, IPAddressV6(), folly::range(), folly::sformat(), and folly::split().

Referenced by TEST().

                                                                       {
   auto piece = StringPiece(arpaname);
   if (!piece.removeSuffix(".ip6.arpa")) {
     throw IPAddressFormatException(sformat(
         "Invalid input. Should end with 'ip6.arpa'. Got '{}'", arpaname));
   }
   std::vector<StringPiece> pieces;
   split(".", piece, pieces);
   if (pieces.size() != 32) {
     throw IPAddressFormatException(sformat("Invalid input. Got '{}'", piece));
   }
   std::array<char, IPAddressV6::kToFullyQualifiedSize> ip;
   size_t pos = 0;
   int count = 0;
   for (size_t i = 1; i <= pieces.size(); i++) {
     ip[pos] = pieces[pieces.size() - i][0];
     pos++;
     count++;
     // add ':' every 4 chars
     if (count == 4 && pos < ip.size()) {
       ip[pos++] = ':';
       count = 0;
     }
   }
   return IPAddressV6(folly::range(ip));
 }

IPAddressV4 folly::IPAddressV6::getIPv4For6To4 ( ) const

Return a V4 address if this is a 6To4 address.

Exceptions

TypeError if not a 6To4 address

Definition at line 252 of file IPAddressV6.cpp.

References addr, bytes(), is6To4(), folly::sformat(), str(), uint16_t, uint8_t, and folly::unpackInto().

Referenced by folly::toAppend(), and toBinary().

                                               {
   if (!is6To4()) {
     throw IPAddressV6::TypeError(
         sformat("Invalid IP '{}': not a 6to4 address", str()));
   }
   // convert 16x8 bytes into first 4x16 bytes
   uint16_t ints[4] = {0, 0, 0, 0};
   unpackInto(bytes(), ints, 4);
   // repack into 4x8
   union {
     unsigned char bytes[4];
     in_addr addr;
   } ipv4;
   ipv4.bytes[0] = (uint8_t)((ints[1] & 0xFF00) >> 8);
   ipv4.bytes[1] = (uint8_t)(ints[1] & 0x00FF);
   ipv4.bytes[2] = (uint8_t)((ints[2] & 0xFF00) >> 8);
   ipv4.bytes[3] = (uint8_t)(ints[2] & 0x00FF);
   return IPAddressV4(ipv4.addr);
 }

Optional< MacAddress > folly::IPAddressV6::getMacAddressFromEUI64 ( ) const

Return the mac address if this is an auto-configured IPv6 address based on EUI-64

Returns: an Optional<MacAddress> union representing the mac address. If the address is not based on EUI-64 it will return an empty Optional. You can use Optional::value() to check whether the mac address is not null.

Definition at line 147 of file IPAddressV6.cpp.

References addr_, bytes(), folly::IPAddressV6::AddressStorage::bytes_, folly::MacAddress::fromBinary(), folly::none, and folly::range().

Referenced by getMacAddressFromLinkLocal(), isNonroutable(), and TEST().

                                                                {
   if (!(addr_.bytes_[11] == 0xff && addr_.bytes_[12] == 0xfe)) {
     return folly::none;
   }
   // The auto configured address uses modified EUI-64 format,
   // See RFC 4291 sections 2.5.1, 2.5.6, and Appendix A
   std::array<uint8_t, MacAddress::SIZE> bytes;
   // Step 1: first 8 bytes are network prefix, and can be stripped
   // Step 2: invert the universal/local (U/L) flag (bit 7)
   bytes[0] = addr_.bytes_[8] ^ 0x02;
   // Step 3: copy these bytes as they are
   bytes[1] = addr_.bytes_[9];
   bytes[2] = addr_.bytes_[10];
   // Step 4: strip bytes (0xfffe), which are bytes_[11] and bytes_[12]
   // Step 5: copy the rest.
   bytes[3] = addr_.bytes_[13];
   bytes[4] = addr_.bytes_[14];
   bytes[5] = addr_.bytes_[15];
   return Optional<MacAddress>(MacAddress::fromBinary(range(bytes)));
 }

Optional< MacAddress > folly::IPAddressV6::getMacAddressFromLinkLocal ( ) const

Return the mac address if this is a link-local IPv6 address.

Returns: an Optional<MacAddress> union representing the mac address.

If the address is not a link-local one it will return an empty Optional. You can use Optional::value() to check whether the mac address is not null.

Definition at line 139 of file IPAddressV6.cpp.

References getMacAddressFromEUI64(), isLinkLocal(), and folly::none.

Referenced by isNonroutable(), and TEST().

                                                                    {
   // Returned MacAddress must be constructed from a link-local IPv6 address.
   if (!isLinkLocal()) {
     return folly::none;
   }
   return getMacAddressFromEUI64();
 }

uint8_t folly::IPAddressV6::getMulticastFlags ( ) const

Return the flags for a multicast address. This method may only be called on multicast addresses.

Definition at line 390 of file IPAddressV6.cpp.

References addr_, folly::IPAddressV6::AddressStorage::bytes_, isMulticast(), and uint8_t.

Referenced by isNonroutable().

                                              {
   DCHECK(isMulticast());
   return uint8_t((addr_.bytes_[1] >> 4) & 0xf);
 }

uint8_t folly::IPAddressV6::getMulticastScope ( ) const

Return the scope for a multicast address. This method may only be called on multicast addresses.

Definition at line 395 of file IPAddressV6.cpp.

References addr_, folly::IPAddressV6::AddressStorage::bytes_, isMulticast(), and uint8_t.

Referenced by isNonroutable(), and isRoutable().

                                              {
   DCHECK(isMulticast());
   return uint8_t(addr_.bytes_[1] & 0xf);
 }

bool folly::IPAddressV6::getNthLSBit ( size_t bitIndex ) const

inline

Definition at line 359 of file IPAddressV6.h.

References bitCount(), and getNthMSBit().

                                           {
     return getNthMSBit(bitCount() - bitIndex - 1);
   }

uint8_t folly::IPAddressV6::getNthLSByte ( size_t byteIndex ) const

inline

Definition at line 363 of file IPAddressV6.h.

References byteCount(), and getNthMSByte().

                                                {
     return getNthMSByte(byteCount() - byteIndex - 1);
   }

bool folly::IPAddressV6::getNthMSBit ( size_t bitIndex ) const

inline

Definition at line 353 of file IPAddressV6.h.

References folly::detail::getNthMSBitImpl(), getNthMSByte(), and uint8_t.

Referenced by getNthLSBit().

                                           {
     return detail::getNthMSBitImpl(*this, bitIndex, AF_INET6);
   }

uint8_t folly::IPAddressV6::getNthMSByte ( size_t byteIndex ) const

Definition at line 489 of file IPAddressV6.cpp.

References byteCount(), bytes(), folly::detail::familyNameStr(), and folly::sformat().

Referenced by getNthLSByte(), and getNthMSBit().

                                                         {
   const auto highestIndex = byteCount() - 1;
   if (byteIndex > highestIndex) {
     throw std::invalid_argument(sformat(
         "Byte index must be <= {} for addresses of type: {}",
         highestIndex,
         detail::familyNameStr(AF_INET6)));
   }
   return bytes()[byteIndex];
 }

uint16_t folly::IPAddressV6::getScopeId ( ) const

inline

Definition at line 290 of file IPAddressV6.h.

References scope_.

Referenced by str().

                               {
     return scope_;
   }

IPAddressV6 folly::IPAddressV6::getSolicitedNodeAddress ( ) const

Return the solicited-node multicast address for this address.

Definition at line 400 of file IPAddressV6.cpp.

References addr_, bytes(), folly::IPAddressV6::AddressStorage::bytes_, fromBinary(), isMulticast(), and uint8_t.

Referenced by version().

                                                        {
   // Solicted node addresses must be constructed from unicast (or anycast)
   // addresses
   DCHECK(!isMulticast());
 
   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));
 }

size_t folly::IPAddressV6::hash ( ) const

Definition at line 314 of file IPAddressV6.cpp.

References addr_, folly::hash::SpookyHashV2::Hash128(), folly::hash::hash_combine(), isIPv4Mapped(), seed, and uint64_t.

Referenced by bitCount(), folly::hash_value(), std::hash< folly::IPAddressV6 >::operator()(), and toJson().

                                {
   if (isIPv4Mapped()) {
     /* An IPAddress containing this object would be equal (i.e. operator==)
        to an IPAddress containing the corresponding IPv4.
        So we must make sure that the hash values are the same as well */
     return IPAddress::createIPv4(*this).hash();
   }
 
   static const uint64_t seed = AF_INET6;
   uint64_t hash1 = 0, hash2 = 0;
   hash::SpookyHashV2::Hash128(&addr_, 16, &hash1, &hash2);
   return hash::hash_combine(seed, hash1, hash2);
 }

bool folly::IPAddressV6::inBinarySubnet	(	const std::array< uint8_t, 2 >	addr,
		size_t	numBits
	)		const

protected

Helper that returns true if the address is in the binary subnet specified by addr.

Definition at line 530 of file IPAddressV6.cpp.

References mask().

Referenced by bytes(), isLinkLocal(), isPrivate(), and isRoutable().

                           {
   auto masked = mask(numBits);
   return (std::memcmp(addr.data(), masked.bytes(), 2) == 0);
 }

bool folly::IPAddressV6::inSubnet ( StringPiece cidrNetwork ) const

Definition at line 329 of file IPAddressV6.cpp.

References addr, fetchMask(), inSubnetWithMask(), and folly::sformat().

Referenced by bitCount().

                                                         {
   auto subnetInfo = IPAddress::createNetwork(cidrNetwork);
   auto addr = subnetInfo.first;
   if (!addr.isV6()) {
     throw IPAddressFormatException(
         sformat("Address '{}' is not a V6 address", addr.toJson()));
   }
   return inSubnetWithMask(addr.asV6(), fetchMask(subnetInfo.second));
 }

bool folly::IPAddressV6::inSubnet	(	const IPAddressV6 &	subnet,
		uint8_t	cidr
	)		const

inline

Definition at line 205 of file IPAddressV6.h.

References fetchMask(), inSubnetWithMask(), isLoopback(), and mask().

                                                                {
     return inSubnetWithMask(subnet, fetchMask(cidr));
   }

bool folly::IPAddressV6::inSubnetWithMask	(	const IPAddressV6 &	subnet,
		const ByteArray16 &	mask
	)		const

Definition at line 340 of file IPAddressV6.cpp.

References folly::detail::Bytes::mask(), mask(), and toByteArray().

Referenced by inSubnet().

                                        {
   const auto mask = detail::Bytes::mask(toByteArray(), cidrMask);
   const auto subMask = detail::Bytes::mask(subnet.toByteArray(), cidrMask);
   return (mask == subMask);
 }

bool folly::IPAddressV6::is6To4 ( ) const

inline

Definition at line 170 of file IPAddressV6.h.

References type().

Referenced by getIPv4For6To4(), and folly::toAppend().

                       {
     return type() == IPAddressV6::Type::T6TO4;
   }

bool folly::IPAddressV6::isIPv4Mapped ( ) const

Definition at line 273 of file IPAddressV6.cpp.

References bytes(), and i.

Referenced by createIPv4(), hash(), isLoopback(), isPrivate(), and isTeredo().

                                      {
   // v4 mapped addresses have their first 10 bytes set to 0, the next 2 bytes
   // set to 255 (0xff);
   const unsigned char* by = bytes();
 
   // check if first 10 bytes are 0
   for (int i = 0; i < 10; i++) {
     if (by[i] != 0x00) {
       return false;
     }
   }
   // check if bytes 11 and 12 are 255
   if (by[10] == 0xff && by[11] == 0xff) {
     return true;
   }
   return false;
 }

bool folly::IPAddressV6::isLinkLocal ( ) const

Return true if this is a link-local IPv6 address.

Note that this only returns true for addresses in the fe80::/10 range. It returns false for the loopback address (::1), even though this address is also effectively has link-local scope. It also returns false for link-scope and interface-scope multicast addresses.

Definition at line 382 of file IPAddressV6.cpp.

References inBinarySubnet().

Referenced by getMacAddressFromLinkLocal(), and isNonroutable().

                                     {
   return inBinarySubnet({{0xfe, 0x80}}, 10);
 }

bool folly::IPAddressV6::isLinkLocalBroadcast ( ) const

Definition at line 367 of file IPAddressV6.cpp.

Referenced by isZero().

                                              {
   static const IPAddressV6 kLinkLocalBroadcast("ff02::1");
   return *this == kLinkLocalBroadcast;
 }

bool folly::IPAddressV6::isLoopback ( ) const

Definition at line 349 of file IPAddressV6.cpp.

References createIPv4(), isIPv4Mapped(), and toSockAddr().

Referenced by inSubnet(), and isPrivate().

                                    {
   // Check if v4 mapped is loopback
   if (isIPv4Mapped() && createIPv4().isLoopback()) {
     return true;
   }
   auto socka = toSockAddr();
   return IN6_IS_ADDR_LOOPBACK(&socka.sin6_addr);
 }

bool folly::IPAddressV6::isMulticast ( ) const

Return true if this is a multicast address.

Definition at line 386 of file IPAddressV6.cpp.

References addr_, and folly::IPAddressV6::AddressStorage::bytes_.

Referenced by folly::MacAddress::createMulticast(), getMulticastFlags(), getMulticastScope(), getSolicitedNodeAddress(), isNonroutable(), and isRoutable().

                                     {
   return addr_.bytes_[0] == 0xff;
 }

bool folly::IPAddressV6::isNonroutable ( ) const

inline

Definition at line 215 of file IPAddressV6.h.

References getMacAddressFromEUI64(), getMacAddressFromLinkLocal(), getMulticastFlags(), getMulticastScope(), isLinkLocal(), isMulticast(), isPrivate(), isRoutable(), and uint8_t.

                              {
     return !isRoutable();
   }

bool folly::IPAddressV6::isPrivate ( ) const

Definition at line 373 of file IPAddressV6.cpp.

References createIPv4(), inBinarySubnet(), isIPv4Mapped(), and isLoopback().

Referenced by isNonroutable().

                                   {
   // Check if mapped is private
   if (isIPv4Mapped() && createIPv4().isPrivate()) {
     return true;
   }
   return isLoopback() || inBinarySubnet({{0xfc, 0x00}}, 7);
 }

bool folly::IPAddressV6::isRoutable ( ) const

Return true if this address is routable.

Definition at line 358 of file IPAddressV6.cpp.

References getMulticastScope(), inBinarySubnet(), and isMulticast().

Referenced by isNonroutable().

                                    {
   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);
 }

bool folly::IPAddressV6::isTeredo ( ) const

inline

Definition at line 175 of file IPAddressV6.h.

References isIPv4Mapped(), and type().

                         {
     return type() == IPAddressV6::Type::TEREDO;
   }

bool folly::IPAddressV6::isZero ( ) const

inline

Definition at line 275 of file IPAddressV6.h.

References bytes(), isLinkLocalBroadcast(), and mask().

                       {
     constexpr auto zero = ByteArray16{{}};
     return 0 == std::memcmp(bytes(), zero.data(), zero.size());
   }

CIDRNetworkV6 folly::IPAddressV6::longestCommonPrefix	(	const CIDRNetworkV6 &	one,
		const CIDRNetworkV6 &	two
	)

static

Definition at line 521 of file IPAddressV6.cpp.

References IPAddressV6(), folly::detail::Bytes::longestCommonPrefix(), and prefix().

Referenced by folly::operator<(), TEST(), and version().

                               {
   auto prefix = detail::Bytes::longestCommonPrefix(
       one.first.addr_.bytes_, one.second, two.first.addr_.bytes_, two.second);
   return {IPAddressV6(prefix.first), prefix.second};
 }

IPAddressV6 folly::IPAddressV6::mask ( size_t numBits ) const

Definition at line 427 of file IPAddressV6.cpp.

References addr_, bitCount(), folly::IPAddressV6::AddressStorage::bytes_, fetchMask(), IPAddressV6(), folly::detail::Bytes::mask(), and folly::sformat().

Referenced by inBinarySubnet(), inSubnet(), inSubnetWithMask(), and isZero().

                                                   {
   static const auto bits = bitCount();
   if (numBits > bits) {
     throw IPAddressFormatException(
         sformat("numBits({}) > bitCount({})", numBits, bits));
   }
   ByteArray16 ba = detail::Bytes::mask(fetchMask(numBits), addr_.bytes_);
   return IPAddressV6(ba);
 }

void folly::IPAddressV6::setScopeId ( uint16_t scope )

inline

Definition at line 293 of file IPAddressV6.h.

References scope_.

Referenced by TEST().

                                   {
     scope_ = scope;
   }

string folly::IPAddressV6::str ( ) const

Definition at line 438 of file IPAddressV6.cpp.

References buffer(), bytes(), folly::errnoStr(), getScopeId(), folly::sformat(), string, toAddr(), and folly::detail::Bytes::toHex().

Referenced by getIPv4For6To4(), folly::operator<<(), TEST(), folly::toAppend(), toByteArray(), toJson(), and tryFromString().

                               {
   char buffer[INET6_ADDRSTRLEN + IFNAMSIZ + 1];
 
   if (!inet_ntop(AF_INET6, toAddr().s6_addr, buffer, INET6_ADDRSTRLEN)) {
     throw IPAddressFormatException(sformat(
         "Invalid address with hex '{}' with error {}",
         detail::Bytes::toHex(bytes(), 16),
         errnoStr(errno)));
   }
 
   auto scopeId = getScopeId();
   if (scopeId != 0) {
     auto len = strlen(buffer);
     buffer[len] = '%';
 
     auto errsv = errno;
     if (!if_indextoname(scopeId, buffer + len + 1)) {
       // if we can't map the if because eg. it no longer exists,
       // append the if index instead
       snprintf(buffer + len + 1, IFNAMSIZ, "%u", scopeId);
     }
     errno = errsv;
   }
 
   return string(buffer);
 }

auto folly::IPAddressV6::tie ( ) const

inlineprivate

Definition at line 379 of file IPAddressV6.h.

References addr_, folly::IPAddressV6::AddressStorage::bytes_, and scope_.

                    {
     return std::tie(addr_.bytes_, scope_);
   }

in6_addr folly::IPAddressV6::toAddr ( ) const

inline

Definition at line 286 of file IPAddressV6.h.

References addr_, and folly::IPAddressV6::AddressStorage::in6Addr_.

Referenced by BENCHMARK(), and str().

                           {
     return addr_.in6Addr_;
   }

ByteRange folly::IPAddressV6::toBinary ( ) const

inline

Returns the address as a Range.

Definition at line 129 of file IPAddressV6.h.

References addr_, createIPv4(), getIPv4For6To4(), folly::IPAddressV6::AddressStorage::in6Addr_, IPAddressV6(), and folly::pushmi::__adl::noexcept().

                              {
     return ByteRange((const unsigned char*)&addr_.in6Addr_.s6_addr, 16);
   }

ByteArray16 folly::IPAddressV6::toByteArray ( ) const

inline

Definition at line 306 of file IPAddressV6.h.

References bytes(), str(), string, toFullyQualified(), toFullyQualifiedAppend(), and toInverseArpaName().

Referenced by inSubnetWithMask().

                                   {
     ByteArray16 ba{{0}};
     std::memcpy(ba.data(), bytes(), 16);
     return ba;
   }

string folly::IPAddressV6::toFullyQualified ( ) const

Definition at line 466 of file IPAddressV6.cpp.

References addr_, folly::detail::fastIpv6ToString(), and folly::IPAddressV6::AddressStorage::in6Addr_.

Referenced by BENCHMARK(), BENCHMARK_RELATIVE(), and toByteArray().

                                            {
   return detail::fastIpv6ToString(addr_.in6Addr_);
 }

void folly::IPAddressV6::toFullyQualifiedAppend ( std::string & out ) const

Definition at line 471 of file IPAddressV6.cpp.

References addr_, folly::detail::fastIpv6AppendToString(), and folly::IPAddressV6::AddressStorage::in6Addr_.

Referenced by BENCHMARK_RELATIVE(), and toByteArray().

                                                              {
   detail::fastIpv6AppendToString(addr_.in6Addr_, out);
 }

string folly::IPAddressV6::toInverseArpaName ( ) const

Definition at line 476 of file IPAddressV6.cpp.

References a, bytes(), i, folly::join(), and folly::sformat().

Referenced by toByteArray().

                                             {
   constexpr folly::StringPiece lut = "0123456789abcdef";
   std::array<char, 32> a;
   int j = 0;
   for (int i = 15; i >= 0; i--) {
     a[j] = (lut[bytes()[i] & 0xf]);
     a[j + 1] = (lut[bytes()[i] >> 4]);
     j += 2;
   }
   return sformat("{}.ip6.arpa", join(".", a));
 }

string folly::IPAddressV6::toJson ( ) const

See also: IPAddress::toJson

Definition at line 309 of file IPAddressV6.cpp.

References hash(), folly::sformat(), and str().

Referenced by bitCount().

                                  {
   return sformat("{{family:'AF_INET6', addr:'{}', hash:{}}}", str(), hash());
 }

sockaddr_in6 folly::IPAddressV6::toSockAddr ( ) const

inline

Definition at line 297 of file IPAddressV6.h.

References addr, addr_, folly::IPAddressV6::AddressStorage::in6Addr_, and scope_.

Referenced by isLoopback(), and TEST().

                                   {
     sockaddr_in6 addr;
     memset(&addr, 0, sizeof(sockaddr_in6));
     addr.sin6_family = AF_INET6;
     addr.sin6_scope_id = scope_;
     memcpy(&addr.sin6_addr, &addr_.in6Addr_, sizeof(in6_addr));
     return addr;
   }

Expected< IPAddressV6, IPAddressFormatError > folly::IPAddressV6::tryFromBinary ( ByteRange bytes )

staticnoexcept

Non-throwing version of fromBinary(). On failure returns IPAddressFormatError.

Definition at line 178 of file IPAddressV6.cpp.

References addr, bytes(), folly::makeUnexpected(), folly::gen::move, and trySetFromBinary().

Referenced by fromBinary(), TEST(), TEST_P(), and folly::toAppend().

                               {
   IPAddressV6 addr;
   auto setResult = addr.trySetFromBinary(bytes);
   if (setResult.hasError()) {
     return makeUnexpected(std::move(setResult.error()));
   }
   return addr;
 }

Expected< IPAddressV6, IPAddressFormatError > folly::IPAddressV6::tryFromString ( StringPiece str )

staticnoexcept

Tries to create a new IPAddressV6 instance from provided string and returns it on success. Returns IPAddressFormatError on failure.

Definition at line 82 of file IPAddressV6.cpp.

References folly::INVALID_IP, IPAddressV6(), folly::makeUnexpected(), SCOPE_EXIT, and str().

Referenced by BENCHMARK(), BENCHMARK_RELATIVE(), IPAddressV6(), TEST_P(), and folly::toAppend().

                               {
   auto ip = str.str();
 
   // Allow addresses surrounded in brackets
   if (ip.size() < 2) {
     return makeUnexpected(IPAddressFormatError::INVALID_IP);
   }
   if (ip.front() == '[' && ip.back() == ']') {
     ip = ip.substr(1, ip.size() - 2);
   }
 
   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) == 0) {
     SCOPE_EXIT {
       ::freeaddrinfo(result);
     };
     const struct sockaddr_in6* sa =
         reinterpret_cast<struct sockaddr_in6*>(result->ai_addr);
     return IPAddressV6(*sa);
   }
   return makeUnexpected(IPAddressFormatError::INVALID_IP);
 }

Expected< Unit, IPAddressFormatError > folly::IPAddressV6::trySetFromBinary ( ByteRange bytes )

privatenoexcept

Set the current IPAddressV6 object to have the address specified by bytes. Returns IPAddressFormatError if bytes.size() is not 16.

Definition at line 188 of file IPAddressV6.cpp.

References addr_, bytes(), folly::IPAddressV6::AddressStorage::in6Addr_, folly::INVALID_IP, folly::makeUnexpected(), scope_, and folly::unit.

Referenced by tryFromBinary().

                               {
   if (bytes.size() != 16) {
     return makeUnexpected(IPAddressFormatError::INVALID_IP);
   }
   memcpy(&addr_.in6Addr_.s6_addr, bytes.data(), sizeof(in6_addr));
   scope_ = 0;
   return unit;
 }

IPAddressV6::Type folly::IPAddressV6::type ( ) const

Definition at line 292 of file IPAddressV6.cpp.

References bytes(), folly::NORMAL, uint16_t, uint32_t, and folly::unpackInto().

Referenced by is6To4(), and isTeredo().

                                         {
   // convert 16x8 bytes into first 2x16 bytes
   uint16_t ints[2] = {0, 0};
   unpackInto(bytes(), ints, 2);
 
   if ((((uint32_t)ints[0] << 16) | ints[1]) == IPAddressV6::PREFIX_TEREDO) {
     return Type::TEREDO;
   }
 
   if ((uint32_t)ints[0] == IPAddressV6::PREFIX_6TO4) {
     return Type::T6TO4;
   }
 
   return Type::NORMAL;
 }

bool folly::IPAddressV6::validate ( StringPiece ip )

staticnoexcept

Definition at line 65 of file IPAddressV6.cpp.

Referenced by TEST(), and folly::toAppend().

                                                   {
   return tryFromString(ip).hasValue();
 }

uint8_t folly::IPAddressV6::version ( ) const

inline

Definition at line 324 of file IPAddressV6.h.

References fetchMask(), getSolicitedNodeAddress(), and longestCommonPrefix().

                           {
     return 6;
   }

Friends And Related Function Documentation

bool operator!=	(	const IPAddressV6 &	a,
		const IPAddressV6 &	b
	)

friend

Definition at line 387 of file IPAddressV6.h.

                                                                             {
     return a.tie() != b.tie();
   }

bool operator<	(	const IPAddressV6 &	a,
		const IPAddressV6 &	b
	)

friend

Definition at line 390 of file IPAddressV6.h.

                                                                            {
     return a.tie() < b.tie();
   }

bool operator<=	(	const IPAddressV6 &	a,
		const IPAddressV6 &	b
	)

friend

Definition at line 396 of file IPAddressV6.h.

                                                                             {
     return a.tie() <= b.tie();
   }

bool operator==	(	const IPAddressV6 &	a,
		const IPAddressV6 &	b
	)

friend

Definition at line 384 of file IPAddressV6.h.

                                                                             {
     return a.tie() == b.tie();
   }

bool operator>	(	const IPAddressV6 &	a,
		const IPAddressV6 &	b
	)

friend

Definition at line 393 of file IPAddressV6.h.

                                                                            {
     return a.tie() > b.tie();
   }

bool operator>=	(	const IPAddressV6 &	a,
		const IPAddressV6 &	b
	)

friend

Definition at line 399 of file IPAddressV6.h.

                                                                             {
     return a.tie() >= b.tie();
   }

Member Data Documentation

union folly::IPAddressV6::AddressStorage folly::IPAddressV6::addr_

private

Referenced by folly::IPAddressV6::AddressStorage::AddressStorage(), bytes(), getMacAddressFromEUI64(), getMulticastFlags(), getMulticastScope(), getSolicitedNodeAddress(), hash(), isMulticast(), mask(), tie(), toAddr(), toBinary(), toFullyQualified(), toFullyQualifiedAppend(), toSockAddr(), and trySetFromBinary().

constexpr size_t folly::IPAddressV6::kToFullyQualifiedSize

static

Initial value:

8 * 4 + 7

Definition at line 93 of file IPAddressV6.h.

Referenced by BENCHMARK_RELATIVE(), and TEST().

const uint32_t folly::IPAddressV6::PREFIX_6TO4 = 0x2002

static

Definition at line 90 of file IPAddressV6.h.

Referenced by folly::IPAddressV4::getIPv6For6To4().

const uint32_t folly::IPAddressV6::PREFIX_TEREDO = 0x20010000

static

Definition at line 88 of file IPAddressV6.h.

uint16_t folly::IPAddressV6::scope_ {0}

private

Definition at line 417 of file IPAddressV6.h.

Referenced by getScopeId(), setScopeId(), tie(), toSockAddr(), and trySetFromBinary().

The documentation for this class was generated from the following files:

proxygen/folly/folly/IPAddressV6.h
proxygen/folly/folly/IPAddressV6.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation