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
