Bitcoin Core  21.99.0
P2P Digital Currency
netaddress.h
Go to the documentation of this file.
1 // Copyright (c) 2009-2020 The Bitcoin Core developers
2 // Distributed under the MIT software license, see the accompanying
3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 
5 #ifndef BITCOIN_NETADDRESS_H
6 #define BITCOIN_NETADDRESS_H
7 
8 #if defined(HAVE_CONFIG_H)
10 #endif
11 
12 #include <attributes.h>
13 #include <compat.h>
14 #include <crypto/siphash.h>
15 #include <prevector.h>
16 #include <random.h>
17 #include <serialize.h>
18 #include <tinyformat.h>
19 #include <util/strencodings.h>
20 #include <util/string.h>
21 
22 #include <array>
23 #include <cstdint>
24 #include <ios>
25 #include <string>
26 #include <vector>
27 
34 static constexpr int ADDRV2_FORMAT = 0x20000000;
35 
45 enum Network
46 {
49 
52 
55 
58 
61 
64 
68 
71 };
72 
75 static const std::array<uint8_t, 12> IPV4_IN_IPV6_PREFIX{
76  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF
77 };
78 
83 static const std::array<uint8_t, 6> TORV2_IN_IPV6_PREFIX{
84  0xFD, 0x87, 0xD8, 0x7E, 0xEB, 0x43
85 };
86 
92 static const std::array<uint8_t, 6> INTERNAL_IN_IPV6_PREFIX{
93  0xFD, 0x6B, 0x88, 0xC0, 0x87, 0x24 // 0xFD + sha256("bitcoin")[0:5].
94 };
95 
97 static constexpr size_t ADDR_IPV4_SIZE = 4;
98 
100 static constexpr size_t ADDR_IPV6_SIZE = 16;
101 
104 static constexpr size_t ADDR_TORV3_SIZE = 32;
105 
107 static constexpr size_t ADDR_I2P_SIZE = 32;
108 
110 static constexpr size_t ADDR_CJDNS_SIZE = 16;
111 
113 static constexpr size_t ADDR_INTERNAL_SIZE = 10;
114 
118 class CNetAddr
119 {
120  protected:
126 
131 
136  uint32_t m_scope_id{0};
137 
138  public:
139  CNetAddr();
140  explicit CNetAddr(const struct in_addr& ipv4Addr);
141  void SetIP(const CNetAddr& ip);
142 
150 
151  bool SetInternal(const std::string& name);
152 
161  bool SetSpecial(const std::string& addr);
162 
163  bool IsBindAny() const; // INADDR_ANY equivalent
164  bool IsIPv4() const; // IPv4 mapped address (::FFFF:0:0/96, 0.0.0.0/0)
165  bool IsIPv6() const; // IPv6 address (not mapped IPv4, not Tor)
166  bool IsRFC1918() const; // IPv4 private networks (10.0.0.0/8, 192.168.0.0/16, 172.16.0.0/12)
167  bool IsRFC2544() const; // IPv4 inter-network communications (198.18.0.0/15)
168  bool IsRFC6598() const; // IPv4 ISP-level NAT (100.64.0.0/10)
169  bool IsRFC5737() const; // IPv4 documentation addresses (192.0.2.0/24, 198.51.100.0/24, 203.0.113.0/24)
170  bool IsRFC3849() const; // IPv6 documentation address (2001:0DB8::/32)
171  bool IsRFC3927() const; // IPv4 autoconfig (169.254.0.0/16)
172  bool IsRFC3964() const; // IPv6 6to4 tunnelling (2002::/16)
173  bool IsRFC4193() const; // IPv6 unique local (FC00::/7)
174  bool IsRFC4380() const; // IPv6 Teredo tunnelling (2001::/32)
175  bool IsRFC4843() const; // IPv6 ORCHID (deprecated) (2001:10::/28)
176  bool IsRFC7343() const; // IPv6 ORCHIDv2 (2001:20::/28)
177  bool IsRFC4862() const; // IPv6 autoconfig (FE80::/64)
178  bool IsRFC6052() const; // IPv6 well-known prefix for IPv4-embedded address (64:FF9B::/96)
179  bool IsRFC6145() const; // IPv6 IPv4-translated address (::FFFF:0:0:0/96) (actually defined in RFC2765)
180  bool IsHeNet() const; // IPv6 Hurricane Electric - https://he.net (2001:0470::/36)
181  bool IsTor() const;
182  bool IsI2P() const;
183  bool IsCJDNS() const;
184  bool IsLocal() const;
185  bool IsRoutable() const;
186  bool IsInternal() const;
187  bool IsValid() const;
188 
192  bool IsAddrV1Compatible() const;
193 
194  enum Network GetNetwork() const;
195  std::string ToString() const;
196  std::string ToStringIP() const;
197  uint64_t GetHash() const;
198  bool GetInAddr(struct in_addr* pipv4Addr) const;
199  Network GetNetClass() const;
200 
202  uint32_t GetLinkedIPv4() const;
204  bool HasLinkedIPv4() const;
205 
206  // The AS on the BGP path to the node we use to diversify
207  // peers in AddrMan bucketing based on the AS infrastructure.
208  // The ip->AS mapping depends on how asmap is constructed.
209  uint32_t GetMappedAS(const std::vector<bool> &asmap) const;
210 
211  std::vector<unsigned char> GetGroup(const std::vector<bool> &asmap) const;
212  std::vector<unsigned char> GetAddrBytes() const;
213  int GetReachabilityFrom(const CNetAddr *paddrPartner = nullptr) const;
214 
215  explicit CNetAddr(const struct in6_addr& pipv6Addr, const uint32_t scope = 0);
216  bool GetIn6Addr(struct in6_addr* pipv6Addr) const;
217 
218  friend bool operator==(const CNetAddr& a, const CNetAddr& b);
219  friend bool operator!=(const CNetAddr& a, const CNetAddr& b) { return !(a == b); }
220  friend bool operator<(const CNetAddr& a, const CNetAddr& b);
221 
225  bool IsRelayable() const
226  {
227  return IsIPv4() || IsIPv6() || IsTor();
228  }
229 
233  template <typename Stream>
234  void Serialize(Stream& s) const
235  {
236  if (s.GetVersion() & ADDRV2_FORMAT) {
238  } else {
240  }
241  }
242 
246  template <typename Stream>
247  void Unserialize(Stream& s)
248  {
249  if (s.GetVersion() & ADDRV2_FORMAT) {
251  } else {
253  }
254  }
255 
256  friend class CNetAddrHash;
257  friend class CSubNet;
258 
259  private:
267  bool SetTor(const std::string& addr);
268 
276  bool SetI2P(const std::string& addr);
277 
281  enum BIP155Network : uint8_t {
282  IPV4 = 1,
283  IPV6 = 2,
284  TORV2 = 3,
285  TORV3 = 4,
286  I2P = 5,
287  CJDNS = 6,
288  };
289 
293  static constexpr size_t V1_SERIALIZATION_SIZE = ADDR_IPV6_SIZE;
294 
300  static constexpr size_t MAX_ADDRV2_SIZE = 512;
301 
308 
316  bool SetNetFromBIP155Network(uint8_t possible_bip155_net, size_t address_size);
317 
321  void SerializeV1Array(uint8_t (&arr)[V1_SERIALIZATION_SIZE]) const
322  {
323  size_t prefix_size;
324 
325  switch (m_net) {
326  case NET_IPV6:
327  assert(m_addr.size() == sizeof(arr));
328  memcpy(arr, m_addr.data(), m_addr.size());
329  return;
330  case NET_IPV4:
331  prefix_size = sizeof(IPV4_IN_IPV6_PREFIX);
332  assert(prefix_size + m_addr.size() == sizeof(arr));
333  memcpy(arr, IPV4_IN_IPV6_PREFIX.data(), prefix_size);
334  memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
335  return;
336  case NET_INTERNAL:
337  prefix_size = sizeof(INTERNAL_IN_IPV6_PREFIX);
338  assert(prefix_size + m_addr.size() == sizeof(arr));
339  memcpy(arr, INTERNAL_IN_IPV6_PREFIX.data(), prefix_size);
340  memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
341  return;
342  case NET_ONION:
343  case NET_I2P:
344  case NET_CJDNS:
345  break;
346  case NET_UNROUTABLE:
347  case NET_MAX:
348  assert(false);
349  } // no default case, so the compiler can warn about missing cases
350 
351  // Serialize ONION, I2P and CJDNS as all-zeros.
352  memset(arr, 0x0, V1_SERIALIZATION_SIZE);
353  }
354 
358  template <typename Stream>
359  void SerializeV1Stream(Stream& s) const
360  {
361  uint8_t serialized[V1_SERIALIZATION_SIZE];
362 
363  SerializeV1Array(serialized);
364 
365  s << serialized;
366  }
367 
371  template <typename Stream>
372  void SerializeV2Stream(Stream& s) const
373  {
374  if (IsInternal()) {
375  // Serialize NET_INTERNAL as embedded in IPv6. We need to
376  // serialize such addresses from addrman.
377  s << static_cast<uint8_t>(BIP155Network::IPV6);
380  return;
381  }
382 
383  s << static_cast<uint8_t>(GetBIP155Network());
384  s << m_addr;
385  }
386 
391  {
392  // Use SetLegacyIPv6() so that m_net is set correctly. For example
393  // ::FFFF:0102:0304 should be set as m_net=NET_IPV4 (1.2.3.4).
394  SetLegacyIPv6(arr);
395  }
396 
400  template <typename Stream>
401  void UnserializeV1Stream(Stream& s)
402  {
403  uint8_t serialized[V1_SERIALIZATION_SIZE];
404 
405  s >> serialized;
406 
407  UnserializeV1Array(serialized);
408  }
409 
413  template <typename Stream>
414  void UnserializeV2Stream(Stream& s)
415  {
416  uint8_t bip155_net;
417  s >> bip155_net;
418 
419  size_t address_size;
420  s >> COMPACTSIZE(address_size);
421 
422  if (address_size > MAX_ADDRV2_SIZE) {
423  throw std::ios_base::failure(strprintf(
424  "Address too long: %u > %u", address_size, MAX_ADDRV2_SIZE));
425  }
426 
427  m_scope_id = 0;
428 
429  if (SetNetFromBIP155Network(bip155_net, address_size)) {
430  m_addr.resize(address_size);
431  s >> MakeSpan(m_addr);
432 
433  if (m_net != NET_IPV6) {
434  return;
435  }
436 
437  // Do some special checks on IPv6 addresses.
438 
439  // Recognize NET_INTERNAL embedded in IPv6, such addresses are not
440  // gossiped but could be coming from addrman, when unserializing from
441  // disk.
444  memmove(m_addr.data(), m_addr.data() + INTERNAL_IN_IPV6_PREFIX.size(),
447  return;
448  }
449 
452  return;
453  }
454 
455  // IPv4 and TORv2 are not supposed to be embedded in IPv6 (like in V1
456  // encoding). Unserialize as !IsValid(), thus ignoring them.
457  } else {
458  // If we receive an unknown BIP155 network id (from the future?) then
459  // ignore the address - unserialize as !IsValid().
460  s.ignore(address_size);
461  }
462 
463  // Mimic a default-constructed CNetAddr object which is !IsValid() and thus
464  // will not be gossiped, but continue reading next addresses from the stream.
465  m_net = NET_IPV6;
467  }
468 };
469 
471 {
472 public:
473  size_t operator()(const CNetAddr& a) const noexcept
474  {
475  CSipHasher hasher(m_salt_k0, m_salt_k1);
476  hasher.Write(a.m_net);
477  hasher.Write(a.m_addr.data(), a.m_addr.size());
478  return static_cast<size_t>(hasher.Finalize());
479  }
480 
481 private:
482  const uint64_t m_salt_k0 = GetRand(std::numeric_limits<uint64_t>::max());
483  const uint64_t m_salt_k1 = GetRand(std::numeric_limits<uint64_t>::max());
484 };
485 
486 class CSubNet
487 {
488  protected:
492  uint8_t netmask[16];
494  bool valid;
495 
496  bool SanityCheck() const;
497 
498  public:
502  CSubNet();
503 
511  CSubNet(const CNetAddr& addr, uint8_t mask);
512 
520  CSubNet(const CNetAddr& addr, const CNetAddr& mask);
521 
526  explicit CSubNet(const CNetAddr& addr);
527 
528  bool Match(const CNetAddr &addr) const;
529 
530  std::string ToString() const;
531  bool IsValid() const;
532 
533  friend bool operator==(const CSubNet& a, const CSubNet& b);
534  friend bool operator!=(const CSubNet& a, const CSubNet& b) { return !(a == b); }
535  friend bool operator<(const CSubNet& a, const CSubNet& b);
536 
538  {
539  READWRITE(obj.network);
540  if (obj.network.IsIPv4()) {
541  // Before commit 102867c587f5f7954232fb8ed8e85cda78bb4d32, CSubNet used the last 4 bytes of netmask
542  // to store the relevant bytes for an IPv4 mask. For compatibility reasons, keep doing so in
543  // serialized form.
544  unsigned char dummy[12] = {0};
545  READWRITE(dummy);
546  READWRITE(MakeSpan(obj.netmask).first(4));
547  } else {
548  READWRITE(obj.netmask);
549  }
550  READWRITE(obj.valid);
551  // Mark invalid if the result doesn't pass sanity checking.
552  SER_READ(obj, if (obj.valid) obj.valid = obj.SanityCheck());
553  }
554 };
555 
557 class CService : public CNetAddr
558 {
559  protected:
560  uint16_t port; // host order
561 
562  public:
563  CService();
564  CService(const CNetAddr& ip, uint16_t port);
565  CService(const struct in_addr& ipv4Addr, uint16_t port);
566  explicit CService(const struct sockaddr_in& addr);
567  uint16_t GetPort() const;
568  bool GetSockAddr(struct sockaddr* paddr, socklen_t *addrlen) const;
569  bool SetSockAddr(const struct sockaddr* paddr);
570  friend bool operator==(const CService& a, const CService& b);
571  friend bool operator!=(const CService& a, const CService& b) { return !(a == b); }
572  friend bool operator<(const CService& a, const CService& b);
573  std::vector<unsigned char> GetKey() const;
574  std::string ToString() const;
575  std::string ToStringPort() const;
576  std::string ToStringIPPort() const;
577 
578  CService(const struct in6_addr& ipv6Addr, uint16_t port);
579  explicit CService(const struct sockaddr_in6& addr);
580 
582  {
583  READWRITEAS(CNetAddr, obj);
585  }
586 };
587 
588 bool SanityCheckASMap(const std::vector<bool>& asmap);
589 
590 #endif // BITCOIN_NETADDRESS_H
CNetAddr::IsIPv6
bool IsIPv6() const
Definition: netaddress.cpp:320
ADDRV2_FORMAT
static constexpr int ADDRV2_FORMAT
A flag that is ORed into the protocol version to designate that addresses should be serialized in (un...
Definition: netaddress.h:34
CService
A combination of a network address (CNetAddr) and a (TCP) port.
Definition: netaddress.h:557
CService::GetSockAddr
bool GetSockAddr(struct sockaddr *paddr, socklen_t *addrlen) const
Obtain the IPv4/6 socket address this represents.
Definition: netaddress.cpp:982
CService::operator!=
friend bool operator!=(const CService &a, const CService &b)
Definition: netaddress.h:571
NET_UNROUTABLE
@ NET_UNROUTABLE
Addresses from these networks are not publicly routable on the global Internet.
Definition: netaddress.h:48
CNetAddr::GetGroup
std::vector< unsigned char > GetGroup(const std::vector< bool > &asmap) const
Get the canonical identifier of our network group.
Definition: netaddress.cpp:766
assert
assert(!tx.IsCoinBase())
NET_IPV4
@ NET_IPV4
IPv4.
Definition: netaddress.h:51
CNetAddr::SetI2P
bool SetI2P(const std::string &addr)
Parse an I2P address and set this object to it.
Definition: netaddress.cpp:269
CNetAddr::SetNetFromBIP155Network
bool SetNetFromBIP155Network(uint8_t possible_bip155_net, size_t address_size)
Set m_net from the provided BIP155 network id and size after validation.
Definition: netaddress.cpp:49
CNetAddr::m_addr
prevector< ADDR_IPV6_SIZE, uint8_t > m_addr
Raw representation of the network address.
Definition: netaddress.h:125
CNetAddr::GetAddrBytes
std::vector< unsigned char > GetAddrBytes() const
Definition: netaddress.cpp:820
CNetAddr::SetLegacyIPv6
void SetLegacyIPv6(Span< const uint8_t > ipv6)
Set from a legacy IPv6 address.
Definition: netaddress.cpp:138
CNetAddr::GetNetClass
Network GetNetClass() const
Definition: netaddress.cpp:707
CSubNet::SERIALIZE_METHODS
SERIALIZE_METHODS(CSubNet, obj)
Definition: netaddress.h:537
NET_INTERNAL
@ NET_INTERNAL
A set of addresses that represent the hash of a string or FQDN.
Definition: netaddress.h:67
TORV2_IN_IPV6_PREFIX
static const std::array< uint8_t, 6 > TORV2_IN_IPV6_PREFIX
Prefix of an IPv6 address when it contains an embedded TORv2 address.
Definition: netaddress.h:83
CNetAddr::IsRFC3964
bool IsRFC3964() const
Definition: netaddress.cpp:357
CNetAddr::GetIn6Addr
bool GetIn6Addr(struct in6_addr *pipv6Addr) const
Try to get our IPv6 address.
Definition: netaddress.cpp:675
CNetAddr::GetReachabilityFrom
int GetReachabilityFrom(const CNetAddr *paddrPartner=nullptr) const
Calculates a metric for how reachable (*this) is from a given partner.
Definition: netaddress.cpp:852
string.h
CNetAddr
Network address.
Definition: netaddress.h:118
NET_MAX
@ NET_MAX
Dummy value to indicate the number of NET_* constants.
Definition: netaddress.h:70
HasPrefix
bool HasPrefix(const T1 &obj, const std::array< uint8_t, PREFIX_LEN > &prefix)
Check whether a container begins with the given prefix.
Definition: string.h:91
CNetAddr::IsRFC2544
bool IsRFC2544() const
Definition: netaddress.cpp:330
CNetAddr::IsRFC4862
bool IsRFC4862() const
Definition: netaddress.cpp:374
CNetAddr::ToString
std::string ToString() const
Definition: netaddress.cpp:631
CNetAddr::UnserializeV1Array
void UnserializeV1Array(uint8_t(&arr)[V1_SERIALIZATION_SIZE])
Unserialize from a pre-ADDRv2/BIP155 format from an array.
Definition: netaddress.h:390
CNetAddr::SetTor
bool SetTor(const std::string &addr)
Parse a Tor address and set this object to it.
Definition: netaddress.cpp:229
CSubNet::valid
bool valid
Is this value valid? (only used to signal parse errors)
Definition: netaddress.h:494
bitcoin-config.h
CSubNet::operator!=
friend bool operator!=(const CSubNet &a, const CSubNet &b)
Definition: netaddress.h:534
CustomUintFormatter
Serialization wrapper class for custom integers and enums.
Definition: serialize.h:472
CNetAddr::UnserializeV1Stream
void UnserializeV1Stream(Stream &s)
Unserialize from a pre-ADDRv2/BIP155 format from a stream.
Definition: netaddress.h:401
READWRITEAS
#define READWRITEAS(type, obj)
Definition: serialize.h:148
Network
Network
A network type.
Definition: netaddress.h:45
CNetAddr::IsRelayable
bool IsRelayable() const
Whether this address should be relayed to other peers even if we can't reach it ourselves.
Definition: netaddress.h:225
CNetAddr::IsRFC6145
bool IsRFC6145() const
Definition: netaddress.cpp:385
CNetAddr::IsInternal
bool IsInternal() const
Definition: netaddress.cpp:500
GetRand
uint64_t GetRand(uint64_t nMax) noexcept
Generate a uniform random integer in the range [0..range).
Definition: random.cpp:591
CService::ToStringIPPort
std::string ToStringIPPort() const
Definition: netaddress.cpp:1028
CSipHasher
SipHash-2-4.
Definition: siphash.h:13
CNetAddr::MAX_ADDRV2_SIZE
static constexpr size_t MAX_ADDRV2_SIZE
Maximum size of an address as defined in BIP155 (in bytes).
Definition: netaddress.h:300
CSubNet::Match
bool Match(const CNetAddr &addr) const
Definition: netaddress.cpp:1147
CNetAddr::IsBindAny
bool IsBindAny() const
Definition: netaddress.cpp:310
CNetAddr::GetInAddr
bool GetInAddr(struct in_addr *pipv4Addr) const
Try to get our IPv4 address.
Definition: netaddress.cpp:656
CNetAddr::GetBIP155Network
BIP155Network GetBIP155Network() const
Get the BIP155 network id of this address.
Definition: netaddress.cpp:27
CNetAddr::ToStringIP
std::string ToStringIP() const
Definition: netaddress.cpp:608
tinyformat.h
CNetAddr::Unserialize
void Unserialize(Stream &s)
Unserialize from a stream.
Definition: netaddress.h:247
IPV6
@ IPV6
Definition: netbase.cpp:280
CNetAddr::IsIPv4
bool IsIPv4() const
Definition: netaddress.cpp:318
Span
A Span is an object that can refer to a contiguous sequence of objects.
Definition: span.h:92
ADDR_INTERNAL_SIZE
static constexpr size_t ADDR_INTERNAL_SIZE
Size of "internal" (NET_INTERNAL) address (in bytes).
Definition: netaddress.h:113
strencodings.h
CNetAddr::IsI2P
bool IsI2P() const
Check whether this object represents an I2P address.
Definition: netaddress.cpp:418
NET_I2P
@ NET_I2P
I2P.
Definition: netaddress.h:60
siphash.h
CNetAddr::GetNetwork
enum Network GetNetwork() const
Definition: netaddress.cpp:524
random.h
CService::ToString
std::string ToString() const
Definition: netaddress.cpp:1037
CNetAddr::m_scope_id
uint32_t m_scope_id
Scope id if scoped/link-local IPV6 address.
Definition: netaddress.h:136
CSubNet::network
CNetAddr network
Network (base) address.
Definition: netaddress.h:490
ADDR_TORV3_SIZE
static constexpr size_t ADDR_TORV3_SIZE
Size of TORv3 address (in bytes).
Definition: netaddress.h:104
CNetAddr::SetSpecial
bool SetSpecial(const std::string &addr)
Parse a Tor or I2P address and set this object to it.
Definition: netaddress.cpp:212
CService::SetSockAddr
bool SetSockAddr(const struct sockaddr *paddr)
Definition: netaddress.cpp:941
CSipHasher::Finalize
uint64_t Finalize() const
Compute the 64-bit SipHash-2-4 of the data written so far.
Definition: siphash.cpp:76
CNetAddr::UnserializeV2Stream
void UnserializeV2Stream(Stream &s)
Unserialize from a ADDRv2 / BIP155 format.
Definition: netaddress.h:414
CNetAddr::IsRFC3849
bool IsRFC3849() const
Definition: netaddress.cpp:352
compat.h
CNetAddr::IsRoutable
bool IsRoutable() const
Definition: netaddress.cpp:490
CNetAddr::GetHash
uint64_t GetHash() const
Definition: netaddress.cpp:830
CNetAddr::SerializeV1Stream
void SerializeV1Stream(Stream &s) const
Serialize in pre-ADDRv2/BIP155 format to a stream.
Definition: netaddress.h:359
CService::SERIALIZE_METHODS
SERIALIZE_METHODS(CService, obj)
Definition: netaddress.h:581
CService::ToStringPort
std::string ToStringPort() const
Definition: netaddress.cpp:1023
INTERNAL_IN_IPV6_PREFIX
static const std::array< uint8_t, 6 > INTERNAL_IN_IPV6_PREFIX
Prefix of an IPv6 address when it contains an embedded "internal" address.
Definition: netaddress.h:92
CNetAddr::CJDNS
@ CJDNS
Definition: netaddress.h:287
CNetAddr::SerializeV1Array
void SerializeV1Array(uint8_t(&arr)[V1_SERIALIZATION_SIZE]) const
Serialize in pre-ADDRv2/BIP155 format to an array.
Definition: netaddress.h:321
CNetAddr::GetMappedAS
uint32_t GetMappedAS(const std::vector< bool > &asmap) const
Definition: netaddress.cpp:725
CNetAddr::IsRFC6052
bool IsRFC6052() const
Definition: netaddress.cpp:362
CSubNet::operator<
friend bool operator<(const CSubNet &a, const CSubNet &b)
Definition: netaddress.cpp:1241
CNetAddr::IsValid
bool IsValid() const
Definition: netaddress.cpp:451
CNetAddr::IsRFC1918
bool IsRFC1918() const
Definition: netaddress.cpp:322
CNetAddr::IsRFC6598
bool IsRFC6598() const
Definition: netaddress.cpp:340
CSubNet
Definition: netaddress.h:486
CNetAddr::IsHeNet
bool IsHeNet() const
Definition: netaddress.cpp:404
CNetAddr::IsCJDNS
bool IsCJDNS() const
Check whether this object represents a CJDNS address.
Definition: netaddress.cpp:423
CNetAddr::operator!=
friend bool operator!=(const CNetAddr &a, const CNetAddr &b)
Definition: netaddress.h:219
READWRITE
#define READWRITE(...)
Definition: serialize.h:147
CNetAddr::IsRFC5737
bool IsRFC5737() const
Definition: netaddress.cpp:345
CNetAddr::operator==
friend bool operator==(const CNetAddr &a, const CNetAddr &b)
Definition: netaddress.cpp:636
IPV4_IN_IPV6_PREFIX
static const std::array< uint8_t, 12 > IPV4_IN_IPV6_PREFIX
Prefix of an IPv6 address when it contains an embedded IPv4 address.
Definition: netaddress.h:75
SanityCheckASMap
bool SanityCheckASMap(const std::vector< bool > &asmap)
Definition: netaddress.cpp:1246
CService::GetPort
uint16_t GetPort() const
Definition: netaddress.cpp:955
attributes.h
CNetAddr::BIP155Network
BIP155Network
BIP155 network ids recognized by this software.
Definition: netaddress.h:281
CNetAddr::I2P
@ I2P
Definition: netaddress.h:286
name
const char * name
Definition: rest.cpp:43
prevector::resize
void resize(size_type new_size)
Definition: prevector.h:316
CSubNet::netmask
uint8_t netmask[16]
Netmask, in network byte order.
Definition: netaddress.h:492
CService::operator==
friend bool operator==(const CService &a, const CService &b)
Definition: netaddress.cpp:960
prevector< ADDR_IPV6_SIZE, uint8_t >
prevector::assign
void assign(size_type n, const T &val)
Definition: prevector.h:218
strprintf
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1164
CNetAddrHash::m_salt_k0
const uint64_t m_salt_k0
Definition: netaddress.h:482
CNetAddr::SerializeV2Stream
void SerializeV2Stream(Stream &s) const
Serialize as ADDRv2 / BIP155.
Definition: netaddress.h:372
ADDR_IPV6_SIZE
static constexpr size_t ADDR_IPV6_SIZE
Size of IPv6 address (in bytes).
Definition: netaddress.h:100
ADDR_IPV4_SIZE
static constexpr size_t ADDR_IPV4_SIZE
Size of IPv4 address (in bytes).
Definition: netaddress.h:97
CSubNet::operator==
friend bool operator==(const CSubNet &a, const CSubNet &b)
Definition: netaddress.cpp:1236
CNetAddr::GetLinkedIPv4
uint32_t GetLinkedIPv4() const
For IPv4, mapped IPv4, SIIT translated IPv4, Teredo, 6to4 tunneled addresses, return the relevant IPv...
Definition: netaddress.cpp:690
CSubNet::ToString
std::string ToString() const
Definition: netaddress.cpp:1175
CNetAddr::operator<
friend bool operator<(const CNetAddr &a, const CNetAddr &b)
Definition: netaddress.cpp:641
ADDR_I2P_SIZE
static constexpr size_t ADDR_I2P_SIZE
Size of I2P address (in bytes).
Definition: netaddress.h:107
CService::port
uint16_t port
Definition: netaddress.h:560
prevector::data
value_type * data()
Definition: prevector.h:528
CNetAddr::IPV6
@ IPV6
Definition: netaddress.h:283
CNetAddrHash::m_salt_k1
const uint64_t m_salt_k1
Definition: netaddress.h:483
NET_ONION
@ NET_ONION
TOR (v2 or v3)
Definition: netaddress.h:57
CNetAddr::IsRFC4193
bool IsRFC4193() const
Definition: netaddress.cpp:380
CNetAddr::IsRFC7343
bool IsRFC7343() const
Definition: netaddress.cpp:398
prevector::size
size_type size() const
Definition: prevector.h:282
CNetAddr::IsTor
bool IsTor() const
Check whether this object represents a TOR address.
Definition: netaddress.cpp:413
CNetAddr::TORV3
@ TORV3
Definition: netaddress.h:285
ADDR_CJDNS_SIZE
static constexpr size_t ADDR_CJDNS_SIZE
Size of CJDNS address (in bytes).
Definition: netaddress.h:110
CSubNet::IsValid
bool IsValid() const
Definition: netaddress.cpp:1208
serialize.h
CNetAddrHash::operator()
size_t operator()(const CNetAddr &a) const noexcept
Definition: netaddress.h:473
NET_IPV6
@ NET_IPV6
IPv6.
Definition: netaddress.h:54
CNetAddr::SetInternal
bool SetInternal(const std::string &name)
Create an "internal" address that represents a name or FQDN.
Definition: netaddress.cpp:173
CNetAddr::m_net
Network m_net
Network to which this address belongs.
Definition: netaddress.h:130
COMPACTSIZE
#define COMPACTSIZE(obj)
Definition: serialize.h:444
prevector.h
CNetAddr::CNetAddr
CNetAddr()
Construct an unspecified IPv6 network address (::/128).
Definition: netaddress.cpp:105
NET_CJDNS
@ NET_CJDNS
CJDNS.
Definition: netaddress.h:63
CNetAddr::IsAddrV1Compatible
bool IsAddrV1Compatible() const
Check if the current object can be serialized in pre-ADDRv2/BIP155 format.
Definition: netaddress.cpp:505
CNetAddr::IsRFC3927
bool IsRFC3927() const
Definition: netaddress.cpp:335
CNetAddr::HasLinkedIPv4
bool HasLinkedIPv4() const
Whether this address has a linked IPv4 address (see GetLinkedIPv4()).
Definition: netaddress.cpp:685
SER_READ
#define SER_READ(obj, code)
Definition: serialize.h:149
CNetAddr::IsRFC4843
bool IsRFC4843() const
Definition: netaddress.cpp:392
CNetAddr::IPV4
@ IPV4
Definition: netaddress.h:282
CNetAddr::V1_SERIALIZATION_SIZE
static constexpr size_t V1_SERIALIZATION_SIZE
Size of CNetAddr when serialized as ADDRv1 (pre-BIP155) (in bytes).
Definition: netaddress.h:293
Using
static Wrapper< Formatter, T & > Using(T &&t)
Cause serialization/deserialization of an object to be done using a specified formatter class.
Definition: serialize.h:440
CSubNet::CSubNet
CSubNet()
Construct an invalid subnet (empty, Match() always returns false).
Definition: netaddress.cpp:1042
MakeSpan
constexpr Span< A > MakeSpan(A(&a)[N])
MakeSpan for arrays:
Definition: span.h:222
CNetAddr::Serialize
void Serialize(Stream &s) const
Serialize to a stream.
Definition: netaddress.h:234
CNetAddr::IsLocal
bool IsLocal() const
Definition: netaddress.cpp:425
CNetAddr::TORV2
@ TORV2
Definition: netaddress.h:284
CNetAddr::IsRFC4380
bool IsRFC4380() const
Definition: netaddress.cpp:369
CService::CService
CService()
Definition: netaddress.cpp:915
CNetAddrHash
Definition: netaddress.h:470
CNetAddr::SetIP
void SetIP(const CNetAddr &ip)
Definition: netaddress.cpp:107
CSipHasher::Write
CSipHasher & Write(uint64_t data)
Hash a 64-bit integer worth of data It is treated as if this was the little-endian interpretation of ...
Definition: siphash.cpp:28
CService::GetKey
std::vector< unsigned char > GetKey() const
Definition: netaddress.cpp:1015
CService::operator<
friend bool operator<(const CService &a, const CService &b)
Definition: netaddress.cpp:965
CSubNet::SanityCheck
bool SanityCheck() const
Definition: netaddress.cpp:1213