No OneTemporary
Actions

Size

55 KB

Subscribers

None

View Options

	diff --git a/src/netaddress.cpp b/src/netaddress.cpp
	index a2e7e8955..6356bf913 100644
	--- a/src/netaddress.cpp
	+++ b/src/netaddress.cpp
	@@ -1,1186 +1,1186 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2016 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include <netaddress.h>

	#include <crypto/common.h>
	#include <crypto/sha3.h>
	#include <hash.h>
	#include <prevector.h>
	#include <util/asmap.h>
	#include <util/strencodings.h>
	#include <util/string.h>

	#include <tinyformat.h>

	#include <algorithm>
	#include <array>
	#include <cstdint>
	#include <ios>
	#include <iterator>
	#include <tuple>

	constexpr size_t CNetAddr::V1_SERIALIZATION_SIZE;
	constexpr size_t CNetAddr::MAX_ADDRV2_SIZE;

	CNetAddr::BIP155Network CNetAddr::GetBIP155Network() const {
	switch (m_net) {
	case NET_IPV4:
	return BIP155Network::IPV4;
	case NET_IPV6:
	return BIP155Network::IPV6;
	case NET_ONION:
	switch (m_addr.size()) {
	case ADDR_TORV2_SIZE:
	return BIP155Network::TORV2;
	case ADDR_TORV3_SIZE:
	return BIP155Network::TORV3;
	default:
	assert(false);
	}
	case NET_I2P:
	return BIP155Network::I2P;
	case NET_CJDNS:
	return BIP155Network::CJDNS;
	case NET_INTERNAL:
	// should have been handled before calling this function
	case NET_UNROUTABLE:
	// m_net is never and should not be set to NET_UNROUTABLE
	case NET_MAX:
	// m_net is never and should not be set to NET_MAX
	assert(false);
	} // no default case, so the compiler can warn about missing cases

	assert(false);
	}

	bool CNetAddr::SetNetFromBIP155Network(uint8_t possible_bip155_net,
	size_t address_size) {
	switch (possible_bip155_net) {
	case BIP155Network::IPV4:
	if (address_size == ADDR_IPV4_SIZE) {
	m_net = NET_IPV4;
	return true;
	}
	throw std::ios_base::failure(
	strprintf("BIP155 IPv4 address with length %u (should be %u)",
	address_size, ADDR_IPV4_SIZE));
	case BIP155Network::IPV6:
	if (address_size == ADDR_IPV6_SIZE) {
	m_net = NET_IPV6;
	return true;
	}
	throw std::ios_base::failure(
	strprintf("BIP155 IPv6 address with length %u (should be %u)",
	address_size, ADDR_IPV6_SIZE));
	case BIP155Network::TORV2:
	if (address_size == ADDR_TORV2_SIZE) {
	m_net = NET_ONION;
	return true;
	}
	throw std::ios_base::failure(
	strprintf("BIP155 TORv2 address with length %u (should be %u)",
	address_size, ADDR_TORV2_SIZE));
	case BIP155Network::TORV3:
	if (address_size == ADDR_TORV3_SIZE) {
	m_net = NET_ONION;
	return true;
	}
	throw std::ios_base::failure(
	strprintf("BIP155 TORv3 address with length %u (should be %u)",
	address_size, ADDR_TORV3_SIZE));
	case BIP155Network::I2P:
	if (address_size == ADDR_I2P_SIZE) {
	m_net = NET_I2P;
	return true;
	}
	throw std::ios_base::failure(
	strprintf("BIP155 I2P address with length %u (should be %u)",
	address_size, ADDR_I2P_SIZE));
	case BIP155Network::CJDNS:
	if (address_size == ADDR_CJDNS_SIZE) {
	m_net = NET_CJDNS;
	return true;
	}
	throw std::ios_base::failure(
	strprintf("BIP155 CJDNS address with length %u (should be %u)",
	address_size, ADDR_CJDNS_SIZE));
	}

	// Don't throw on addresses with unknown network ids (maybe from the
	// future). Instead silently drop them and have the unserialization code
	// consume subsequent ones which may be known to us.
	return false;
	}

	/**
	* Construct an unspecified IPv6 network address (::/128).
	*
	* @note This address is considered invalid by CNetAddr::IsValid()
	*/
	CNetAddr::CNetAddr() {}

	void CNetAddr::SetIP(const CNetAddr &ipIn) {
	// Size check.
	switch (ipIn.m_net) {
	case NET_IPV4:
	assert(ipIn.m_addr.size() == ADDR_IPV4_SIZE);
	break;
	case NET_IPV6:
	assert(ipIn.m_addr.size() == ADDR_IPV6_SIZE);
	break;
	case NET_ONION:
	assert(ipIn.m_addr.size() == ADDR_TORV2_SIZE \|\|
	ipIn.m_addr.size() == ADDR_TORV3_SIZE);
	break;
	case NET_I2P:
	assert(ipIn.m_addr.size() == ADDR_I2P_SIZE);
	break;
	case NET_CJDNS:
	assert(ipIn.m_addr.size() == ADDR_CJDNS_SIZE);
	break;
	case NET_INTERNAL:
	assert(ipIn.m_addr.size() == ADDR_INTERNAL_SIZE);
	break;
	case NET_UNROUTABLE:
	case NET_MAX:
	assert(false);
	} // no default case, so the compiler can warn about missing cases

	m_net = ipIn.m_net;
	m_addr = ipIn.m_addr;
	}

	void CNetAddr::SetLegacyIPv6(Span<const uint8_t> ipv6) {
	assert(ipv6.size() == ADDR_IPV6_SIZE);

	size_t skip{0};

	if (HasPrefix(ipv6, IPV4_IN_IPV6_PREFIX)) {
	// IPv4-in-IPv6
	m_net = NET_IPV4;
	skip = sizeof(IPV4_IN_IPV6_PREFIX);
	} else if (HasPrefix(ipv6, TORV2_IN_IPV6_PREFIX)) {
	// TORv2-in-IPv6
	m_net = NET_ONION;
	skip = sizeof(TORV2_IN_IPV6_PREFIX);
	} else if (HasPrefix(ipv6, INTERNAL_IN_IPV6_PREFIX)) {
	// Internal-in-IPv6
	m_net = NET_INTERNAL;
	skip = sizeof(INTERNAL_IN_IPV6_PREFIX);
	} else {
	// IPv6
	m_net = NET_IPV6;
	}

	m_addr.assign(ipv6.begin() + skip, ipv6.end());
	}

	/**
	* Create an "internal" address that represents a name or FQDN. CAddrMan uses
	* these fake addresses to keep track of which DNS seeds were used.
	* @returns Whether or not the operation was successful.
	* @see NET_INTERNAL, INTERNAL_IN_IPV6_PREFIX, CNetAddr::IsInternal(),
	* CNetAddr::IsRFC4193()
	*/
	bool CNetAddr::SetInternal(const std::string &name) {
	if (name.empty()) {
	return false;
	}
	m_net = NET_INTERNAL;
	uint8_t hash[32] = {};
	CSHA256().Write((const uint8_t *)name.data(), name.size()).Finalize(hash);
	m_addr.assign(hash, hash + ADDR_INTERNAL_SIZE);
	return true;
	}

	namespace torv3 {
	// https://gitweb.torproject.org/torspec.git/tree/rend-spec-v3.txt#n2135
	static constexpr size_t CHECKSUM_LEN = 2;
	static const uint8_t VERSION[] = {3};
	static constexpr size_t TOTAL_LEN =
	ADDR_TORV3_SIZE + CHECKSUM_LEN + sizeof(VERSION);

	static void Checksum(Span<const uint8_t> addr_pubkey,
	uint8_t (&checksum)[CHECKSUM_LEN]) {
	// TORv3 CHECKSUM = H(".onion checksum" \| PUBKEY \| VERSION)[:2]
	static const uint8_t prefix[] = ".onion checksum";
	static constexpr size_t prefix_len = 15;

	SHA3_256 hasher;

	hasher.Write(MakeSpan(prefix).first(prefix_len));
	hasher.Write(addr_pubkey);
	hasher.Write(VERSION);

	uint8_t checksum_full[SHA3_256::OUTPUT_SIZE];

	hasher.Finalize(checksum_full);

	memcpy(checksum, checksum_full, sizeof(checksum));
	}

	}; // namespace torv3

	/**
	* Parse a TOR address and set this object to it.
	*
	* @returns Whether or not the operation was successful.
	*
	* @see CNetAddr::IsTor()
	*/
	bool CNetAddr::SetSpecial(const std::string &str) {
	static const char *suffix{".onion"};
	static constexpr size_t suffix_len{6};

	if (!ValidAsCString(str) \|\| str.size() <= suffix_len \|\|
	str.substr(str.size() - suffix_len) != suffix) {
	return false;
	}

	bool invalid;
	const auto &input =
	DecodeBase32(str.substr(0, str.size() - suffix_len).c_str(), &invalid);

	if (invalid) {
	return false;
	}

	switch (input.size()) {
	case ADDR_TORV2_SIZE:
	m_net = NET_ONION;
	m_addr.assign(input.begin(), input.end());
	return true;
	case torv3::TOTAL_LEN: {
	Span<const uint8_t> input_pubkey{input.data(), ADDR_TORV3_SIZE};
	Span<const uint8_t> input_checksum{input.data() + ADDR_TORV3_SIZE,
	torv3::CHECKSUM_LEN};
	Span<const uint8_t> input_version{input.data() + ADDR_TORV3_SIZE +
	torv3::CHECKSUM_LEN,
	sizeof(torv3::VERSION)};

	uint8_t calculated_checksum[torv3::CHECKSUM_LEN];
	torv3::Checksum(input_pubkey, calculated_checksum);

	if (input_checksum != calculated_checksum \|\|
	input_version != torv3::VERSION) {
	return false;
	}

	m_net = NET_ONION;
	m_addr.assign(input_pubkey.begin(), input_pubkey.end());
	return true;
	}
	}

	return false;
	}

	CNetAddr::CNetAddr(const struct in_addr &ipv4Addr) {
	m_net = NET_IPV4;
	const uint8_t ptr = reinterpret_cast<const uint8_t >(&ipv4Addr);
	m_addr.assign(ptr, ptr + ADDR_IPV4_SIZE);
	}

	CNetAddr::CNetAddr(const struct in6_addr &ipv6Addr, const uint32_t scope) {
	SetLegacyIPv6(Span<const uint8_t>(
	reinterpret_cast<const uint8_t *>(&ipv6Addr), sizeof(ipv6Addr)));
	- scopeId = scope;
	+ m_scope_id = scope;
	}

	bool CNetAddr::IsBindAny() const {
	if (!IsIPv4() && !IsIPv6()) {
	return false;
	}
	return std::all_of(m_addr.begin(), m_addr.end(),
	[](uint8_t b) { return b == 0; });
	}

	bool CNetAddr::IsIPv4() const {
	return m_net == NET_IPV4;
	}

	bool CNetAddr::IsIPv6() const {
	return m_net == NET_IPV6;
	}

	bool CNetAddr::IsRFC1918() const {
	return IsIPv4() &&
	(m_addr[0] == 10 \|\| (m_addr[0] == 192 && m_addr[1] == 168) \|\|
	(m_addr[0] == 172 && m_addr[1] >= 16 && m_addr[1] <= 31));
	}

	bool CNetAddr::IsRFC2544() const {
	return IsIPv4() && m_addr[0] == 198 && (m_addr[1] == 18 \|\| m_addr[1] == 19);
	}

	bool CNetAddr::IsRFC3927() const {
	return IsIPv4() && HasPrefix(m_addr, std::array<uint8_t, 2>{{169, 254}});
	}

	bool CNetAddr::IsRFC6598() const {
	return IsIPv4() && m_addr[0] == 100 && m_addr[1] >= 64 && m_addr[1] <= 127;
	}

	bool CNetAddr::IsRFC5737() const {
	return IsIPv4() &&
	(HasPrefix(m_addr, std::array<uint8_t, 3>{{192, 0, 2}}) \|\|
	HasPrefix(m_addr, std::array<uint8_t, 3>{{198, 51, 100}}) \|\|
	HasPrefix(m_addr, std::array<uint8_t, 3>{{203, 0, 113}}));
	}

	bool CNetAddr::IsRFC3849() const {
	return IsIPv6() &&
	HasPrefix(m_addr, std::array<uint8_t, 4>{{0x20, 0x01, 0x0D, 0xB8}});
	}

	bool CNetAddr::IsRFC3964() const {
	return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 2>{{0x20, 0x02}});
	}

	bool CNetAddr::IsRFC6052() const {
	return IsIPv6() &&
	HasPrefix(m_addr, std::array<uint8_t, 12>{{0x00, 0x64, 0xFF, 0x9B,
	0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00}});
	}

	bool CNetAddr::IsRFC4380() const {
	return IsIPv6() &&
	HasPrefix(m_addr, std::array<uint8_t, 4>{{0x20, 0x01, 0x00, 0x00}});
	}

	bool CNetAddr::IsRFC4862() const {
	return IsIPv6() &&
	HasPrefix(m_addr, std::array<uint8_t, 8>{{0xFE, 0x80, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00}});
	}

	bool CNetAddr::IsRFC4193() const {
	return IsIPv6() && (m_addr[0] & 0xFE) == 0xFC;
	}

	bool CNetAddr::IsRFC6145() const {
	return IsIPv6() &&
	HasPrefix(m_addr, std::array<uint8_t, 12>{{0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00,
	0xFF, 0xFF, 0x00, 0x00}});
	}

	bool CNetAddr::IsRFC4843() const {
	return IsIPv6() &&
	HasPrefix(m_addr, std::array<uint8_t, 3>{{0x20, 0x01, 0x00}}) &&
	(m_addr[3] & 0xF0) == 0x10;
	}

	bool CNetAddr::IsRFC7343() const {
	return IsIPv6() &&
	HasPrefix(m_addr, std::array<uint8_t, 3>{{0x20, 0x01, 0x00}}) &&
	(m_addr[3] & 0xF0) == 0x20;
	}

	bool CNetAddr::IsHeNet() const {
	return IsIPv6() &&
	HasPrefix(m_addr, std::array<uint8_t, 4>{{0x20, 0x01, 0x04, 0x70}});
	}

	/**
	* Check whether this object represents a TOR address.
	*
	* @see CNetAddr::SetSpecial(const std::string &)
	*/
	bool CNetAddr::IsTor() const {
	return m_net == NET_ONION;
	}

	/**
	* Check whether this object represents an I2P address.
	*/
	bool CNetAddr::IsI2P() const {
	return m_net == NET_I2P;
	}

	/**
	* Check whether this object represents a CJDNS address.
	*/
	bool CNetAddr::IsCJDNS() const {
	return m_net == NET_CJDNS;
	}

	bool CNetAddr::IsLocal() const {
	// IPv4 loopback (127.0.0.0/8 or 0.0.0.0/8)
	if (IsIPv4() && (m_addr[0] == 127 \|\| m_addr[0] == 0)) {
	return true;
	}

	// IPv6 loopback (::1/128)
	static const uint8_t pchLocal[16] = {0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 1};
	if (IsIPv6() && memcmp(m_addr.data(), pchLocal, sizeof(pchLocal)) == 0) {
	return true;
	}

	return false;
	}

	/**
	* @returns Whether or not this network address is a valid address that @a could
	* be used to refer to an actual host.
	*
	* @note A valid address may or may not be publicly routable on the global
	* internet. As in, the set of valid addresses is a superset of the set of
	* publicly routable addresses.
	*
	* @see CNetAddr::IsRoutable()
	*/
	bool CNetAddr::IsValid() const {
	// unspecified IPv6 address (::/128)
	uint8_t ipNone6[16] = {};
	if (IsIPv6() && memcmp(m_addr.data(), ipNone6, sizeof(ipNone6)) == 0) {
	return false;
	}

	// documentation IPv6 address
	if (IsRFC3849()) {
	return false;
	}

	if (IsInternal()) {
	return false;
	}

	if (IsIPv4()) {
	const uint32_t addr = ReadBE32(m_addr.data());
	if (addr == INADDR_ANY \|\| addr == INADDR_NONE) {
	return false;
	}
	}

	return true;
	}

	/**
	* @returns Whether or not this network address is publicly routable on the
	* global internet.
	*
	* @note A routable address is always valid. As in, the set of routable
	* addresses is a subset of the set of valid addresses.
	*
	* @see CNetAddr::IsValid()
	*/
	bool CNetAddr::IsRoutable() const {
	return IsValid() &&
	!(IsRFC1918() \|\| IsRFC2544() \|\| IsRFC3927() \|\| IsRFC4862() \|\|
	IsRFC6598() \|\| IsRFC5737() \|\| (IsRFC4193() && !IsTor()) \|\|
	IsRFC4843() \|\| IsRFC7343() \|\| IsLocal() \|\| IsInternal());
	}

	/**
	* @returns Whether or not this is a dummy address that represents a name.
	*
	* @see CNetAddr::SetInternal(const std::string &)
	*/
	bool CNetAddr::IsInternal() const {
	return m_net == NET_INTERNAL;
	}

	bool CNetAddr::IsAddrV1Compatible() const {
	switch (m_net) {
	case NET_IPV4:
	case NET_IPV6:
	case NET_INTERNAL:
	return true;
	case NET_ONION:
	return m_addr.size() == ADDR_TORV2_SIZE;
	case NET_I2P:
	case NET_CJDNS:
	return false;
	case NET_UNROUTABLE:
	// m_net is never and should not be set to NET_UNROUTABLE
	case NET_MAX:
	// m_net is never and should not be set to NET_MAX
	assert(false);
	} // no default case, so the compiler can warn about missing cases

	assert(false);
	}

	enum Network CNetAddr::GetNetwork() const {
	if (IsInternal()) {
	return NET_INTERNAL;
	}

	if (!IsRoutable()) {
	return NET_UNROUTABLE;
	}

	return m_net;
	}

	static std::string IPv6ToString(Span<const uint8_t> a) {
	assert(a.size() == ADDR_IPV6_SIZE);
	// clang-format off
	return strprintf("%x:%x:%x:%x:%x:%x:%x:%x",
	ReadBE16(&a[0]),
	ReadBE16(&a[2]),
	ReadBE16(&a[4]),
	ReadBE16(&a[6]),
	ReadBE16(&a[8]),
	ReadBE16(&a[10]),
	ReadBE16(&a[12]),
	ReadBE16(&a[14]));
	// clang-format on
	}

	std::string CNetAddr::ToStringIP() const {
	switch (m_net) {
	case NET_IPV4:
	case NET_IPV6: {
	CService serv(*this, 0);
	struct sockaddr_storage sockaddr;
	socklen_t socklen = sizeof(sockaddr);
	if (serv.GetSockAddr((struct sockaddr *)&sockaddr, &socklen)) {
	char name[1025] = "";
	if (!getnameinfo((const struct sockaddr *)&sockaddr, socklen,
	name, sizeof(name), nullptr, 0,
	NI_NUMERICHOST)) {
	return std::string(name);
	}
	}
	if (m_net == NET_IPV4) {
	return strprintf("%u.%u.%u.%u", m_addr[0], m_addr[1], m_addr[2],
	m_addr[3]);
	}
	return IPv6ToString(m_addr);
	}
	case NET_ONION:
	switch (m_addr.size()) {
	case ADDR_TORV2_SIZE:
	return EncodeBase32(m_addr) + ".onion";
	case ADDR_TORV3_SIZE: {
	uint8_t checksum[torv3::CHECKSUM_LEN];
	torv3::Checksum(m_addr, checksum);

	// TORv3 onion_address = base32(PUBKEY \| CHECKSUM \| VERSION)
	// + ".onion"
	prevector<torv3::TOTAL_LEN, uint8_t> address{m_addr.begin(),
	m_addr.end()};
	address.insert(address.end(), checksum,
	checksum + torv3::CHECKSUM_LEN);
	address.insert(address.end(), torv3::VERSION,
	torv3::VERSION + sizeof(torv3::VERSION));

	return EncodeBase32(address) + ".onion";
	}
	default:
	assert(false);
	}
	case NET_I2P:
	return EncodeBase32(m_addr, false /* don't pad with = */) +
	".b32.i2p";
	case NET_CJDNS:
	return IPv6ToString(m_addr);
	case NET_INTERNAL:
	return EncodeBase32(m_addr) + ".internal";
	case NET_UNROUTABLE:
	// m_net is never and should not be set to NET_UNROUTABLE
	case NET_MAX:
	// m_net is never and should not be set to NET_MAX
	assert(false);
	} // no default case, so the compiler can warn about missing cases

	assert(false);
	}

	std::string CNetAddr::ToString() const {
	return ToStringIP();
	}

	bool operator==(const CNetAddr &a, const CNetAddr &b) {
	return a.m_net == b.m_net && a.m_addr == b.m_addr;
	}

	bool operator<(const CNetAddr &a, const CNetAddr &b) {
	return std::tie(a.m_net, a.m_addr) < std::tie(b.m_net, b.m_addr);
	}

	/**
	* Try to get our IPv4 address.
	*
	* @param[out] pipv4Addr The in_addr struct to which to copy.
	*
	* @returns Whether or not the operation was successful, in particular, whether
	* or not our address was an IPv4 address.
	*
	* @see CNetAddr::IsIPv4()
	*/
	bool CNetAddr::GetInAddr(struct in_addr *pipv4Addr) const {
	if (!IsIPv4()) {
	return false;
	}
	assert(sizeof(*pipv4Addr) == m_addr.size());
	memcpy(pipv4Addr, m_addr.data(), m_addr.size());
	return true;
	}

	/**
	* Try to get our IPv6 address.
	*
	* @param[out] pipv6Addr The in6_addr struct to which to copy.
	*
	* @returns Whether or not the operation was successful, in particular, whether
	* or not our address was an IPv6 address.
	*
	* @see CNetAddr::IsIPv6()
	*/
	bool CNetAddr::GetIn6Addr(struct in6_addr *pipv6Addr) const {
	if (!IsIPv6()) {
	return false;
	}
	assert(sizeof(*pipv6Addr) == m_addr.size());
	memcpy(pipv6Addr, m_addr.data(), m_addr.size());
	return true;
	}

	bool CNetAddr::HasLinkedIPv4() const {
	return IsRoutable() && (IsIPv4() \|\| IsRFC6145() \|\| IsRFC6052() \|\|
	IsRFC3964() \|\| IsRFC4380());
	}

	uint32_t CNetAddr::GetLinkedIPv4() const {
	if (IsIPv4()) {
	return ReadBE32(m_addr.data());
	} else if (IsRFC6052() \|\| IsRFC6145()) {
	// mapped IPv4, SIIT translated IPv4: the IPv4 address is the last 4
	// bytes of the address
	return ReadBE32(MakeSpan(m_addr).last(ADDR_IPV4_SIZE).data());
	} else if (IsRFC3964()) {
	// 6to4 tunneled IPv4: the IPv4 address is in bytes 2-6
	return ReadBE32(MakeSpan(m_addr).subspan(2, ADDR_IPV4_SIZE).data());
	} else if (IsRFC4380()) {
	// Teredo tunneled IPv4: the IPv4 address is in the last 4 bytes of the
	// address, but bitflipped
	return ~ReadBE32(MakeSpan(m_addr).last(ADDR_IPV4_SIZE).data());
	}
	assert(false);
	}

	uint32_t CNetAddr::GetNetClass() const {
	// Make sure that if we return NET_IPV6, then IsIPv6() is true. The callers
	// expect that.

	// Check for "internal" first because such addresses are also !IsRoutable()
	// and we don't want to return NET_UNROUTABLE in that case.
	if (IsInternal()) {
	return NET_INTERNAL;
	}
	if (!IsRoutable()) {
	return NET_UNROUTABLE;
	}
	if (HasLinkedIPv4()) {
	return NET_IPV4;
	}
	return m_net;
	}

	uint32_t CNetAddr::GetMappedAS(const std::vector<bool> &asmap) const {
	uint32_t net_class = GetNetClass();
	if (asmap.size() == 0 \|\| (net_class != NET_IPV4 && net_class != NET_IPV6)) {
	return 0; // Indicates not found, safe because AS0 is reserved per
	// RFC7607.
	}
	std::vector<bool> ip_bits(128);
	if (HasLinkedIPv4()) {
	// For lookup, treat as if it was just an IPv4 address
	// (IPV4_IN_IPV6_PREFIX + IPv4 bits)
	for (int8_t byte_i = 0; byte_i < 12; ++byte_i) {
	for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
	ip_bits[byte_i * 8 + bit_i] =
	(IPV4_IN_IPV6_PREFIX[byte_i] >> (7 - bit_i)) & 1;
	}
	}
	uint32_t ipv4 = GetLinkedIPv4();
	for (int i = 0; i < 32; ++i) {
	ip_bits[96 + i] = (ipv4 >> (31 - i)) & 1;
	}
	} else {
	// Use all 128 bits of the IPv6 address otherwise
	assert(IsIPv6());
	for (int8_t byte_i = 0; byte_i < 16; ++byte_i) {
	uint8_t cur_byte = m_addr[byte_i];
	for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
	ip_bits[byte_i * 8 + bit_i] = (cur_byte >> (7 - bit_i)) & 1;
	}
	}
	}
	uint32_t mapped_as = Interpret(asmap, ip_bits);
	return mapped_as;
	}

	/**
	* Get the canonical identifier of our network group
	*
	* The groups are assigned in a way where it should be costly for an attacker to
	* obtain addresses with many different group identifiers, even if it is cheap
	* to obtain addresses with the same identifier.
	*
	* @note No two connections will be attempted to addresses with the same network
	* group.
	*/
	std::vector<uint8_t> CNetAddr::GetGroup(const std::vector<bool> &asmap) const {
	std::vector<uint8_t> vchRet;
	uint32_t net_class = GetNetClass();
	// If non-empty asmap is supplied and the address is IPv4/IPv6,
	// return ASN to be used for bucketing.
	uint32_t asn = GetMappedAS(asmap);
	if (asn != 0) { // Either asmap was empty, or address has non-asmappable net
	// class (e.g. TOR).
	vchRet.push_back(NET_IPV6); // IPv4 and IPv6 with same ASN should be in
	// the same bucket
	for (int i = 0; i < 4; i++) {
	vchRet.push_back((asn >> (8 * i)) & 0xFF);
	}
	return vchRet;
	}

	vchRet.push_back(net_class);
	int nBits{0};

	if (IsLocal()) {
	// all local addresses belong to the same group
	} else if (IsInternal()) {
	// all internal-usage addresses get their own group
	nBits = ADDR_INTERNAL_SIZE * 8;
	} else if (!IsRoutable()) {
	// all other unroutable addresses belong to the same group
	} else if (HasLinkedIPv4()) {
	// IPv4 addresses (and mapped IPv4 addresses) use /16 groups
	uint32_t ipv4 = GetLinkedIPv4();
	vchRet.push_back((ipv4 >> 24) & 0xFF);
	vchRet.push_back((ipv4 >> 16) & 0xFF);
	return vchRet;
	} else if (IsTor() \|\| IsI2P() \|\| IsCJDNS()) {
	nBits = 4;
	} else if (IsHeNet()) {
	// for he.net, use /36 groups
	nBits = 36;
	} else {
	// for the rest of the IPv6 network, use /32 groups
	nBits = 32;
	}

	// Push our address onto vchRet.
	const size_t num_bytes = nBits / 8;
	vchRet.insert(vchRet.end(), m_addr.begin(), m_addr.begin() + num_bytes);
	nBits %= 8;
	// ...for the last byte, push nBits and for the rest of the byte push 1's
	if (nBits > 0) {
	assert(num_bytes < m_addr.size());
	vchRet.push_back(m_addr[num_bytes] \| ((1 << (8 - nBits)) - 1));
	}

	return vchRet;
	}

	std::vector<uint8_t> CNetAddr::GetAddrBytes() const {
	if (IsAddrV1Compatible()) {
	uint8_t serialized[V1_SERIALIZATION_SIZE];
	SerializeV1Array(serialized);
	return {std::begin(serialized), std::end(serialized)};
	}
	return std::vector<uint8_t>(m_addr.begin(), m_addr.end());
	}

	uint64_t CNetAddr::GetHash() const {
	uint256 hash = Hash(m_addr);
	uint64_t nRet;
	memcpy(&nRet, &hash, sizeof(nRet));
	return nRet;
	}

	// private extensions to enum Network, only returned by GetExtNetwork, and only
	// used in GetReachabilityFrom
	static const int NET_UNKNOWN = NET_MAX + 0;
	static const int NET_TEREDO = NET_MAX + 1;
	static int GetExtNetwork(const CNetAddr *addr) {
	if (addr == nullptr) {
	return NET_UNKNOWN;
	}
	if (addr->IsRFC4380()) {
	return NET_TEREDO;
	}
	return addr->GetNetwork();
	}

	/** Calculates a metric for how reachable (this) is from a given partner /
	int CNetAddr::GetReachabilityFrom(const CNetAddr *paddrPartner) const {
	enum Reachability {
	REACH_UNREACHABLE,
	REACH_DEFAULT,
	REACH_TEREDO,
	REACH_IPV6_WEAK,
	REACH_IPV4,
	REACH_IPV6_STRONG,
	REACH_PRIVATE
	};

	if (!IsRoutable() \|\| IsInternal()) {
	return REACH_UNREACHABLE;
	}

	int ourNet = GetExtNetwork(this);
	int theirNet = GetExtNetwork(paddrPartner);
	bool fTunnel = IsRFC3964() \|\| IsRFC6052() \|\| IsRFC6145();

	switch (theirNet) {
	case NET_IPV4:
	switch (ourNet) {
	default:
	return REACH_DEFAULT;
	case NET_IPV4:
	return REACH_IPV4;
	}
	case NET_IPV6:
	switch (ourNet) {
	default:
	return REACH_DEFAULT;
	case NET_TEREDO:
	return REACH_TEREDO;
	case NET_IPV4:
	return REACH_IPV4;
	// only prefer giving our IPv6 address if it's not tunnelled
	case NET_IPV6:
	return fTunnel ? REACH_IPV6_WEAK : REACH_IPV6_STRONG;
	}
	case NET_ONION:
	switch (ourNet) {
	default:
	return REACH_DEFAULT;
	// Tor users can connect to IPv4 as well
	case NET_IPV4:
	return REACH_IPV4;
	case NET_ONION:
	return REACH_PRIVATE;
	}
	case NET_TEREDO:
	switch (ourNet) {
	default:
	return REACH_DEFAULT;
	case NET_TEREDO:
	return REACH_TEREDO;
	case NET_IPV6:
	return REACH_IPV6_WEAK;
	case NET_IPV4:
	return REACH_IPV4;
	}
	case NET_UNKNOWN:
	case NET_UNROUTABLE:
	default:
	switch (ourNet) {
	default:
	return REACH_DEFAULT;
	case NET_TEREDO:
	return REACH_TEREDO;
	case NET_IPV6:
	return REACH_IPV6_WEAK;
	case NET_IPV4:
	return REACH_IPV4;
	// either from Tor, or don't care about our address
	case NET_ONION:
	return REACH_PRIVATE;
	}
	}
	}

	CService::CService() : port(0) {}

	CService::CService(const CNetAddr &cip, uint16_t portIn)
	: CNetAddr(cip), port(portIn) {}

	CService::CService(const struct in_addr &ipv4Addr, uint16_t portIn)
	: CNetAddr(ipv4Addr), port(portIn) {}

	CService::CService(const struct in6_addr &ipv6Addr, uint16_t portIn)
	: CNetAddr(ipv6Addr), port(portIn) {}

	CService::CService(const struct sockaddr_in &addr)
	: CNetAddr(addr.sin_addr), port(ntohs(addr.sin_port)) {
	assert(addr.sin_family == AF_INET);
	}

	CService::CService(const struct sockaddr_in6 &addr)
	: CNetAddr(addr.sin6_addr, addr.sin6_scope_id),
	port(ntohs(addr.sin6_port)) {
	assert(addr.sin6_family == AF_INET6);
	}

	bool CService::SetSockAddr(const struct sockaddr *paddr) {
	switch (paddr->sa_family) {
	case AF_INET:
	*this =
	CService(reinterpret_cast<const struct sockaddr_in >(paddr));
	return true;
	case AF_INET6:
	*this =
	CService(reinterpret_cast<const struct sockaddr_in6 >(paddr));
	return true;
	default:
	return false;
	}
	}

	uint16_t CService::GetPort() const {
	return port;
	}

	bool operator==(const CService &a, const CService &b) {
	return static_cast<CNetAddr>(a) == static_cast<CNetAddr>(b) &&
	a.port == b.port;
	}

	bool operator<(const CService &a, const CService &b) {
	return static_cast<CNetAddr>(a) < static_cast<CNetAddr>(b) \|\|
	(static_cast<CNetAddr>(a) == static_cast<CNetAddr>(b) &&
	a.port < b.port);
	}

	/**
	* Obtain the IPv4/6 socket address this represents.
	*
	* @param[out] paddr The obtained socket address.
	* @param[in,out] addrlen The size, in bytes, of the address structure pointed
	* to by paddr. The value that's pointed to by this
	* parameter might change after calling this function if
	* the size of the corresponding address structure
	* changed.
	*
	* @returns Whether or not the operation was successful.
	*/
	bool CService::GetSockAddr(struct sockaddr paddr, socklen_t addrlen) const {
	if (IsIPv4()) {
	if (*addrlen < (socklen_t)sizeof(struct sockaddr_in)) {
	return false;
	}
	*addrlen = sizeof(struct sockaddr_in);
	struct sockaddr_in *paddrin =
	reinterpret_cast<struct sockaddr_in *>(paddr);
	memset(paddrin, 0, *addrlen);
	if (!GetInAddr(&paddrin->sin_addr)) {
	return false;
	}
	paddrin->sin_family = AF_INET;
	paddrin->sin_port = htons(port);
	return true;
	}
	if (IsIPv6()) {
	if (*addrlen < (socklen_t)sizeof(struct sockaddr_in6)) {
	return false;
	}
	*addrlen = sizeof(struct sockaddr_in6);
	struct sockaddr_in6 *paddrin6 =
	reinterpret_cast<struct sockaddr_in6 *>(paddr);
	memset(paddrin6, 0, *addrlen);
	if (!GetIn6Addr(&paddrin6->sin6_addr)) {
	return false;
	}
	- paddrin6->sin6_scope_id = scopeId;
	+ paddrin6->sin6_scope_id = m_scope_id;
	paddrin6->sin6_family = AF_INET6;
	paddrin6->sin6_port = htons(port);
	return true;
	}
	return false;
	}

	/**
	* @returns An identifier unique to this service's address and port number.
	*/
	std::vector<uint8_t> CService::GetKey() const {
	auto key = GetAddrBytes();
	// most significant byte of our port
	key.push_back(port / 0x100);
	// least significant byte of our port
	key.push_back(port & 0x0FF);
	return key;
	}

	std::string CService::ToStringPort() const {
	return strprintf("%u", port);
	}

	std::string CService::ToStringIPPort() const {
	if (IsIPv4() \|\| IsTor() \|\| IsI2P() \|\| IsInternal()) {
	return ToStringIP() + ":" + ToStringPort();
	} else {
	return "[" + ToStringIP() + "]:" + ToStringPort();
	}
	}

	std::string CService::ToString() const {
	return ToStringIPPort();
	}

	CSubNet::CSubNet() : valid(false) {
	memset(netmask, 0, sizeof(netmask));
	}

	CSubNet::CSubNet(const CNetAddr &addr, uint8_t mask) : CSubNet() {
	valid = (addr.IsIPv4() && mask <= ADDR_IPV4_SIZE * 8) \|\|
	(addr.IsIPv6() && mask <= ADDR_IPV6_SIZE * 8);
	if (!valid) {
	return;
	}

	assert(mask <= sizeof(netmask) * 8);

	network = addr;

	uint8_t n = mask;
	for (size_t i = 0; i < network.m_addr.size(); ++i) {
	const uint8_t bits = n < 8 ? n : 8;
	// Set first bits.
	netmask[i] = (uint8_t)((uint8_t)0xFF << (8 - bits));
	// Normalize network according to netmask.
	network.m_addr[i] &= netmask[i];
	n -= bits;
	}
	}

	/**
	* @returns The number of 1-bits in the prefix of the specified subnet mask. If
	* the specified subnet mask is not a valid one, -1.
	*/
	static inline int NetmaskBits(uint8_t x) {
	switch (x) {
	case 0x00:
	return 0;
	case 0x80:
	return 1;
	case 0xc0:
	return 2;
	case 0xe0:
	return 3;
	case 0xf0:
	return 4;
	case 0xf8:
	return 5;
	case 0xfc:
	return 6;
	case 0xfe:
	return 7;
	case 0xff:
	return 8;
	default:
	return -1;
	}
	}

	CSubNet::CSubNet(const CNetAddr &addr, const CNetAddr &mask) : CSubNet() {
	valid = (addr.IsIPv4() \|\| addr.IsIPv6()) && addr.m_net == mask.m_net;
	if (!valid) {
	return;
	}
	// Check if `mask` contains 1-bits after 0-bits (which is an invalid
	// netmask).
	bool zeros_found = false;
	for (auto b : mask.m_addr) {
	const int num_bits = NetmaskBits(b);
	if (num_bits == -1 \|\| (zeros_found && num_bits != 0)) {
	valid = false;
	return;
	}
	if (num_bits < 8) {
	zeros_found = true;
	}
	}

	assert(mask.m_addr.size() <= sizeof(netmask));

	memcpy(netmask, mask.m_addr.data(), mask.m_addr.size());

	network = addr;

	// Normalize network according to netmask
	for (size_t x = 0; x < network.m_addr.size(); ++x) {
	network.m_addr[x] &= netmask[x];
	}
	}

	CSubNet::CSubNet(const CNetAddr &addr) : CSubNet() {
	valid = addr.IsIPv4() \|\| addr.IsIPv6();
	if (!valid) {
	return;
	}

	assert(addr.m_addr.size() <= sizeof(netmask));

	memset(netmask, 0xFF, addr.m_addr.size());

	network = addr;
	}

	/**
	* @returns True if this subnet is valid, the specified address is valid, and
	* the specified address belongs in this subnet.
	*/
	bool CSubNet::Match(const CNetAddr &addr) const {
	if (!valid \|\| !addr.IsValid() \|\| network.m_net != addr.m_net) {
	return false;
	}
	assert(network.m_addr.size() == addr.m_addr.size());
	for (size_t x = 0; x < addr.m_addr.size(); ++x) {
	if ((addr.m_addr[x] & netmask[x]) != network.m_addr[x]) {
	return false;
	}
	}
	return true;
	}

	std::string CSubNet::ToString() const {
	assert(network.m_addr.size() <= sizeof(netmask));

	uint8_t cidr = 0;

	for (size_t i = 0; i < network.m_addr.size(); ++i) {
	if (netmask[i] == 0x00) {
	break;
	}
	cidr += NetmaskBits(netmask[i]);
	}

	return network.ToString() + strprintf("/%u", cidr);
	}

	bool CSubNet::IsValid() const {
	return valid;
	}

	bool CSubNet::SanityCheck() const {
	if (!(network.IsIPv4() \|\| network.IsIPv6())) {
	return false;
	}

	for (size_t x = 0; x < network.m_addr.size(); ++x) {
	if (network.m_addr[x] & ~netmask[x]) {
	return false;
	}
	}

	return true;
	}

	bool operator==(const CSubNet &a, const CSubNet &b) {
	return a.valid == b.valid && a.network == b.network &&
	!memcmp(a.netmask, b.netmask, 16);
	}

	bool operator<(const CSubNet &a, const CSubNet &b) {
	return (a.network < b.network \|\|
	(a.network == b.network && memcmp(a.netmask, b.netmask, 16) < 0));
	}

	bool SanityCheckASMap(const std::vector<bool> &asmap) {
	// For IP address lookups, the input is 128 bits
	return SanityCheckASMap(asmap, 128);
	}
	diff --git a/src/netaddress.h b/src/netaddress.h
	index 5ae5eb117..2af717f04 100644
	--- a/src/netaddress.h
	+++ b/src/netaddress.h
	@@ -1,539 +1,542 @@
	// Copyright (c) 2009-2016 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#ifndef BITCOIN_NETADDRESS_H
	#define BITCOIN_NETADDRESS_H

	#if defined(HAVE_CONFIG_H)
	#include <config/bitcoin-config.h>
	#endif

	#include <attributes.h>
	#include <compat.h>
	#include <prevector.h>
	#include <serialize.h>
	#include <util/strencodings.h>
	#include <util/string.h>

	#include <tinyformat.h>

	#include <array>
	#include <cstdint>
	#include <ios>
	#include <string>
	#include <vector>

	/**
	* A flag that is ORed into the protocol version to designate that addresses
	* should be serialized in (unserialized from) v2 format (BIP155).
	* Make sure that this does not collide with any of the values in `version.h`.
	*/
	static const int ADDRV2_FORMAT = 0x20000000;

	/**
	* A network type.
	* @note An address may belong to more than one network, for example `10.0.0.1`
	* belongs to both `NET_UNROUTABLE` and `NET_IPV4`.
	* Keep these sequential starting from 0 and `NET_MAX` as the last entry.
	* We have loops like `for (int i = 0; i < NET_MAX; i++)` that expect to iterate
	* over all enum values and also `GetExtNetwork()` "extends" this enum by
	* introducing standalone constants starting from `NET_MAX`.
	*/
	enum Network {
	/// Addresses from these networks are not publicly routable on the global
	/// Internet.
	NET_UNROUTABLE = 0,

	/// IPv4
	NET_IPV4,

	/// IPv6
	NET_IPV6,

	/// TOR (v2 or v3)
	NET_ONION,

	/// I2P
	NET_I2P,

	/// CJDNS
	NET_CJDNS,

	/// A set of addresses that represent the hash of a string or FQDN. We use
	/// them in CAddrMan to keep track of which DNS seeds were used.
	NET_INTERNAL,

	/// Dummy value to indicate the number of NET_* constants.
	NET_MAX,
	};

	/// Prefix of an IPv6 address when it contains an embedded IPv4 address.
	/// Used when (un)serializing addresses in ADDRv1 format (pre-BIP155).
	static const std::array<uint8_t, 12> IPV4_IN_IPV6_PREFIX{
	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF}};

	/// Prefix of an IPv6 address when it contains an embedded TORv2 address.
	/// Used when (un)serializing addresses in ADDRv1 format (pre-BIP155).
	/// Such dummy IPv6 addresses are guaranteed to not be publicly routable as they
	/// fall under RFC4193's fc00::/7 subnet allocated to unique-local addresses.
	static const std::array<uint8_t, 6> TORV2_IN_IPV6_PREFIX{
	{0xFD, 0x87, 0xD8, 0x7E, 0xEB, 0x43}};

	/// Prefix of an IPv6 address when it contains an embedded "internal" address.
	/// Used when (un)serializing addresses in ADDRv1 format (pre-BIP155).
	/// The prefix comes from 0xFD + SHA256("bitcoin")[0:5].
	/// Such dummy IPv6 addresses are guaranteed to not be publicly routable as they
	/// fall under RFC4193's fc00::/7 subnet allocated to unique-local addresses.
	static const std::array<uint8_t, 6> INTERNAL_IN_IPV6_PREFIX{
	// 0xFD + sha256("bitcoin")[0:5].
	{0xFD, 0x6B, 0x88, 0xC0, 0x87, 0x24}};

	/// Size of IPv4 address (in bytes).
	static constexpr size_t ADDR_IPV4_SIZE = 4;

	/// Size of IPv6 address (in bytes).
	static constexpr size_t ADDR_IPV6_SIZE = 16;

	/// Size of TORv2 address (in bytes).
	static constexpr size_t ADDR_TORV2_SIZE = 10;

	/// Size of TORv3 address (in bytes). This is the length of just the address
	/// as used in BIP155, without the checksum and the version byte.
	static constexpr size_t ADDR_TORV3_SIZE = 32;

	/// Size of I2P address (in bytes).
	static constexpr size_t ADDR_I2P_SIZE = 32;

	/// Size of CJDNS address (in bytes).
	static constexpr size_t ADDR_CJDNS_SIZE = 16;

	/// Size of "internal" (NET_INTERNAL) address (in bytes).
	static constexpr size_t ADDR_INTERNAL_SIZE = 10;

	/**
	* Network address.
	*/
	class CNetAddr {
	protected:
	/**
	* Raw representation of the network address.
	* In network byte order (big endian) for IPv4 and IPv6.
	*/
	prevector<ADDR_IPV6_SIZE, uint8_t> m_addr{ADDR_IPV6_SIZE, 0x0};

	/**
	* Network to which this address belongs.
	*/
	Network m_net{NET_IPV6};

	- // for scoped/link-local ipv6 addresses
	- uint32_t scopeId{0};
	+ /**
	+ * Scope id if scoped/link-local IPV6 address.
	+ * See https://tools.ietf.org/html/rfc4007
	+ */
	+ uint32_t m_scope_id{0};

	public:
	CNetAddr();
	explicit CNetAddr(const struct in_addr &ipv4Addr);
	void SetIP(const CNetAddr &ip);

	/**
	* Set from a legacy IPv6 address.
	* Legacy IPv6 address may be a normal IPv6 address, or another address
	* (e.g. IPv4) disguised as IPv6. This encoding is used in the legacy
	* `addr` encoding.
	*/
	void SetLegacyIPv6(Span<const uint8_t> ipv6);

	bool SetInternal(const std::string &name);

	// for Tor addresses
	bool SetSpecial(const std::string &strName);
	// INADDR_ANY equivalent
	bool IsBindAny() const;
	// IPv4 mapped address (::FFFF:0:0/96, 0.0.0.0/0)
	bool IsIPv4() const;
	// IPv6 address (not mapped IPv4, not Tor)
	bool IsIPv6() const;
	// IPv4 private networks (10.0.0.0/8, 192.168.0.0/16, 172.16.0.0/12)
	bool IsRFC1918() const;
	// IPv4 inter-network communications (198.18.0.0/15)
	bool IsRFC2544() const;
	// IPv4 ISP-level NAT (100.64.0.0/10)
	bool IsRFC6598() const;
	// IPv4 documentation addresses (192.0.2.0/24, 198.51.100.0/24,
	// 203.0.113.0/24)
	bool IsRFC5737() const;
	// IPv6 documentation address (2001:0DB8::/32)
	bool IsRFC3849() const;
	// IPv4 autoconfig (169.254.0.0/16)
	bool IsRFC3927() const;
	// IPv6 6to4 tunnelling (2002::/16)
	bool IsRFC3964() const;
	// IPv6 unique local (FC00::/7)
	bool IsRFC4193() const;
	// IPv6 Teredo tunnelling (2001::/32)
	bool IsRFC4380() const;
	// IPv6 ORCHID (deprecated) (2001:10::/28)
	bool IsRFC4843() const;
	// IPv6 ORCHIDv2 (2001:20::/28)
	bool IsRFC7343() const;
	// IPv6 autoconfig (FE80::/64)
	bool IsRFC4862() const;
	// IPv6 well-known prefix for IPv4-embedded address (64:FF9B::/96)
	bool IsRFC6052() const;
	// IPv6 IPv4-translated address (::FFFF:0:0:0/96) (actually defined in
	// RFC2765)
	bool IsRFC6145() const;
	// IPv6 Hurricane Electric - https://he.net (2001:0470::/36)
	bool IsHeNet() const;
	bool IsTor() const;
	bool IsI2P() const;
	bool IsCJDNS() const;
	bool IsLocal() const;
	bool IsRoutable() const;
	bool IsInternal() const;
	bool IsValid() const;

	/**
	* Check if the current object can be serialized in pre-ADDRv2/BIP155
	* format.
	*/
	bool IsAddrV1Compatible() const;

	enum Network GetNetwork() const;
	std::string ToString() const;
	std::string ToStringIP() const;
	uint64_t GetHash() const;
	bool GetInAddr(struct in_addr *pipv4Addr) const;
	uint32_t GetNetClass() const;

	//! For IPv4, mapped IPv4, SIIT translated IPv4, Teredo, 6to4 tunneled
	//! addresses, return the relevant IPv4 address as a uint32.
	uint32_t GetLinkedIPv4() const;
	//! Whether this address has a linked IPv4 address (see GetLinkedIPv4()).
	bool HasLinkedIPv4() const;

	// The AS on the BGP path to the node we use to diversify
	// peers in AddrMan bucketing based on the AS infrastructure.
	// The ip->AS mapping depends on how asmap is constructed.
	uint32_t GetMappedAS(const std::vector<bool> &asmap) const;

	std::vector<uint8_t> GetGroup(const std::vector<bool> &asmap) const;
	std::vector<uint8_t> GetAddrBytes() const;
	int GetReachabilityFrom(const CNetAddr *paddrPartner = nullptr) const;

	explicit CNetAddr(const struct in6_addr &pipv6Addr,
	const uint32_t scope = 0);
	bool GetIn6Addr(struct in6_addr *pipv6Addr) const;

	friend bool operator==(const CNetAddr &a, const CNetAddr &b);
	friend bool operator!=(const CNetAddr &a, const CNetAddr &b) {
	return !(a == b);
	}
	friend bool operator<(const CNetAddr &a, const CNetAddr &b);

	/**
	* Serialize to a stream.
	*/
	template <typename Stream> void Serialize(Stream &s) const {
	if (s.GetVersion() & ADDRV2_FORMAT) {
	SerializeV2Stream(s);
	} else {
	SerializeV1Stream(s);
	}
	}

	/**
	* Unserialize from a stream.
	*/
	template <typename Stream> void Unserialize(Stream &s) {
	if (s.GetVersion() & ADDRV2_FORMAT) {
	UnserializeV2Stream(s);
	} else {
	UnserializeV1Stream(s);
	}
	}

	friend class CSubNet;

	private:
	/**
	* BIP155 network ids recognized by this software.
	*/
	enum BIP155Network : uint8_t {
	IPV4 = 1,
	IPV6 = 2,
	TORV2 = 3,
	TORV3 = 4,
	I2P = 5,
	CJDNS = 6,
	};

	/**
	* Size of CNetAddr when serialized as ADDRv1 (pre-BIP155) (in bytes).
	*/
	static constexpr size_t V1_SERIALIZATION_SIZE = ADDR_IPV6_SIZE;

	/**
	* Maximum size of an address as defined in BIP155 (in bytes).
	* This is only the size of the address, not the entire CNetAddr object
	* when serialized.
	*/
	static constexpr size_t MAX_ADDRV2_SIZE = 512;

	/**
	* Get the BIP155 network id of this address.
	* Must not be called for IsInternal() objects.
	* @returns BIP155 network id
	*/
	BIP155Network GetBIP155Network() const;

	/**
	* Set `m_net` from the provided BIP155 network id and size after
	* validation.
	* @retval true the network was recognized, is valid and `m_net` was set
	* @retval false not recognised (from future?) and should be silently
	* ignored
	* @throws std::ios_base::failure if the network is one of the BIP155
	* founding networks recognized by this software (id 1..6) with wrong
	* address size.
	*/
	bool SetNetFromBIP155Network(uint8_t possible_bip155_net,
	size_t address_size);

	/**
	* Serialize in pre-ADDRv2/BIP155 format to an array.
	*/
	void SerializeV1Array(uint8_t (&arr)[V1_SERIALIZATION_SIZE]) const {
	size_t prefix_size;

	switch (m_net) {
	case NET_IPV6:
	assert(m_addr.size() == sizeof(arr));
	memcpy(arr, m_addr.data(), m_addr.size());
	return;
	case NET_IPV4:
	prefix_size = sizeof(IPV4_IN_IPV6_PREFIX);
	assert(prefix_size + m_addr.size() == sizeof(arr));
	memcpy(arr, IPV4_IN_IPV6_PREFIX.data(), prefix_size);
	memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
	return;
	case NET_ONION:
	if (m_addr.size() == ADDR_TORV3_SIZE) {
	break;
	}
	prefix_size = sizeof(TORV2_IN_IPV6_PREFIX);
	assert(prefix_size + m_addr.size() == sizeof(arr));
	memcpy(arr, TORV2_IN_IPV6_PREFIX.data(), prefix_size);
	memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
	return;
	case NET_INTERNAL:
	prefix_size = sizeof(INTERNAL_IN_IPV6_PREFIX);
	assert(prefix_size + m_addr.size() == sizeof(arr));
	memcpy(arr, INTERNAL_IN_IPV6_PREFIX.data(), prefix_size);
	memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
	return;
	case NET_I2P:
	break;
	case NET_CJDNS:
	break;
	case NET_UNROUTABLE:
	case NET_MAX:
	assert(false);
	} // no default case, so the compiler can warn about missing cases

	// Serialize TORv3, I2P and CJDNS as all-zeros.
	memset(arr, 0x0, V1_SERIALIZATION_SIZE);
	}

	/**
	* Serialize in pre-ADDRv2/BIP155 format to a stream.
	*/
	template <typename Stream> void SerializeV1Stream(Stream &s) const {
	uint8_t serialized[V1_SERIALIZATION_SIZE];

	SerializeV1Array(serialized);

	s << serialized;
	}

	/**
	* Serialize as ADDRv2 / BIP155.
	*/
	template <typename Stream> void SerializeV2Stream(Stream &s) const {
	if (IsInternal()) {
	// Serialize NET_INTERNAL as embedded in IPv6. We need to
	// serialize such addresses from addrman.
	s << static_cast<uint8_t>(BIP155Network::IPV6);
	s << COMPACTSIZE(ADDR_IPV6_SIZE);
	SerializeV1Stream(s);
	return;
	}

	s << static_cast<uint8_t>(GetBIP155Network());
	s << m_addr;
	}

	/**
	* Unserialize from a pre-ADDRv2/BIP155 format from an array.
	*/
	void UnserializeV1Array(uint8_t (&arr)[V1_SERIALIZATION_SIZE]) {
	// Use SetLegacyIPv6() so that m_net is set correctly. For example
	// ::FFFF:0102:0304 should be set as m_net=NET_IPV4 (1.2.3.4).
	SetLegacyIPv6(arr);
	}

	/**
	* Unserialize from a pre-ADDRv2/BIP155 format from a stream.
	*/
	template <typename Stream> void UnserializeV1Stream(Stream &s) {
	uint8_t serialized[V1_SERIALIZATION_SIZE];

	s >> serialized;

	UnserializeV1Array(serialized);
	}

	/**
	* Unserialize from a ADDRv2 / BIP155 format.
	*/
	template <typename Stream> void UnserializeV2Stream(Stream &s) {
	uint8_t bip155_net;
	s >> bip155_net;

	size_t address_size;
	s >> COMPACTSIZE(address_size);

	if (address_size > MAX_ADDRV2_SIZE) {
	throw std::ios_base::failure(strprintf(
	"Address too long: %u > %u", address_size, MAX_ADDRV2_SIZE));
	}

	- scopeId = 0;
	+ m_scope_id = 0;

	if (SetNetFromBIP155Network(bip155_net, address_size)) {
	m_addr.resize(address_size);
	s >> MakeSpan(m_addr);

	if (m_net != NET_IPV6) {
	return;
	}

	// Do some special checks on IPv6 addresses.

	// Recognize NET_INTERNAL embedded in IPv6, such addresses are not
	// gossiped but could be coming from addrman, when unserializing
	// from disk.
	if (HasPrefix(m_addr, INTERNAL_IN_IPV6_PREFIX)) {
	m_net = NET_INTERNAL;
	memmove(m_addr.data(),
	m_addr.data() + INTERNAL_IN_IPV6_PREFIX.size(),
	ADDR_INTERNAL_SIZE);
	m_addr.resize(ADDR_INTERNAL_SIZE);
	return;
	}

	if (!HasPrefix(m_addr, IPV4_IN_IPV6_PREFIX) &&
	!HasPrefix(m_addr, TORV2_IN_IPV6_PREFIX)) {
	return;
	}

	// IPv4 and TORv2 are not supposed to be embedded in IPv6 (like in
	// V1 encoding). Unserialize as !IsValid(), thus ignoring them.
	} else {
	// If we receive an unknown BIP155 network id (from the future?)
	// then ignore the address - unserialize as !IsValid().
	s.ignore(address_size);
	}

	// Mimic a default-constructed CNetAddr object which is !IsValid() and
	// thus will not be gossiped, but continue reading next addresses from
	// the stream.
	m_net = NET_IPV6;
	m_addr.assign(ADDR_IPV6_SIZE, 0x0);
	}
	};

	class CSubNet {
	protected:
	/// Network (base) address
	CNetAddr network;
	/// Netmask, in network byte order
	uint8_t netmask[16];
	/// Is this value valid? (only used to signal parse errors)
	bool valid;

	bool SanityCheck() const;

	public:
	CSubNet();
	CSubNet(const CNetAddr &addr, uint8_t mask);
	CSubNet(const CNetAddr &addr, const CNetAddr &mask);

	// constructor for single ip subnet (<ipv4>/32 or <ipv6>/128)
	explicit CSubNet(const CNetAddr &addr);

	bool Match(const CNetAddr &addr) const;

	std::string ToString() const;
	bool IsValid() const;

	friend bool operator==(const CSubNet &a, const CSubNet &b);
	friend bool operator!=(const CSubNet &a, const CSubNet &b) {
	return !(a == b);
	}
	friend bool operator<(const CSubNet &a, const CSubNet &b);

	SERIALIZE_METHODS(CSubNet, obj) {
	READWRITE(obj.network);
	if (obj.network.IsIPv4()) {
	// Before D9176, CSubNet used the last 4 bytes of netmask to store
	// the relevant bytes for an IPv4 mask. For compatiblity reasons,
	// keep doing so in serialized form.
	uint8_t dummy[12] = {0};
	READWRITE(dummy);
	READWRITE(MakeSpan(obj.netmask).first(4));
	} else {
	READWRITE(obj.netmask);
	}
	READWRITE(obj.valid);
	// Mark invalid if the result doesn't pass sanity checking.
	SER_READ(obj, if (obj.valid) obj.valid = obj.SanityCheck());
	}
	};

	/** A combination of a network address (CNetAddr) and a (TCP) port */
	class CService : public CNetAddr {
	protected:
	// host order
	uint16_t port;

	public:
	CService();
	CService(const CNetAddr &ip, uint16_t port);
	CService(const struct in_addr &ipv4Addr, uint16_t port);
	explicit CService(const struct sockaddr_in &addr);
	uint16_t GetPort() const;
	bool GetSockAddr(struct sockaddr paddr, socklen_t addrlen) const;
	bool SetSockAddr(const struct sockaddr *paddr);
	friend bool operator==(const CService &a, const CService &b);
	friend bool operator!=(const CService &a, const CService &b) {
	return !(a == b);
	}
	friend bool operator<(const CService &a, const CService &b);
	std::vector<uint8_t> GetKey() const;
	std::string ToString() const;
	std::string ToStringPort() const;
	std::string ToStringIPPort() const;

	CService(const struct in6_addr &ipv6Addr, uint16_t port);
	explicit CService(const struct sockaddr_in6 &addr);

	SERIALIZE_METHODS(CService, obj) {
	READWRITEAS(CNetAddr, obj);
	READWRITE(Using<BigEndianFormatter<2>>(obj.port));
	}
	};

	bool SanityCheckASMap(const std::vector<bool> &asmap);

	#endif // BITCOIN_NETADDRESS_H

File Metadata

Mime Type: text/x-diff
Expires: Thu, May 22, 00:59 (19 h, 38 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5866235
Default Alt Text: (55 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions