| // Copyright 2017 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #ifndef SRC_LIB_INET_IP_ADDRESS_H_ | |
| #define SRC_LIB_INET_IP_ADDRESS_H_ | |
| #include <arpa/inet.h> | |
| #include <fuchsia/net/cpp/fidl.h> | |
| #include <lib/syslog/cpp/macros.h> | |
| namespace inet { | |
| // Represents a V4 or V6 IP address. | |
| class IpAddress { | |
| public: | |
| static const IpAddress kInvalid; | |
| static const IpAddress kV4Loopback; | |
| static const IpAddress kV6Loopback; | |
| // Creates an IpAddress from a string containing a numeric IP address. Returns |kInvalid| if | |
| // |address_string| cannot be converted into a valid IP address. | |
| // | |
| // If |family| is |AF_UNSPEC|, this function accepts both IPv4 and IPv6 address strings. If | |
| // |family| is |AF_INET| only IPv4 strings are accepted, and if |family| is |AF_INET6|, only | |
| // IPv6 strings are accepted. | |
| // | |
| // IPv6 address strings may be non-canonical in the following respects: | |
| // 1) A pair of colons may be substituted for one or more zeros (rather than two or more). | |
| // 2) The run of zeros replaced by a pair of colons need not be the longest run of zeros, and, | |
| // in the case of a tie, need not be the left-most run of zeros. | |
| // 3) Zeros may occur adjacent to a pair of colons. | |
| // 4) Upper-case hexadecimal digits are allowed. | |
| // 5) Hexadecimal words may have leading zeros. | |
| // | |
| // The following constraints apply to IPv6 address strings: | |
| // 1) At most one pair of colons may appear in the string. | |
| // 2) A string that has no colon pairs must contain exactly eight words. | |
| // 3) Hexadecimal words may have at most 4 digits. | |
| // 4) Mixed (IPv6 and IPv4) address strings are not supported. | |
| static IpAddress FromString(const std::string& address_string, sa_family_t family = AF_UNSPEC); | |
| // Parses an IpAddress prefixing a string view. If the parse succeeds, this method returns the | |
| // valid IpAddress and the number of characters that were parsed to produce it. If the parse | |
| // fails, this method returns an invalid IpAddress and zero. See |FromString| for details about | |
| // how the string is parsed. | |
| // | |
| // Note that this method looks for a valid address string in the initial position in the string | |
| // view. This means that inputs such as "::anything" will produce a successful result: in this | |
| // case, the IPv6 unspecified address "::" and 2 characters parsed. If the caller wants to | |
| // know whether the entire string view constitutes a valid address, it will be necessary to | |
| // compare the returned number of parsed characters to the length of the string view, e.g. | |
| // | |
| // auto result = IpAddress::FromStringView(string_view); | |
| // if (result.first.is_valid() && result.second == string_view.size()) { | |
| // // Do something with result.first. | |
| // } | |
| // | |
| static std::pair<IpAddress, size_t> FromStringView(std::string_view string_view, | |
| sa_family_t family = AF_UNSPEC); | |
| // Creates an invalid IP address. | |
| IpAddress(); | |
| // Creates an IPV4 address from four address bytes. | |
| IpAddress(uint8_t b0, uint8_t b1, uint8_t b2, uint8_t b3); | |
| // Creates an IPV4 address from an in_addr_t. | |
| explicit IpAddress(in_addr_t addr); | |
| // Creates an IPV4 address from an in_addr struct. | |
| explicit IpAddress(const in_addr& addr); | |
| // Creates an IPV6 address from eight address words. | |
| IpAddress(uint16_t w0, uint16_t w1, uint16_t w2, uint16_t w3, uint16_t w4, uint16_t w5, | |
| uint16_t w6, uint16_t w7); | |
| // Creates an IPV6 address from two address words (first and last). | |
| IpAddress(uint16_t w0, uint16_t w7); | |
| // Creates an IPV6 address from a vector of words. The address starts with |start| words of value | |
| // zero followed by the values from |source|, followed by zeros to fill the remainder. | |
| explicit IpAddress(const std::vector<uint16_t>& source, size_t start = 0); | |
| // Creates an IPV6 address from an in6_addr struct. | |
| explicit IpAddress(const in6_addr& addr); | |
| // Creates an address from a sockaddr struct. | |
| explicit IpAddress(const sockaddr& addr); | |
| // Creates an address from a sockaddr_storage struct. | |
| explicit IpAddress(const sockaddr_storage& addr); | |
| // Creates an address from a fuchsia.net Ipv4Address struct. | |
| explicit IpAddress(const fuchsia::net::Ipv4Address& addr); | |
| // Creates an address from a fuchsia.net Ipv6Address struct. | |
| explicit IpAddress(const fuchsia::net::Ipv6Address& addr); | |
| // Creates an address from a fuchsia.net IpAddress struct. | |
| explicit IpAddress(const fuchsia::net::IpAddress& addr); | |
| // Indicates whether this address is valid. | |
| bool is_valid() const { return family_ != AF_UNSPEC; } | |
| // Returns the family of this address: |AF_INET| for V4, |AF_INET6| for V6 and | |
| // |AF_UNSPEC| for an invalid address. | |
| sa_family_t family() const { return family_; } | |
| // Indicates whether this address is a V4 address. | |
| bool is_v4() const { return family() == AF_INET; } | |
| // Indicates whether this address is a V6 address. | |
| bool is_v6() const { return family() == AF_INET6; } | |
| // Indicates whether this address is a V6 address that is mapped from a V4 address. | |
| bool is_mapped_from_v4() const; | |
| // Returns the V4 address from a V6 address that is mapped from a V4 address. Calling this method | |
| // is only permitted if this address returns true from |is_mapped_from_v4|. | |
| IpAddress mapped_v4_address() const; | |
| // Returns the V6 address that is the mapping of this address, which must be a V4 address. | |
| IpAddress mapped_as_v6() const; | |
| // Indicates whether this address is a loopback address. | |
| bool is_loopback() const; | |
| // Indicates whether this address is link-local (IPv4: in 169.254.0.0/16, IPv6: in fe80::/10). | |
| bool is_link_local() const; | |
| // Returns this address as an |in_addr|. Only defined for V4 addresses. | |
| const in_addr& as_in_addr() const { | |
| FX_DCHECK(is_v4()); | |
| return v4_; | |
| } | |
| // Returns this address as an |in_addr_t|. Only defined for V4 addresses. | |
| in_addr_t as_in_addr_t() const { | |
| FX_DCHECK(is_v4()); | |
| return v4_.s_addr; | |
| } | |
| // Returns this address as an |in6_addr|. Only defined for V6 addresses. | |
| const in6_addr& as_in6_addr() const { | |
| FX_DCHECK(is_v6()); | |
| return v6_; | |
| } | |
| // Returns a pointer to the bytes that make up this address. |byte_count| | |
| // indicates the byte count. Not defined for invalid addresses. | |
| const uint8_t* as_bytes() const { | |
| FX_DCHECK(is_valid()); | |
| return is_v4() ? reinterpret_cast<const uint8_t*>(&v4_.s_addr) : v6_.s6_addr; | |
| } | |
| // Returns a pointer to the network-order words (big-endian) that make up the | |
| // address. |word_count| indicates the byte count. This is only defined for | |
| // V6 addresses. | |
| const uint16_t* as_v6_words() const { | |
| FX_DCHECK(is_v6()); | |
| return v6_.s6_addr16; | |
| } | |
| // Returns the number of bytes that make up this address. A V4 address is | |
| // 4 bytes, and a V6 address is 16 bytes. Not defined for invalid addresses. | |
| size_t byte_count() const { | |
| FX_DCHECK(is_valid()); | |
| return is_v4() ? sizeof(in_addr) : sizeof(in6_addr); | |
| } | |
| // Returns the number of words that make up this address. A V4 address is | |
| // 2 words, and a V6 address is 8 words. Not defined for invalid addresses. | |
| size_t word_count() const { | |
| FX_DCHECK(is_valid()); | |
| return byte_count() / sizeof(uint16_t); | |
| } | |
| // Returns a string representation of this address. V6 addresses are | |
| // represented as specified in RFC 5952. For invalid addresses, this method | |
| // returns "<invalid>". | |
| std::string ToString() const; | |
| explicit operator bool() const { return is_valid(); } | |
| bool operator==(const IpAddress& other) const { | |
| return family() == other.family() && | |
| (!is_valid() || (std::memcmp(as_bytes(), other.as_bytes(), byte_count()) == 0)); | |
| } | |
| bool operator!=(const IpAddress& other) const { return !(*this == other); } | |
| explicit operator fuchsia::net::Ipv4Address() const; | |
| explicit operator fuchsia::net::Ipv6Address() const; | |
| explicit operator fuchsia::net::IpAddress() const; | |
| private: | |
| sa_family_t family_; | |
| union { | |
| in_addr v4_; | |
| in6_addr v6_; | |
| }; | |
| }; | |
| // Inserts a string representation of |value|. V6 addresses are represented as | |
| // specified in RFC 5952. For invalid addresses, this method inserts | |
| // "<invalid>". | |
| std::ostream& operator<<(std::ostream& os, const IpAddress& value); | |
| } // namespace inet | |
| template <> | |
| struct std::hash<inet::IpAddress> { | |
| std::size_t operator()(const inet::IpAddress& address) const noexcept { | |
| if (!address.is_valid()) | |
| return 0; | |
| size_t hash = 0; | |
| if (address.is_v4()) { | |
| auto byte_ptr = address.as_bytes(); | |
| for (size_t i = 0; i < address.byte_count(); ++i) { | |
| hash = (hash << 1) ^ *byte_ptr; | |
| ++byte_ptr; | |
| } | |
| } else { | |
| auto word_ptr = address.as_v6_words(); | |
| for (size_t i = 0; i < address.word_count(); ++i) { | |
| hash = (hash << 1) ^ *word_ptr; | |
| ++word_ptr; | |
| } | |
| } | |
| return hash; | |
| } | |
| }; | |
| #endif // SRC_LIB_INET_IP_ADDRESS_H_ |