blob: a6eeffd86bb1af1127440e9821e1a889968228c5 [file] [log] [blame]
// 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.
#include <cstdint>
#if defined(_WIN32)
#include <winsock2.h>
#include <ws2tcpip.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>
#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 QuicheIpAddress {
// 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(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 friend bool operator==(QuicheIpAddress lhs,
QuicheIpAddress rhs);
QUICHE_EXPORT 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. becomes
// ::ffff: 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;
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 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 friend bool operator==(const QuicheIpPrefix& lhs,
const QuicheIpPrefix& rhs);
QUICHE_EXPORT friend bool operator!=(const QuicheIpPrefix& lhs,
const QuicheIpPrefix& rhs);
QuicheIpAddress address_;
uint8_t prefix_length_;
inline std::ostream& operator<<(std::ostream& os, const QuicheIpPrefix prefix) {
os << prefix.ToString();
return os;
} // namespace quiche