react-native-windows 0.85.0-preview.1 → 0.85.0

package/external/folly/folly/IPAddressV6.h

@@ -0,0 +1,627 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * A representation of an IPv6 address
+ *
+ * @see IPAddress
+ * @see IPAddressV4
+ *
+ * @class folly::IPAddressV6
+ */
+
+#pragma once
+
+#include <cstring>
+
+#include <array>
+#include <functional>
+#include <iosfwd>
+#include <map>
+#include <stdexcept>
+
+#include <folly/Expected.h>
+#include <folly/FBString.h>
+#include <folly/IPAddressException.h>
+#include <folly/Optional.h>
+#include <folly/Range.h>
+#include <folly/detail/IPAddress.h>
+#include <folly/hash/Hash.h>
+
+namespace folly {
+
+class IPAddress;
+class IPAddressV4;
+class IPAddressV6;
+class MacAddress;
+
+/**
+ * Pair of IPAddressV6, netmask
+ */
+typedef std::pair<IPAddressV6, uint8_t> CIDRNetworkV6;
+
+/**
+ * Specialization for `std::array` for IPv6 addresses
+ */
+typedef std::array<uint8_t, 16> ByteArray16;
+
+class IPAddressV6 {
+ public:
+  /**
+   * Represents the different types that IPv6 Addresses can be
+   *
+   */
+  enum Type {
+    TEREDO,
+    T6TO4,
+    NORMAL,
+  };
+
+  /**
+   * A constructor parameter to indicate that we should create a link-local
+   * IPAddressV6.
+   */
+  enum LinkLocalTag {
+    LINK_LOCAL,
+  };
+
+  /**
+   * Alias std::runtime_error, to be thrown when a type assertion fails
+   */
+  typedef std::runtime_error TypeError;
+
+  /**
+   * The binary prefix for Teredo networks
+   */
+  static const uint32_t PREFIX_TEREDO;
+
+  /**
+   * The binary prefix for Teredo networks
+   */
+  static const uint32_t PREFIX_6TO4;
+
+  /**
+   * The size of the std::string returned by toFullyQualified.
+   */
+  static constexpr size_t kToFullyQualifiedSize =
+      8 /*words*/ * 4 /*hex chars per word*/ + 7 /*separators*/;
+
+  /**
+   * Return true if the input string can be parsed as an IPv6 addres
+   */
+  static bool validate(StringPiece ip) noexcept;
+
+  /**
+   * Create a new IPAddressV6 instance from the provided binary data, in network
+   * byte order.
+   *
+   * @throws IPAddressFormatException if the input length is not 16 bytes.
+   */
+  static IPAddressV6 fromBinary(ByteRange bytes);
+
+  /**
+   * Create a new IPAddressV6 from the provided ByteRange.
+   *
+   * Returns an IPAddressFormatError if the input length is not 4 bytes.
+   */
+  static Expected<IPAddressV6, IPAddressFormatError> tryFromBinary(
+      ByteRange bytes) noexcept;
+
+  /**
+   * Create a new IPAddressV6 from the provided string.
+   *
+   * Returns an IPAddressFormatError if the string is not a valid IP.
+   */
+  static Expected<IPAddressV6, IPAddressFormatError> tryFromString(
+      StringPiece str) noexcept;
+
+  /**
+   * Create a new IPAddress instance from the ip6.arpa representation.
+   * @throws IPAddressFormatException if the input is not a valid ip6.arpa
+   * representation
+   */
+  static IPAddressV6 fromInverseArpaName(const std::string& arpaname);
+
+  /**
+   * Returns the address as a ByteRange.
+   */
+  ByteRange toBinary() const {
+    return ByteRange((const unsigned char*)&addr_.in6Addr_.s6_addr, 16);
+  }
+
+  /**
+   * Default constructor for IPAddressV6.
+   *
+   * The address value will be ::0
+   */
+  IPAddressV6();
+
+  /**
+   * Construct an IPAddressV6 from a string
+   *
+   * @throws IPAddressFormatException if the string is not a valid IPv6 address.
+   */
+  explicit IPAddressV6(StringPiece addr);
+
+  /**
+   * Construct an IPAddressV6 from a ByteArray16
+   */
+  explicit IPAddressV6(const ByteArray16& src) noexcept;
+
+  /**
+   * Construct an IPAddressV6 from an `in_addr` representation of an IPV6
+   * address
+   */
+  explicit IPAddressV6(const in6_addr& src) noexcept;
+
+  /**
+   * Construct an IPAddressV6 from an `sockaddr_in6` representation of an IPV6
+   * address
+   */
+  explicit IPAddressV6(const sockaddr_in6& src) noexcept;
+
+  /**
+   * Create a link-local IPAddressV6 from the specified ethernet MAC address.
+   */
+  IPAddressV6(LinkLocalTag tag, MacAddress mac);
+
+  /**
+   * Return the mapped IPAddressV4
+   *
+   * @throws IPAddressFormatException if the address is not IPv4 mapped
+   */
+  IPAddressV4 createIPv4() const;
+
+  /**
+   * Return a V4 address if this is a 6To4 address.
+   * @throws TypeError if not a 6To4 address
+   */
+  IPAddressV4 getIPv4For6To4() const;
+
+  /**
+   * Return true if the address is a 6to4 address
+   */
+  bool is6To4() const { return type() == IPAddressV6::Type::T6TO4; }
+
+  /**
+   * Return true if the address is a Teredo address
+   */
+  bool isTeredo() const { return type() == IPAddressV6::Type::TEREDO; }
+
+  /**
+   * Return true if the adddress is IPv4 mapped
+   */
+  bool isIPv4Mapped() const;
+
+  /**
+   * Return what type of IPv6 address this is.
+   *
+   * @see Type
+   */
+  Type type() const;
+
+  /**
+   * Return the number of bits in the IP address representation
+   *
+   * @returns 128
+   */
+  static constexpr size_t bitCount() { return 128; }
+
+  /**
+   * Get a json representation of the IP address.
+   *
+   * This prints a string representation of the address, for human consumption
+   * or logging. The string will take the form of a JSON object that looks like:
+   *  `{family:'AF_INET6', addr:'address', hash:long}`.
+   */
+  std::string toJson() const;
+
+  /**
+   * Returns a hash of the IP address.
+   */
+  size_t hash() const;
+
+  /**
+   * @overloadbrief Check if the address is found in the specified CIDR
+   * netblock.
+   *
+   * This will return false if the specified cidrNet is V4, but the address is
+   * V6. It will also return false if the specified cidrNet is V6 but the
+   * address is V4. This method will do the right thing in the case of a v6
+   * mapped v4 address.
+   *
+   * @note This is slower than the below counterparts. If perf is important use
+   *       one of the two argument variations below.
+   * @param [in] cidrNetwork address in "192.168.1.0/24" format
+   * @throws IPAddressFormatException if no /mask in cidrNetwork
+   * @return true if address is part of specified subnet with cidr
+   */
+  bool inSubnet(StringPiece cidrNetwork) const;
+
+  /**
+   * Check if an IPAddress belongs to a subnet.
+   *
+   * @param [in] subnet Subnet to check against (e.g. 192.168.1.0)
+   * @param [in] cidr   CIDR for subnet (e.g. 24 for /24)
+   * @return true if address is part of specified subnet with cidr
+   */
+  bool inSubnet(const IPAddressV6& subnet, uint8_t cidr) const {
+    return inSubnetWithMask(subnet, fetchMask(cidr));
+  }
+
+  /**
+   * Check if an IPAddress belongs to the subnet with the given mask.
+   *
+   * This is the same as inSubnet but the mask is provided instead of looked up
+   * from the cidr.
+   * @param [in] subnet Subnet to check against
+   * @param [in] mask   The netmask for the subnet
+   * @return true if address is part of the specified subnet with mask
+   */
+  bool inSubnetWithMask(
+      const IPAddressV6& subnet, const ByteArray16& mask) const;
+
+  /**
+   * Return true if the IP address qualifies as localhost.
+   */
+  bool isLoopback() const;
+
+  /**
+   * Return true if the IP address is a special purpose address, as defined per
+   * RFC 6890.
+   *
+   */
+  bool isNonroutable() const { return !isRoutable(); }
+
+  /**
+   * Return true if this address is routable.
+   */
+  bool isRoutable() const;
+
+  /**
+   * Return true if the IP address is private, as per RFC 1918 and RFC 4193.
+   *
+   * For example, 192.168.xxx.xxx or fc00::/7 addresses.
+   */
+  bool isPrivate() 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.
+   */
+  bool isLinkLocal() const;
+
+  /**
+   * Return the mac address if this is a link-local IPv6 address.
+   *
+   * @return a `folly::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.
+   */
+  Optional<MacAddress> getMacAddressFromLinkLocal() const;
+
+  /**
+   * Return the mac address if this is an auto-configured IPv6 address based on
+   * EUI-64
+   *
+   * 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.
+   *
+   * @return a `folly::Optional<MacAddress>` union representing the mac address.
+   *
+   */
+  Optional<MacAddress> getMacAddressFromEUI64() const;
+
+  /**
+   * Return true if this is a multicast address.
+   */
+  bool isMulticast() const;
+
+  /**
+   * Return the flags for a multicast address.
+   *
+   * This method may only be called on multicast addresses.
+   */
+  uint8_t getMulticastFlags() const;
+
+  /**
+   * Return the scope for a multicast address.
+   *
+   * This method may only be called on multicast addresses.
+   */
+  uint8_t getMulticastScope() const;
+
+  /**
+   * Return true if the address is 0
+   */
+  bool isZero() const {
+    constexpr auto zero = ByteArray16{{}};
+    return 0 == std::memcmp(bytes(), zero.data(), zero.size());
+  }
+
+  /**
+   * Return true if the IP address qualifies as broadcast.
+   */
+  bool isLinkLocalBroadcast() const;
+
+  /**
+   * Creates an IPAddressV6 instance with all but most significant numBits set
+   * to 0.
+   *
+   * @throws IPAddressFormatException if `numBits > bitCount()`
+   *
+   * @param [in] numBits number of bits to mask
+   * @return IPAddress instance with bits set to 0
+   */
+  IPAddressV6 mask(size_t numBits) const;
+
+  /**
+   * Return the underlying `in6_addr` structure
+   */
+  in6_addr toAddr() const { return addr_.in6Addr_; }
+
+  /**
+   * Return the link-local scope id.
+   *
+   * This should always be 0 for IP addresses that are *not* link-local.
+   *
+   */
+  uint16_t getScopeId() const { return scope_; }
+  /**
+   * Set the link-local scope id.
+   *
+   * This should always be 0 for IP addresses that are *not* link-local.
+   *
+   */
+  void setScopeId(uint16_t scope) { scope_ = scope; }
+
+  /**
+   * Return the IP address represented as a `sockaddr_in6` struct
+   *
+   */
+  sockaddr_in6 toSockAddr() const {
+    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;
+  }
+
+  /**
+   * Return a ByteArray16 containing the bytes of the IP address.
+   */
+  ByteArray16 toByteArray() const {
+    ByteArray16 ba{{0}};
+    std::memcpy(ba.data(), bytes(), 16);
+    return ba;
+  }
+
+  /**
+   * Return the fully qualified string representation of the address.
+   *
+   * This is the hex representation with : characters inserted every 4 digits.
+   */
+  std::string toFullyQualified() const;
+
+  /**
+   * Same as toFullyQualified() but append to an output string.
+   */
+  void toFullyQualifiedAppend(std::string& out) const;
+
+  /**
+   * Create the inverse arpa representation of the IP address.
+   *
+   */
+  std::string toInverseArpaName() const;
+
+  /**
+   * Provides a string representation of address.
+   *
+   * Throws an IPAddressFormatException on `inet_ntop` error.
+   *
+   * The string representation is calculated on demand.
+   */
+  std::string str() const;
+
+  /**
+   * Returns the version of the IP Address.
+   *
+   * @returns 6
+   */
+  uint8_t version() const { return 6; }
+
+  /**
+   * Return the solicited-node multicast address for this address.
+   */
+  IPAddressV6 getSolicitedNodeAddress() const;
+
+  /**
+   * 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}.
+   * @param [in] numBits bitmask to retrieve
+   * @throws abort if numBits == 0 or numBits > bitCount()
+   * @return mask associated with numBits
+   */
+
+  static ByteArray16 fetchMask(size_t numBits);
+
+  /**
+   * Given 2 (IPAddressV6, mask) pairs extract the longest common (IPAddressV6,
+   * mask) pair
+   */
+  static CIDRNetworkV6 longestCommonPrefix(
+      const CIDRNetworkV6& one, const CIDRNetworkV6& two);
+
+  /**
+   * The number of bytes in the IP address
+   *
+   * @returns 16
+   */
+  static constexpr size_t byteCount() { return 16; }
+
+  /**
+   * Get the nth most significant bit of the IP address (0-indexed).
+   * @param bitIndex n
+   */
+  bool getNthMSBit(size_t bitIndex) const {
+    return detail::getNthMSBitImpl(*this, bitIndex, AF_INET6);
+  }
+
+  /**
+   * Get the nth most significant byte of the IP address (0-indexed).
+   * @param byteIndex n
+   */
+  uint8_t getNthMSByte(size_t byteIndex) const;
+
+  /**
+   * Get the nth bit of the IP address (0-indexed).
+   * @param bitIndex n
+   */
+  bool getNthLSBit(size_t bitIndex) const {
+    return getNthMSBit(bitCount() - bitIndex - 1);
+  }
+
+  /**
+   * Get the nth byte of the IP address (0-indexed).
+   * @param byteIndex n
+   */
+  uint8_t getNthLSByte(size_t byteIndex) const {
+    return getNthMSByte(byteCount() - byteIndex - 1);
+  }
+
+  /**
+   * Returns a pointer to the to IP address bytes, in network byte order.
+   */
+  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<uint8_t, 2> addr, size_t numBits) const;
+
+ private:
+  auto tie() const { return std::tie(addr_.bytes_, scope_); }
+
+ public:
+  /**
+   * Return true if the two addresses are equal.
+   */
+  friend inline bool operator==(
+      const IPAddressV6& addr1, const IPAddressV6& addr2) {
+    return addr1.tie() == addr2.tie();
+  }
+  /**
+   * Return true if the two addresses are not equal.
+   */
+  friend inline bool operator!=(
+      const IPAddressV6& addr1, const IPAddressV6& addr2) {
+    return addr1.tie() != addr2.tie();
+  }
+
+  /**
+   * Return true if addr1 < addr2.
+   */
+  friend inline bool operator<(
+      const IPAddressV6& addr1, const IPAddressV6& addr2) {
+    return addr1.tie() < addr2.tie();
+  }
+
+  /**
+   * Return true if addr1 > addr2.
+   */
+  friend inline bool operator>(
+      const IPAddressV6& addr1, const IPAddressV6& addr2) {
+    return addr1.tie() > addr2.tie();
+  }
+
+  /**
+   * Return true if addr1 <= addr2.
+   */
+  friend inline bool operator<=(
+      const IPAddressV6& addr1, const IPAddressV6& addr2) {
+    return addr1.tie() <= addr2.tie();
+  }
+
+  /**
+   * Return true if addr1 >= addr2.
+   */
+  friend inline bool operator>=(
+      const IPAddressV6& addr1, const IPAddressV6& addr2) {
+    return addr1.tie() >= addr2.tie();
+  }
+
+ private:
+  union AddressStorage {
+    in6_addr in6Addr_;
+    ByteArray16 bytes_;
+    AddressStorage() { std::memset(this, 0, sizeof(AddressStorage)); }
+    explicit AddressStorage(const ByteArray16& bytes) : bytes_(bytes) {}
+    explicit AddressStorage(const in6_addr& addr) : in6Addr_(addr) {}
+    explicit AddressStorage(MacAddress mac);
+  } addr_;
+
+  // Link-local scope id.  This should always be 0 for IPAddresses that
+  // are *not* link-local.
+  uint16_t scope_{0};
+
+  /**
+   * Set the current IPAddressV6 object to have the address specified by bytes.
+   * Returns IPAddressFormatError if bytes.size() is not 16.
+   */
+  Expected<Unit, IPAddressFormatError> trySetFromBinary(
+      ByteRange bytes) noexcept;
+};
+
+/**
+ * `boost::hash` uses hash_value(), so this allows `boost::hash` to work
+ * automatically for IPAddressV4
+ */
+std::size_t hash_value(const IPAddressV6& addr);
+
+/**
+ * Appends a string representation of the IP address to the stream using str().
+ */
+
+std::ostream& operator<<(std::ostream& os, const IPAddressV6& addr);
+
+/**
+ * @overloadbrief Define toAppend() to allow IPAddress to be used with
+ * `folly::to<string>`
+ */
+void toAppend(IPAddressV6 addr, std::string* result);
+void toAppend(IPAddressV6 addr, fbstring* result);
+
+} // namespace folly
+
+namespace std {
+template <>
+struct hash<folly::IPAddressV6> {
+  size_t operator()(const folly::IPAddressV6& addr) const {
+    return addr.hash();
+  }
+};
+} // namespace std