Move QuicIpAddress and IpAddressFamily to third_party/quiche. Move them from third_party/quic to third_party/quiche because third_party/quiche/common/platform/api/quiche_test_loopback.h depends on them. Move them outside platform because they are not actually platformized. Leave aliases in place for the time being. Users will be migrated and aliases removed in a follow-up CL. PiperOrigin-RevId: 472516696
diff --git a/build/source_list.bzl b/build/source_list.bzl index 8c1584d..2f69820 100644 --- a/build/source_list.bzl +++ b/build/source_list.bzl
@@ -48,6 +48,8 @@ "common/quiche_data_reader.h", "common/quiche_data_writer.h", "common/quiche_endian.h", + "common/quiche_ip_address.h", + "common/quiche_ip_address_family.h", "common/quiche_linked_hash_map.h", "common/quiche_mem_slice_storage.h", "common/quiche_protocol_flags_list.h", @@ -406,6 +408,8 @@ "common/quiche_buffer_allocator.cc", "common/quiche_data_reader.cc", "common/quiche_data_writer.cc", + "common/quiche_ip_address.cc", + "common/quiche_ip_address_family.cc", "common/quiche_mem_slice_storage.cc", "common/quiche_text_utils.cc", "common/simple_buffer_allocator.cc", @@ -662,8 +666,6 @@ "quic/core/tls_server_handshaker.cc", "quic/core/uber_quic_stream_id_manager.cc", "quic/core/uber_received_packet_manager.cc", - "quic/platform/api/quic_ip_address.cc", - "quic/platform/api/quic_ip_address_family.cc", "quic/platform/api/quic_socket_address.cc", "spdy/core/array_output_buffer.cc", "spdy/core/hpack/hpack_constants.cc", @@ -1064,6 +1066,7 @@ "common/quiche_data_reader_test.cc", "common/quiche_data_writer_test.cc", "common/quiche_endian_test.cc", + "common/quiche_ip_address_test.cc", "common/quiche_linked_hash_map_test.cc", "common/quiche_mem_slice_storage_test.cc", "common/quiche_text_utils_test.cc", @@ -1269,7 +1272,6 @@ "quic/core/tls_server_handshaker_test.cc", "quic/core/uber_quic_stream_id_manager_test.cc", "quic/core/uber_received_packet_manager_test.cc", - "quic/platform/api/quic_ip_address_test.cc", "quic/platform/api/quic_socket_address_test.cc", "quic/test_tools/crypto_test_utils_test.cc", "quic/test_tools/quic_test_utils_test.cc",
diff --git a/build/source_list.gni b/build/source_list.gni index 74e2d35..9defb90 100644 --- a/build/source_list.gni +++ b/build/source_list.gni
@@ -48,6 +48,8 @@ "src/quiche/common/quiche_data_reader.h", "src/quiche/common/quiche_data_writer.h", "src/quiche/common/quiche_endian.h", + "src/quiche/common/quiche_ip_address.h", + "src/quiche/common/quiche_ip_address_family.h", "src/quiche/common/quiche_linked_hash_map.h", "src/quiche/common/quiche_mem_slice_storage.h", "src/quiche/common/quiche_protocol_flags_list.h", @@ -406,6 +408,8 @@ "src/quiche/common/quiche_buffer_allocator.cc", "src/quiche/common/quiche_data_reader.cc", "src/quiche/common/quiche_data_writer.cc", + "src/quiche/common/quiche_ip_address.cc", + "src/quiche/common/quiche_ip_address_family.cc", "src/quiche/common/quiche_mem_slice_storage.cc", "src/quiche/common/quiche_text_utils.cc", "src/quiche/common/simple_buffer_allocator.cc", @@ -662,8 +666,6 @@ "src/quiche/quic/core/tls_server_handshaker.cc", "src/quiche/quic/core/uber_quic_stream_id_manager.cc", "src/quiche/quic/core/uber_received_packet_manager.cc", - "src/quiche/quic/platform/api/quic_ip_address.cc", - "src/quiche/quic/platform/api/quic_ip_address_family.cc", "src/quiche/quic/platform/api/quic_socket_address.cc", "src/quiche/spdy/core/array_output_buffer.cc", "src/quiche/spdy/core/hpack/hpack_constants.cc", @@ -1064,6 +1066,7 @@ "src/quiche/common/quiche_data_reader_test.cc", "src/quiche/common/quiche_data_writer_test.cc", "src/quiche/common/quiche_endian_test.cc", + "src/quiche/common/quiche_ip_address_test.cc", "src/quiche/common/quiche_linked_hash_map_test.cc", "src/quiche/common/quiche_mem_slice_storage_test.cc", "src/quiche/common/quiche_text_utils_test.cc", @@ -1269,7 +1272,6 @@ "src/quiche/quic/core/tls_server_handshaker_test.cc", "src/quiche/quic/core/uber_quic_stream_id_manager_test.cc", "src/quiche/quic/core/uber_received_packet_manager_test.cc", - "src/quiche/quic/platform/api/quic_ip_address_test.cc", "src/quiche/quic/platform/api/quic_socket_address_test.cc", "src/quiche/quic/test_tools/crypto_test_utils_test.cc", "src/quiche/quic/test_tools/quic_test_utils_test.cc",
diff --git a/build/source_list.json b/build/source_list.json index 6e4aa67..8ab853a 100644 --- a/build/source_list.json +++ b/build/source_list.json
@@ -47,6 +47,8 @@ "quiche/common/quiche_data_reader.h", "quiche/common/quiche_data_writer.h", "quiche/common/quiche_endian.h", + "quiche/common/quiche_ip_address.h", + "quiche/common/quiche_ip_address_family.h", "quiche/common/quiche_linked_hash_map.h", "quiche/common/quiche_mem_slice_storage.h", "quiche/common/quiche_protocol_flags_list.h", @@ -405,6 +407,8 @@ "quiche/common/quiche_buffer_allocator.cc", "quiche/common/quiche_data_reader.cc", "quiche/common/quiche_data_writer.cc", + "quiche/common/quiche_ip_address.cc", + "quiche/common/quiche_ip_address_family.cc", "quiche/common/quiche_mem_slice_storage.cc", "quiche/common/quiche_text_utils.cc", "quiche/common/simple_buffer_allocator.cc", @@ -661,8 +665,6 @@ "quiche/quic/core/tls_server_handshaker.cc", "quiche/quic/core/uber_quic_stream_id_manager.cc", "quiche/quic/core/uber_received_packet_manager.cc", - "quiche/quic/platform/api/quic_ip_address.cc", - "quiche/quic/platform/api/quic_ip_address_family.cc", "quiche/quic/platform/api/quic_socket_address.cc", "quiche/spdy/core/array_output_buffer.cc", "quiche/spdy/core/hpack/hpack_constants.cc", @@ -1063,6 +1065,7 @@ "quiche/common/quiche_data_reader_test.cc", "quiche/common/quiche_data_writer_test.cc", "quiche/common/quiche_endian_test.cc", + "quiche/common/quiche_ip_address_test.cc", "quiche/common/quiche_linked_hash_map_test.cc", "quiche/common/quiche_mem_slice_storage_test.cc", "quiche/common/quiche_text_utils_test.cc", @@ -1268,7 +1271,6 @@ "quiche/quic/core/tls_server_handshaker_test.cc", "quiche/quic/core/uber_quic_stream_id_manager_test.cc", "quiche/quic/core/uber_received_packet_manager_test.cc", - "quiche/quic/platform/api/quic_ip_address_test.cc", "quiche/quic/platform/api/quic_socket_address_test.cc", "quiche/quic/test_tools/crypto_test_utils_test.cc", "quiche/quic/test_tools/quic_test_utils_test.cc",
diff --git a/quiche/quic/platform/api/quic_ip_address.cc b/quiche/common/quiche_ip_address.cc similarity index 64% rename from quiche/quic/platform/api/quic_ip_address.cc rename to quiche/common/quiche_ip_address.cc index ba7f6af..fd90deb 100644 --- a/quiche/quic/platform/api/quic_ip_address.cc +++ b/quiche/common/quiche_ip_address.cc
@@ -2,21 +2,21 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "quiche/quic/platform/api/quic_ip_address.h" +#include "quiche/common/quiche_ip_address.h" #include <algorithm> #include <cstdint> #include <cstring> #include <string> -#include "quiche/quic/platform/api/quic_bug_tracker.h" -#include "quiche/quic/platform/api/quic_ip_address_family.h" -#include "quiche/quic/platform/api/quic_logging.h" +#include "quiche/common/platform/api/quiche_bug_tracker.h" +#include "quiche/common/platform/api/quiche_logging.h" +#include "quiche/common/quiche_ip_address_family.h" -namespace quic { +namespace quiche { -QuicIpAddress QuicIpAddress::Loopback4() { - QuicIpAddress result; +QuicheIpAddress QuicheIpAddress::Loopback4() { + QuicheIpAddress result; result.family_ = IpAddressFamily::IP_V4; result.address_.bytes[0] = 127; result.address_.bytes[1] = 0; @@ -25,8 +25,8 @@ return result; } -QuicIpAddress QuicIpAddress::Loopback6() { - QuicIpAddress result; +QuicheIpAddress QuicheIpAddress::Loopback6() { + QuicheIpAddress result; result.family_ = IpAddressFamily::IP_V6; uint8_t* bytes = result.address_.bytes; memset(bytes, 0, 15); @@ -34,63 +34,65 @@ return result; } -QuicIpAddress QuicIpAddress::Any4() { +QuicheIpAddress QuicheIpAddress::Any4() { in_addr address; memset(&address, 0, sizeof(address)); - return QuicIpAddress(address); + return QuicheIpAddress(address); } -QuicIpAddress QuicIpAddress::Any6() { +QuicheIpAddress QuicheIpAddress::Any6() { in6_addr address; memset(&address, 0, sizeof(address)); - return QuicIpAddress(address); + return QuicheIpAddress(address); } -QuicIpAddress::QuicIpAddress() : family_(IpAddressFamily::IP_UNSPEC) {} +QuicheIpAddress::QuicheIpAddress() : family_(IpAddressFamily::IP_UNSPEC) {} -QuicIpAddress::QuicIpAddress(const in_addr& ipv4_address) +QuicheIpAddress::QuicheIpAddress(const in_addr& ipv4_address) : family_(IpAddressFamily::IP_V4) { address_.v4 = ipv4_address; } -QuicIpAddress::QuicIpAddress(const in6_addr& ipv6_address) +QuicheIpAddress::QuicheIpAddress(const in6_addr& ipv6_address) : family_(IpAddressFamily::IP_V6) { address_.v6 = ipv6_address; } -bool operator==(QuicIpAddress lhs, QuicIpAddress rhs) { +bool operator==(QuicheIpAddress lhs, QuicheIpAddress rhs) { if (lhs.family_ != rhs.family_) { return false; } switch (lhs.family_) { case IpAddressFamily::IP_V4: return std::equal(lhs.address_.bytes, - lhs.address_.bytes + QuicIpAddress::kIPv4AddressSize, + lhs.address_.bytes + QuicheIpAddress::kIPv4AddressSize, rhs.address_.bytes); case IpAddressFamily::IP_V6: return std::equal(lhs.address_.bytes, - lhs.address_.bytes + QuicIpAddress::kIPv6AddressSize, + lhs.address_.bytes + QuicheIpAddress::kIPv6AddressSize, rhs.address_.bytes); case IpAddressFamily::IP_UNSPEC: return true; } - QUIC_BUG(quic_bug_10126_2) + QUICHE_BUG(quiche_bug_10126_2) << "Invalid IpAddressFamily " << static_cast<int32_t>(lhs.family_); return false; } -bool operator!=(QuicIpAddress lhs, QuicIpAddress rhs) { return !(lhs == rhs); } +bool operator!=(QuicheIpAddress lhs, QuicheIpAddress rhs) { + return !(lhs == rhs); +} -bool QuicIpAddress::IsInitialized() const { +bool QuicheIpAddress::IsInitialized() const { return family_ != IpAddressFamily::IP_UNSPEC; } -IpAddressFamily QuicIpAddress::address_family() const { return family_; } +IpAddressFamily QuicheIpAddress::address_family() const { return family_; } -int QuicIpAddress::AddressFamilyToInt() const { +int QuicheIpAddress::AddressFamilyToInt() const { return ToPlatformAddressFamily(family_); } -std::string QuicIpAddress::ToPackedString() const { +std::string QuicheIpAddress::ToPackedString() const { switch (family_) { case IpAddressFamily::IP_V4: return std::string(address_.chars, sizeof(address_.v4)); @@ -99,12 +101,12 @@ case IpAddressFamily::IP_UNSPEC: return ""; } - QUIC_BUG(quic_bug_10126_3) + QUICHE_BUG(quiche_bug_10126_3) << "Invalid IpAddressFamily " << static_cast<int32_t>(family_); return ""; } -std::string QuicIpAddress::ToString() const { +std::string QuicheIpAddress::ToString() const { if (!IsInitialized()) { return ""; } @@ -112,7 +114,7 @@ char buffer[INET6_ADDRSTRLEN] = {0}; const char* result = inet_ntop(AddressFamilyToInt(), address_.bytes, buffer, sizeof(buffer)); - QUIC_BUG_IF(quic_bug_10126_4, result == nullptr) + QUICHE_BUG_IF(quiche_bug_10126_4, result == nullptr) << "Failed to convert an IP address to string"; return buffer; } @@ -121,7 +123,7 @@ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, }; -QuicIpAddress QuicIpAddress::Normalized() const { +QuicheIpAddress QuicheIpAddress::Normalized() const { if (!IsIPv6()) { return *this; } @@ -132,15 +134,15 @@ in_addr result; memcpy(&result, &address_.bytes[12], sizeof(result)); - return QuicIpAddress(result); + return QuicheIpAddress(result); } -QuicIpAddress QuicIpAddress::DualStacked() const { +QuicheIpAddress QuicheIpAddress::DualStacked() const { if (!IsIPv4()) { return *this; } - QuicIpAddress result; + QuicheIpAddress result; result.family_ = IpAddressFamily::IP_V6; memcpy(result.address_.bytes, kMappedAddressPrefix, sizeof(kMappedAddressPrefix)); @@ -148,7 +150,7 @@ return result; } -bool QuicIpAddress::FromPackedString(const char* data, size_t length) { +bool QuicheIpAddress::FromPackedString(const char* data, size_t length) { switch (length) { case kIPv4AddressSize: family_ = IpAddressFamily::IP_V4; @@ -163,7 +165,7 @@ return true; } -bool QuicIpAddress::FromString(std::string str) { +bool QuicheIpAddress::FromString(std::string str) { for (IpAddressFamily family : {IpAddressFamily::IP_V6, IpAddressFamily::IP_V4}) { int result = @@ -176,19 +178,23 @@ return false; } -bool QuicIpAddress::IsIPv4() const { return family_ == IpAddressFamily::IP_V4; } +bool QuicheIpAddress::IsIPv4() const { + return family_ == IpAddressFamily::IP_V4; +} -bool QuicIpAddress::IsIPv6() const { return family_ == IpAddressFamily::IP_V6; } +bool QuicheIpAddress::IsIPv6() const { + return family_ == IpAddressFamily::IP_V6; +} -bool QuicIpAddress::InSameSubnet(const QuicIpAddress& other, - int subnet_length) { +bool QuicheIpAddress::InSameSubnet(const QuicheIpAddress& other, + int subnet_length) { if (!IsInitialized()) { - QUIC_BUG(quic_bug_10126_5) + QUICHE_BUG(quiche_bug_10126_5) << "Attempting to do subnet matching on undefined address"; return false; } if ((IsIPv4() && subnet_length > 32) || (IsIPv6() && subnet_length > 128)) { - QUIC_BUG(quic_bug_10126_6) << "Subnet mask is out of bounds"; + QUICHE_BUG(quiche_bug_10126_6) << "Subnet mask is out of bounds"; return false; } @@ -207,14 +213,14 @@ return (lhs[bytes_to_check] & mask) == (rhs[bytes_to_check] & mask); } -in_addr QuicIpAddress::GetIPv4() const { +in_addr QuicheIpAddress::GetIPv4() const { QUICHE_DCHECK(IsIPv4()); return address_.v4; } -in6_addr QuicIpAddress::GetIPv6() const { +in6_addr QuicheIpAddress::GetIPv6() const { QUICHE_DCHECK(IsIPv6()); return address_.v6; } -} // namespace quic +} // namespace quiche
diff --git a/quiche/common/quiche_ip_address.h b/quiche/common/quiche_ip_address.h new file mode 100644 index 0000000..ef7714c --- /dev/null +++ b/quiche/common/quiche_ip_address.h
@@ -0,0 +1,98 @@ +// 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_ + +#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; +} + +} // namespace quiche + +#endif // QUICHE_COMMON_QUICHE_IP_ADDRESS_H_
diff --git a/quiche/quic/platform/api/quic_ip_address_family.cc b/quiche/common/quiche_ip_address_family.cc similarity index 79% rename from quiche/quic/platform/api/quic_ip_address_family.cc rename to quiche/common/quiche_ip_address_family.cc index c78abf2..885ddb6 100644 --- a/quiche/quic/platform/api/quic_ip_address_family.cc +++ b/quiche/common/quiche_ip_address_family.cc
@@ -2,9 +2,9 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "quiche/quic/platform/api/quic_ip_address_family.h" +#include "quiche/common/quiche_ip_address_family.h" -#include "quiche/quic/platform/api/quic_bug_tracker.h" +#include "quiche/common/platform/api/quiche_bug_tracker.h" #if defined(_WIN32) #include <winsock2.h> @@ -12,7 +12,7 @@ #include <sys/socket.h> #endif // defined(_WIN32) -namespace quic { +namespace quiche { int ToPlatformAddressFamily(IpAddressFamily family) { switch (family) { @@ -23,7 +23,7 @@ case IpAddressFamily::IP_UNSPEC: return AF_UNSPEC; default: - QUIC_BUG(quic_bug_10126_1) + QUICHE_BUG(quic_bug_10126_1) << "Invalid IpAddressFamily " << static_cast<int32_t>(family); return AF_UNSPEC; } @@ -38,10 +38,10 @@ case AF_UNSPEC: return IpAddressFamily::IP_UNSPEC; default: - QUIC_BUG(quic_FromPlatformAddressFamily_unrecognized_family) + QUICHE_BUG(quic_FromPlatformAddressFamily_unrecognized_family) << "Invalid platform address family int " << family; return IpAddressFamily::IP_UNSPEC; } } -} // namespace quic +} // namespace quiche
diff --git a/quiche/common/quiche_ip_address_family.h b/quiche/common/quiche_ip_address_family.h new file mode 100644 index 0000000..1fbec53 --- /dev/null +++ b/quiche/common/quiche_ip_address_family.h
@@ -0,0 +1,23 @@ +// 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_FAMILY_H_ +#define QUICHE_COMMON_QUICHE_IP_ADDRESS_FAMILY_H_ + +namespace quiche { + +// IP address family type used in QUIC. This hides platform dependant IP address +// family types. +enum class IpAddressFamily { + IP_V4, + IP_V6, + IP_UNSPEC, +}; + +int ToPlatformAddressFamily(IpAddressFamily family); +IpAddressFamily FromPlatformAddressFamily(int family); + +} // namespace quiche + +#endif // QUICHE_COMMON_QUICHE_IP_ADDRESS_FAMILY_H_
diff --git a/quiche/quic/platform/api/quic_ip_address_test.cc b/quiche/common/quiche_ip_address_test.cc similarity index 80% rename from quiche/quic/platform/api/quic_ip_address_test.cc rename to quiche/common/quiche_ip_address_test.cc index cc06917..609b6b2 100644 --- a/quiche/quic/platform/api/quic_ip_address_test.cc +++ b/quiche/common/quiche_ip_address_test.cc
@@ -2,19 +2,19 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "quiche/quic/platform/api/quic_ip_address.h" +#include "quiche/common/quiche_ip_address.h" #include <cstdint> -#include "quiche/quic/platform/api/quic_ip_address_family.h" -#include "quiche/quic/platform/api/quic_test.h" +#include "quiche/common/platform/api/quiche_test.h" +#include "quiche/common/quiche_ip_address_family.h" -namespace quic { +namespace quiche { namespace test { namespace { -TEST(QuicIpAddressTest, IPv4) { - QuicIpAddress ip_address; +TEST(QuicheIpAddressTest, IPv4) { + QuicheIpAddress ip_address; EXPECT_FALSE(ip_address.IsInitialized()); EXPECT_TRUE(ip_address.FromString("127.0.52.223")); @@ -34,8 +34,8 @@ EXPECT_EQ(223u, *(v4_address_ptr + 3)); } -TEST(QuicIpAddressTest, IPv6) { - QuicIpAddress ip_address; +TEST(QuicheIpAddressTest, IPv6) { + QuicheIpAddress ip_address; EXPECT_FALSE(ip_address.IsInitialized()); EXPECT_TRUE(ip_address.FromString("fe80::1ff:fe23:4567")); @@ -62,19 +62,19 @@ EXPECT_EQ(ip_address, ip_address.DualStacked()); } -TEST(QuicIpAddressTest, FromPackedString) { - QuicIpAddress loopback4, loopback6; +TEST(QuicheIpAddressTest, FromPackedString) { + QuicheIpAddress loopback4, loopback6; const char loopback4_packed[] = "\x7f\0\0\x01"; const char loopback6_packed[] = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01"; EXPECT_TRUE(loopback4.FromPackedString(loopback4_packed, 4)); EXPECT_TRUE(loopback6.FromPackedString(loopback6_packed, 16)); - EXPECT_EQ(loopback4, QuicIpAddress::Loopback4()); - EXPECT_EQ(loopback6, QuicIpAddress::Loopback6()); + EXPECT_EQ(loopback4, QuicheIpAddress::Loopback4()); + EXPECT_EQ(loopback6, QuicheIpAddress::Loopback6()); } -TEST(QuicIpAddressTest, MappedAddress) { - QuicIpAddress ipv4_address; - QuicIpAddress mapped_address; +TEST(QuicheIpAddressTest, MappedAddress) { + QuicheIpAddress ipv4_address; + QuicheIpAddress mapped_address; EXPECT_TRUE(ipv4_address.FromString("127.0.0.1")); EXPECT_TRUE(mapped_address.FromString("::ffff:7f00:1")); @@ -83,7 +83,7 @@ EXPECT_EQ(ipv4_address, mapped_address.Normalized()); } -TEST(QuicIpAddressTest, Subnets) { +TEST(QuicheIpAddressTest, Subnets) { struct { const char* address1; const char* address2; @@ -118,7 +118,7 @@ }; for (const auto& test_case : test_cases) { - QuicIpAddress address1, address2; + QuicheIpAddress address1, address2; ASSERT_TRUE(address1.FromString(test_case.address1)); ASSERT_TRUE(address2.FromString(test_case.address2)); EXPECT_EQ(test_case.same_subnet, @@ -128,15 +128,15 @@ } } -TEST(QuicIpAddress, LoopbackAddresses) { - QuicIpAddress loopback4; - QuicIpAddress loopback6; +TEST(QuicheIpAddress, LoopbackAddresses) { + QuicheIpAddress loopback4; + QuicheIpAddress loopback6; ASSERT_TRUE(loopback4.FromString("127.0.0.1")); ASSERT_TRUE(loopback6.FromString("::1")); - EXPECT_EQ(loopback4, QuicIpAddress::Loopback4()); - EXPECT_EQ(loopback6, QuicIpAddress::Loopback6()); + EXPECT_EQ(loopback4, QuicheIpAddress::Loopback4()); + EXPECT_EQ(loopback6, QuicheIpAddress::Loopback6()); } } // namespace } // namespace test -} // namespace quic +} // namespace quiche
diff --git a/quiche/quic/core/io/socket_posix.cc b/quiche/quic/core/io/socket_posix.cc index c8d1555..f72b088 100644 --- a/quiche/quic/core/io/socket_posix.cc +++ b/quiche/quic/core/io/socket_posix.cc
@@ -128,7 +128,7 @@ absl::StatusOr<SocketFd> CreateSocketWithFlags(IpAddressFamily address_family, SocketProtocol protocol, int flags) { - int address_family_int = ToPlatformAddressFamily(address_family); + int address_family_int = quiche::ToPlatformAddressFamily(address_family); int type_int = ToPlatformSocketType(protocol); type_int |= flags;
diff --git a/quiche/quic/core/quic_udp_socket_posix.cc b/quiche/quic/core/quic_udp_socket_posix.cc index 400f45b..248fee3 100644 --- a/quiche/quic/core/quic_udp_socket_posix.cc +++ b/quiche/quic/core/quic_udp_socket_posix.cc
@@ -205,10 +205,10 @@ // on ios/osx because CMSG_SPACE isn't a constant expression there. QUICHE_DCHECK_GE(kDefaultUdpPacketControlBufferSize, kMinCmsgSpaceForRead); - absl::StatusOr<SocketFd> socket = - socket_api::CreateSocket(FromPlatformAddressFamily(address_family), - socket_api::SocketProtocol::kUdp, - /*blocking=*/false); + absl::StatusOr<SocketFd> socket = socket_api::CreateSocket( + quiche::FromPlatformAddressFamily(address_family), + socket_api::SocketProtocol::kUdp, + /*blocking=*/false); if (!socket.ok()) { QUIC_LOG_FIRST_N(ERROR, 100)
diff --git a/quiche/quic/platform/api/quic_ip_address.h b/quiche/quic/platform/api/quic_ip_address.h index 685cde8..7f2ed20 100644 --- a/quiche/quic/platform/api/quic_ip_address.h +++ b/quiche/quic/platform/api/quic_ip_address.h
@@ -5,92 +5,11 @@ #ifndef QUICHE_QUIC_PLATFORM_API_QUIC_IP_ADDRESS_H_ #define QUICHE_QUIC_PLATFORM_API_QUIC_IP_ADDRESS_H_ -#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/quic/platform/api/quic_export.h" -#include "quiche/quic/platform/api/quic_ip_address_family.h" +#include "quiche/common/quiche_ip_address.h" namespace quic { -// Represents an IP address. -class QUIC_EXPORT_PRIVATE QuicIpAddress { - 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 QuicIpAddress Loopback4(); - static QuicIpAddress Loopback6(); - static QuicIpAddress Any4(); - static QuicIpAddress Any6(); - - QuicIpAddress(); - QuicIpAddress(const QuicIpAddress& other) = default; - explicit QuicIpAddress(const in_addr& ipv4_address); - explicit QuicIpAddress(const in6_addr& ipv6_address); - QuicIpAddress& operator=(const QuicIpAddress& other) = default; - QuicIpAddress& operator=(QuicIpAddress&& other) = default; - QUIC_EXPORT_PRIVATE friend bool operator==(QuicIpAddress lhs, - QuicIpAddress rhs); - QUIC_EXPORT_PRIVATE friend bool operator!=(QuicIpAddress lhs, - QuicIpAddress 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. - QuicIpAddress 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). - QuicIpAddress DualStacked() const; - bool FromPackedString(const char* data, size_t length); - bool FromString(std::string str); - bool IsIPv4() const; - bool IsIPv6() const; - bool InSameSubnet(const QuicIpAddress& 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 QuicIpAddress address) { - os << address.ToString(); - return os; -} +using QuicIpAddress = ::quiche::QuicheIpAddress; } // namespace quic
diff --git a/quiche/quic/platform/api/quic_ip_address_family.h b/quiche/quic/platform/api/quic_ip_address_family.h index ad3963c..0aeac17 100644 --- a/quiche/quic/platform/api/quic_ip_address_family.h +++ b/quiche/quic/platform/api/quic_ip_address_family.h
@@ -5,18 +5,11 @@ #ifndef QUICHE_QUIC_PLATFORM_API_QUIC_IP_ADDRESS_FAMILY_H_ #define QUICHE_QUIC_PLATFORM_API_QUIC_IP_ADDRESS_FAMILY_H_ +#include "quiche/common/quiche_ip_address_family.h" + namespace quic { -// IP address family type used in QUIC. This hides platform dependant IP address -// family types. -enum class IpAddressFamily { - IP_V4, - IP_V6, - IP_UNSPEC, -}; - -int ToPlatformAddressFamily(IpAddressFamily family); -IpAddressFamily FromPlatformAddressFamily(int family); +using IpAddressFamily = ::quiche::IpAddressFamily; } // namespace quic