| // Copyright (c) 2016 The Chromium 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 QUICHE_COMMON_QUICHE_IP_ADDRESS_H_ |
| #define QUICHE_COMMON_QUICHE_IP_ADDRESS_H_ |
| |
| #include <cstdint> |
| #if defined(_WIN32) |
| #include <winsock2.h> |
| #include <ws2tcpip.h> |
| #else |
| #include <arpa/inet.h> |
| #include <netinet/in.h> |
| #include <sys/socket.h> |
| #include <sys/types.h> |
| #endif |
| |
| #include <ostream> |
| #include <string> |
| |
| #include "quiche/common/platform/api/quiche_export.h" |
| #include "quiche/common/quiche_ip_address_family.h" |
| |
| namespace quiche { |
| |
| // Represents an IP address. |
| class QUICHE_EXPORT_PRIVATE QuicheIpAddress { |
| public: |
| // Sizes of IP addresses of different types, in bytes. |
| enum : size_t { |
| kIPv4AddressSize = 32 / 8, |
| kIPv6AddressSize = 128 / 8, |
| kMaxAddressSize = kIPv6AddressSize, |
| }; |
| |
| // TODO(fayang): Remove Loopback*() and use TestLoopback*() in tests. |
| static QuicheIpAddress Loopback4(); |
| static QuicheIpAddress Loopback6(); |
| static QuicheIpAddress Any4(); |
| static QuicheIpAddress Any6(); |
| |
| QuicheIpAddress(); |
| QuicheIpAddress(const QuicheIpAddress& other) = default; |
| explicit QuicheIpAddress(const in_addr& ipv4_address); |
| explicit QuicheIpAddress(const in6_addr& ipv6_address); |
| QuicheIpAddress& operator=(const QuicheIpAddress& other) = default; |
| QuicheIpAddress& operator=(QuicheIpAddress&& other) = default; |
| QUICHE_EXPORT_PRIVATE friend bool operator==(QuicheIpAddress lhs, |
| QuicheIpAddress rhs); |
| QUICHE_EXPORT_PRIVATE friend bool operator!=(QuicheIpAddress lhs, |
| QuicheIpAddress rhs); |
| |
| bool IsInitialized() const; |
| IpAddressFamily address_family() const; |
| int AddressFamilyToInt() const; |
| // Returns the address as a sequence of bytes in network-byte-order. IPv4 will |
| // be 4 bytes. IPv6 will be 16 bytes. |
| std::string ToPackedString() const; |
| // Returns string representation of the address. |
| std::string ToString() const; |
| // Normalizes the address representation with respect to IPv4 addresses, i.e, |
| // mapped IPv4 addresses ("::ffff:X.Y.Z.Q") are converted to pure IPv4 |
| // addresses. All other IPv4, IPv6, and empty values are left unchanged. |
| QuicheIpAddress Normalized() const; |
| // Returns an address suitable for use in IPv6-aware contexts. This is the |
| // opposite of NormalizeIPAddress() above. IPv4 addresses are converted into |
| // their IPv4-mapped address equivalents (e.g. 192.0.2.1 becomes |
| // ::ffff:192.0.2.1). IPv6 addresses are a noop (they are returned |
| // unchanged). |
| QuicheIpAddress DualStacked() const; |
| bool FromPackedString(const char* data, size_t length); |
| bool FromString(std::string str); |
| bool IsIPv4() const; |
| bool IsIPv6() const; |
| bool InSameSubnet(const QuicheIpAddress& other, int subnet_length); |
| |
| in_addr GetIPv4() const; |
| in6_addr GetIPv6() const; |
| |
| private: |
| union { |
| in_addr v4; |
| in6_addr v6; |
| uint8_t bytes[kMaxAddressSize]; |
| char chars[kMaxAddressSize]; |
| } address_; |
| IpAddressFamily family_; |
| }; |
| |
| inline std::ostream& operator<<(std::ostream& os, |
| const QuicheIpAddress address) { |
| os << address.ToString(); |
| return os; |
| } |
| |
| // Represents an IP prefix, which is an IP address and a prefix length in bits. |
| class QUICHE_EXPORT_PRIVATE QuicheIpPrefix { |
| public: |
| QuicheIpPrefix(); |
| explicit QuicheIpPrefix(const QuicheIpAddress& address); |
| explicit QuicheIpPrefix(const QuicheIpAddress& address, |
| uint8_t prefix_length); |
| |
| QuicheIpAddress address() const { return address_; } |
| uint8_t prefix_length() const { return prefix_length_; } |
| // Human-readable string representation of the prefix suitable for logging. |
| std::string ToString() const; |
| |
| QuicheIpPrefix(const QuicheIpPrefix& other) = default; |
| QuicheIpPrefix& operator=(const QuicheIpPrefix& other) = default; |
| QuicheIpPrefix& operator=(QuicheIpPrefix&& other) = default; |
| QUICHE_EXPORT_PRIVATE friend bool operator==(const QuicheIpPrefix& lhs, |
| const QuicheIpPrefix& rhs); |
| QUICHE_EXPORT_PRIVATE friend bool operator!=(const QuicheIpPrefix& lhs, |
| const QuicheIpPrefix& rhs); |
| |
| private: |
| QuicheIpAddress address_; |
| uint8_t prefix_length_; |
| }; |
| |
| inline std::ostream& operator<<(std::ostream& os, const QuicheIpPrefix prefix) { |
| os << prefix.ToString(); |
| return os; |
| } |
| |
| } // namespace quiche |
| |
| #endif // QUICHE_COMMON_QUICHE_IP_ADDRESS_H_ |