Bitcoin ABC 0.31.6
P2P Digital Currency
netaddress.cpp
Go to the documentation of this file.
1// Copyright (c) 2009-2010 Satoshi Nakamoto
2// Copyright (c) 2009-2016 The Bitcoin Core developers
3// Distributed under the MIT software license, see the accompanying
4// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6#include <netaddress.h>
7
8#include <crypto/common.h>
9#include <crypto/sha3.h>
10#include <hash.h>
11#include <prevector.h>
12#include <util/asmap.h>
13#include <util/strencodings.h>
14#include <util/string.h>
15
16#include <tinyformat.h>
17
18#include <algorithm>
19#include <array>
20#include <cstdint>
21#include <ios>
22#include <iterator>
23#include <tuple>
24
26 switch (m_net) {
27 case NET_IPV4:
29 case NET_IPV6:
31 case NET_ONION:
32 switch (m_addr.size()) {
33 case ADDR_TORV2_SIZE:
34 return BIP155Network::TORV2;
35 case ADDR_TORV3_SIZE:
36 return BIP155Network::TORV3;
37 default:
38 assert(false);
39 }
40 case NET_I2P:
41 return BIP155Network::I2P;
42 case NET_CJDNS:
43 return BIP155Network::CJDNS;
44 case NET_INTERNAL:
45 // should have been handled before calling this function
46 case NET_UNROUTABLE:
47 // m_net is never and should not be set to NET_UNROUTABLE
48 case NET_MAX:
49 // m_net is never and should not be set to NET_MAX
50 assert(false);
51 } // no default case, so the compiler can warn about missing cases
52
53 assert(false);
54}
55
56bool CNetAddr::SetNetFromBIP155Network(uint8_t possible_bip155_net,
57 size_t address_size) {
58 switch (possible_bip155_net) {
60 if (address_size == ADDR_IPV4_SIZE) {
62 return true;
63 }
64 throw std::ios_base::failure(
65 strprintf("BIP155 IPv4 address with length %u (should be %u)",
66 address_size, ADDR_IPV4_SIZE));
68 if (address_size == ADDR_IPV6_SIZE) {
70 return true;
71 }
72 throw std::ios_base::failure(
73 strprintf("BIP155 IPv6 address with length %u (should be %u)",
74 address_size, ADDR_IPV6_SIZE));
75 case BIP155Network::TORV2:
76 if (address_size == ADDR_TORV2_SIZE) {
78 return true;
79 }
80 throw std::ios_base::failure(
81 strprintf("BIP155 TORv2 address with length %u (should be %u)",
82 address_size, ADDR_TORV2_SIZE));
83 case BIP155Network::TORV3:
84 if (address_size == ADDR_TORV3_SIZE) {
86 return true;
87 }
88 throw std::ios_base::failure(
89 strprintf("BIP155 TORv3 address with length %u (should be %u)",
90 address_size, ADDR_TORV3_SIZE));
92 if (address_size == ADDR_I2P_SIZE) {
93 m_net = NET_I2P;
94 return true;
95 }
96 throw std::ios_base::failure(
97 strprintf("BIP155 I2P address with length %u (should be %u)",
98 address_size, ADDR_I2P_SIZE));
99 case BIP155Network::CJDNS:
100 if (address_size == ADDR_CJDNS_SIZE) {
102 return true;
103 }
104 throw std::ios_base::failure(
105 strprintf("BIP155 CJDNS address with length %u (should be %u)",
106 address_size, ADDR_CJDNS_SIZE));
107 }
108
109 // Don't throw on addresses with unknown network ids (maybe from the
110 // future). Instead silently drop them and have the unserialization code
111 // consume subsequent ones which may be known to us.
112 return false;
113}
114
121
122void CNetAddr::SetIP(const CNetAddr &ipIn) {
123 // Size check.
124 switch (ipIn.m_net) {
125 case NET_IPV4:
126 assert(ipIn.m_addr.size() == ADDR_IPV4_SIZE);
127 break;
128 case NET_IPV6:
129 assert(ipIn.m_addr.size() == ADDR_IPV6_SIZE);
130 break;
131 case NET_ONION:
132 assert(ipIn.m_addr.size() == ADDR_TORV2_SIZE ||
133 ipIn.m_addr.size() == ADDR_TORV3_SIZE);
134 break;
135 case NET_I2P:
136 assert(ipIn.m_addr.size() == ADDR_I2P_SIZE);
137 break;
138 case NET_CJDNS:
140 break;
141 case NET_INTERNAL:
143 break;
144 case NET_UNROUTABLE:
145 case NET_MAX:
146 assert(false);
147 } // no default case, so the compiler can warn about missing cases
148
149 m_net = ipIn.m_net;
150 m_addr = ipIn.m_addr;
151}
152
154 assert(ipv6.size() == ADDR_IPV6_SIZE);
155
156 size_t skip{0};
157
158 if (HasPrefix(ipv6, IPV4_IN_IPV6_PREFIX)) {
159 // IPv4-in-IPv6
160 m_net = NET_IPV4;
161 skip = sizeof(IPV4_IN_IPV6_PREFIX);
162 } else if (HasPrefix(ipv6, TORV2_IN_IPV6_PREFIX)) {
163 // TORv2-in-IPv6
165 skip = sizeof(TORV2_IN_IPV6_PREFIX);
166 } else if (HasPrefix(ipv6, INTERNAL_IN_IPV6_PREFIX)) {
167 // Internal-in-IPv6
169 skip = sizeof(INTERNAL_IN_IPV6_PREFIX);
170 } else {
171 // IPv6
172 m_net = NET_IPV6;
173 }
174
175 m_addr.assign(ipv6.begin() + skip, ipv6.end());
176}
177
185bool CNetAddr::SetInternal(const std::string &name) {
186 if (name.empty()) {
187 return false;
188 }
190 uint8_t hash[32] = {};
191 CSHA256().Write((const uint8_t *)name.data(), name.size()).Finalize(hash);
192 m_addr.assign(hash, hash + ADDR_INTERNAL_SIZE);
193 return true;
194}
195
196namespace torv3 {
197// https://gitweb.torproject.org/torspec.git/tree/rend-spec-v3.txt#n2135
198static constexpr size_t CHECKSUM_LEN = 2;
199static const uint8_t VERSION[] = {3};
200static constexpr size_t TOTAL_LEN =
202
203static void Checksum(Span<const uint8_t> addr_pubkey,
204 uint8_t (&checksum)[CHECKSUM_LEN]) {
205 // TORv3 CHECKSUM = H(".onion checksum" | PUBKEY | VERSION)[:2]
206 static const uint8_t prefix[] = ".onion checksum";
207 static constexpr size_t prefix_len = 15;
208
209 SHA3_256 hasher;
210
211 hasher.Write(Span{prefix}.first(prefix_len));
212 hasher.Write(addr_pubkey);
213 hasher.Write(VERSION);
214
215 uint8_t checksum_full[SHA3_256::OUTPUT_SIZE];
216
217 hasher.Finalize(checksum_full);
218
219 memcpy(checksum, checksum_full, sizeof(checksum));
220}
221
222}; // namespace torv3
223
224bool CNetAddr::SetSpecial(const std::string &addr) {
225 if (!ContainsNoNUL(addr)) {
226 return false;
227 }
228
229 if (SetTor(addr)) {
230 return true;
231 }
232
233 if (SetI2P(addr)) {
234 return true;
235 }
236
237 return false;
238}
239
240bool CNetAddr::SetTor(const std::string &addr) {
241 static const char *suffix{".onion"};
242 static constexpr size_t suffix_len{6};
243
244 if (addr.size() <= suffix_len ||
245 addr.substr(addr.size() - suffix_len) != suffix) {
246 return false;
247 }
248
249 auto input = DecodeBase32(
250 std::string_view{addr}.substr(0, addr.size() - suffix_len));
251
252 if (!input) {
253 return false;
254 }
255
256 switch (input->size()) {
257 case ADDR_TORV2_SIZE:
259 m_addr.assign(input->begin(), input->end());
260 return true;
261 case torv3::TOTAL_LEN: {
262 Span<const uint8_t> input_pubkey{input->data(), ADDR_TORV3_SIZE};
263 Span<const uint8_t> input_checksum{input->data() + ADDR_TORV3_SIZE,
265 Span<const uint8_t> input_version{input->data() + ADDR_TORV3_SIZE +
267 sizeof(torv3::VERSION)};
268
269 if (input_version != torv3::VERSION) {
270 return false;
271 }
272
273 uint8_t calculated_checksum[torv3::CHECKSUM_LEN];
274 torv3::Checksum(input_pubkey, calculated_checksum);
275
276 if (input_checksum != calculated_checksum) {
277 return false;
278 }
279
281 m_addr.assign(input_pubkey.begin(), input_pubkey.end());
282 return true;
283 }
284 }
285
286 return false;
287}
288
289bool CNetAddr::SetI2P(const std::string &addr) {
290 // I2P addresses that we support consist of 52 base32 characters +
291 // ".b32.i2p".
292 static constexpr size_t b32_len{52};
293 static const char *suffix{".b32.i2p"};
294 static constexpr size_t suffix_len{8};
295
296 if (addr.size() != b32_len + suffix_len ||
297 ToLower(addr.substr(b32_len)) != suffix) {
298 return false;
299 }
300
301 // Remove the ".b32.i2p" suffix and pad to a multiple of 8 chars, so
302 // DecodeBase32() can decode it.
303 const std::string b32_padded = addr.substr(0, b32_len) + "====";
304
305 auto address_bytes = DecodeBase32(b32_padded);
306
307 if (!address_bytes || address_bytes->size() != ADDR_I2P_SIZE) {
308 return false;
309 }
310
311 m_net = NET_I2P;
312 m_addr.assign(address_bytes->begin(), address_bytes->end());
313
314 return true;
315}
316
317CNetAddr::CNetAddr(const struct in_addr &ipv4Addr) {
318 m_net = NET_IPV4;
319 const uint8_t *ptr = reinterpret_cast<const uint8_t *>(&ipv4Addr);
320 m_addr.assign(ptr, ptr + ADDR_IPV4_SIZE);
321}
322
323CNetAddr::CNetAddr(const struct in6_addr &ipv6Addr, const uint32_t scope) {
325 {reinterpret_cast<const uint8_t *>(&ipv6Addr), sizeof(ipv6Addr)});
326 m_scope_id = scope;
327}
328
330 if (!IsIPv4() && !IsIPv6()) {
331 return false;
332 }
333 return std::all_of(m_addr.begin(), m_addr.end(),
334 [](uint8_t b) { return b == 0; });
335}
336
337bool CNetAddr::IsIPv4() const {
338 return m_net == NET_IPV4;
339}
340
341bool CNetAddr::IsIPv6() const {
342 return m_net == NET_IPV6;
343}
344
346 return IsIPv4() &&
347 (m_addr[0] == 10 || (m_addr[0] == 192 && m_addr[1] == 168) ||
348 (m_addr[0] == 172 && m_addr[1] >= 16 && m_addr[1] <= 31));
349}
350
352 return IsIPv4() && m_addr[0] == 198 && (m_addr[1] == 18 || m_addr[1] == 19);
353}
354
356 return IsIPv4() && HasPrefix(m_addr, std::array<uint8_t, 2>{{169, 254}});
357}
358
360 return IsIPv4() && m_addr[0] == 100 && m_addr[1] >= 64 && m_addr[1] <= 127;
361}
362
364 return IsIPv4() &&
365 (HasPrefix(m_addr, std::array<uint8_t, 3>{{192, 0, 2}}) ||
366 HasPrefix(m_addr, std::array<uint8_t, 3>{{198, 51, 100}}) ||
367 HasPrefix(m_addr, std::array<uint8_t, 3>{{203, 0, 113}}));
368}
369
371 return IsIPv6() &&
372 HasPrefix(m_addr, std::array<uint8_t, 4>{{0x20, 0x01, 0x0D, 0xB8}});
373}
374
376 return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 2>{{0x20, 0x02}});
377}
378
380 return IsIPv6() &&
381 HasPrefix(m_addr, std::array<uint8_t, 12>{{0x00, 0x64, 0xFF, 0x9B,
382 0x00, 0x00, 0x00, 0x00,
383 0x00, 0x00, 0x00, 0x00}});
384}
385
387 return IsIPv6() &&
388 HasPrefix(m_addr, std::array<uint8_t, 4>{{0x20, 0x01, 0x00, 0x00}});
389}
390
392 return IsIPv6() &&
393 HasPrefix(m_addr, std::array<uint8_t, 8>{{0xFE, 0x80, 0x00, 0x00,
394 0x00, 0x00, 0x00, 0x00}});
395}
396
398 return IsIPv6() && (m_addr[0] & 0xFE) == 0xFC;
399}
400
402 return IsIPv6() &&
403 HasPrefix(m_addr, std::array<uint8_t, 12>{{0x00, 0x00, 0x00, 0x00,
404 0x00, 0x00, 0x00, 0x00,
405 0xFF, 0xFF, 0x00, 0x00}});
406}
407
409 return IsIPv6() &&
410 HasPrefix(m_addr, std::array<uint8_t, 3>{{0x20, 0x01, 0x00}}) &&
411 (m_addr[3] & 0xF0) == 0x10;
412}
413
415 return IsIPv6() &&
416 HasPrefix(m_addr, std::array<uint8_t, 3>{{0x20, 0x01, 0x00}}) &&
417 (m_addr[3] & 0xF0) == 0x20;
418}
419
420bool CNetAddr::IsHeNet() const {
421 return IsIPv6() &&
422 HasPrefix(m_addr, std::array<uint8_t, 4>{{0x20, 0x01, 0x04, 0x70}});
423}
424
430bool CNetAddr::IsTor() const {
431 return m_net == NET_ONION;
432}
433
437bool CNetAddr::IsI2P() const {
438 return m_net == NET_I2P;
439}
440
444bool CNetAddr::IsCJDNS() const {
445 return m_net == NET_CJDNS;
446}
447
448bool CNetAddr::IsLocal() const {
449 // IPv4 loopback (127.0.0.0/8 or 0.0.0.0/8)
450 if (IsIPv4() && (m_addr[0] == 127 || m_addr[0] == 0)) {
451 return true;
452 }
453
454 // IPv6 loopback (::1/128)
455 static const uint8_t pchLocal[16] = {0, 0, 0, 0, 0, 0, 0, 0,
456 0, 0, 0, 0, 0, 0, 0, 1};
457 if (IsIPv6() && memcmp(m_addr.data(), pchLocal, sizeof(pchLocal)) == 0) {
458 return true;
459 }
460
461 return false;
462}
463
474bool CNetAddr::IsValid() const {
475 // unspecified IPv6 address (::/128)
476 uint8_t ipNone6[16] = {};
477 if (IsIPv6() && memcmp(m_addr.data(), ipNone6, sizeof(ipNone6)) == 0) {
478 return false;
479 }
480
481 // documentation IPv6 address
482 if (IsRFC3849()) {
483 return false;
484 }
485
486 if (IsInternal()) {
487 return false;
488 }
489
490 if (IsIPv4()) {
491 const uint32_t addr = ReadBE32(m_addr.data());
492 if (addr == INADDR_ANY || addr == INADDR_NONE) {
493 return false;
494 }
495 }
496
497 return true;
498}
499
510 return IsValid() &&
511 !(IsRFC1918() || IsRFC2544() || IsRFC3927() || IsRFC4862() ||
512 IsRFC6598() || IsRFC5737() || (IsRFC4193() && !IsTor()) ||
513 IsRFC4843() || IsRFC7343() || IsLocal() || IsInternal());
514}
515
522 return m_net == NET_INTERNAL;
523}
524
526 switch (m_net) {
527 case NET_IPV4:
528 case NET_IPV6:
529 case NET_INTERNAL:
530 return true;
531 case NET_ONION:
532 return m_addr.size() == ADDR_TORV2_SIZE;
533 case NET_I2P:
534 case NET_CJDNS:
535 return false;
536 case NET_UNROUTABLE:
537 // m_net is never and should not be set to NET_UNROUTABLE
538 case NET_MAX:
539 // m_net is never and should not be set to NET_MAX
540 assert(false);
541 } // no default case, so the compiler can warn about missing cases
542
543 assert(false);
544}
545
547 if (IsInternal()) {
548 return NET_INTERNAL;
549 }
550
551 if (!IsRoutable()) {
552 return NET_UNROUTABLE;
553 }
554
555 return m_net;
556}
557
558static std::string IPv4ToString(Span<const uint8_t> a) {
559 return strprintf("%u.%u.%u.%u", a[0], a[1], a[2], a[3]);
560}
561
565static std::string IPv6ToString(Span<const uint8_t> a, uint32_t scope_id) {
566 assert(a.size() == ADDR_IPV6_SIZE);
567 const std::array<uint16_t, 8> groups{{
568 ReadBE16(&a[0]),
569 ReadBE16(&a[2]),
570 ReadBE16(&a[4]),
571 ReadBE16(&a[6]),
572 ReadBE16(&a[8]),
573 ReadBE16(&a[10]),
574 ReadBE16(&a[12]),
575 ReadBE16(&a[14]),
576 }};
577
578 // The zero compression implementation is inspired by Rust's
579 // std::net::Ipv6Addr, see
580 // https://github.com/rust-lang/rust/blob/cc4103089f40a163f6d143f06359cba7043da29b/library/std/src/net/ip.rs#L1635-L1683
581 struct ZeroSpan {
582 size_t start_index{0};
583 size_t len{0};
584 };
585
586 // Find longest sequence of consecutive all-zero fields. Use first zero
587 // sequence if two or more zero sequences of equal length are found.
588 ZeroSpan longest, current;
589 for (size_t i{0}; i < groups.size(); ++i) {
590 if (groups[i] != 0) {
591 current = {i + 1, 0};
592 continue;
593 }
594 current.len += 1;
595 if (current.len > longest.len) {
596 longest = current;
597 }
598 }
599
600 std::string r;
601 r.reserve(39);
602 for (size_t i{0}; i < groups.size(); ++i) {
603 // Replace the longest sequence of consecutive all-zero fields with
604 // two colons ("::").
605 if (longest.len >= 2 && i >= longest.start_index &&
606 i < longest.start_index + longest.len) {
607 if (i == longest.start_index) {
608 r += "::";
609 }
610 continue;
611 }
612 r += strprintf("%s%x", ((!r.empty() && r.back() != ':') ? ":" : ""),
613 groups[i]);
614 }
615
616 if (scope_id != 0) {
617 r += strprintf("%%%u", scope_id);
618 }
619
620 return r;
621}
622
623std::string CNetAddr::ToStringIP() const {
624 switch (m_net) {
625 case NET_IPV4:
626 return IPv4ToString(m_addr);
627 case NET_IPV6:
629 case NET_ONION:
630 switch (m_addr.size()) {
631 case ADDR_TORV2_SIZE:
632 return EncodeBase32(m_addr) + ".onion";
633 case ADDR_TORV3_SIZE: {
634 uint8_t checksum[torv3::CHECKSUM_LEN];
635 torv3::Checksum(m_addr, checksum);
636
637 // TORv3 onion_address = base32(PUBKEY | CHECKSUM | VERSION)
638 // + ".onion"
640 m_addr.end()};
641 address.insert(address.end(), checksum,
642 checksum + torv3::CHECKSUM_LEN);
643 address.insert(address.end(), torv3::VERSION,
645
646 return EncodeBase32(address) + ".onion";
647 }
648 default:
649 assert(false);
650 }
651 case NET_I2P:
652 return EncodeBase32(m_addr, false /* don't pad with = */) +
653 ".b32.i2p";
654 case NET_CJDNS:
655 return IPv6ToString(m_addr, 0);
656 case NET_INTERNAL:
657 return EncodeBase32(m_addr) + ".internal";
658 case NET_UNROUTABLE:
659 // m_net is never and should not be set to NET_UNROUTABLE
660 case NET_MAX:
661 // m_net is never and should not be set to NET_MAX
662 assert(false);
663 } // no default case, so the compiler can warn about missing cases
664
665 assert(false);
666}
667
668std::string CNetAddr::ToString() const {
669 return ToStringIP();
670}
671
672bool operator==(const CNetAddr &a, const CNetAddr &b) {
673 return a.m_net == b.m_net && a.m_addr == b.m_addr;
674}
675
676bool operator<(const CNetAddr &a, const CNetAddr &b) {
677 return std::tie(a.m_net, a.m_addr) < std::tie(b.m_net, b.m_addr);
678}
679
690bool CNetAddr::GetInAddr(struct in_addr *pipv4Addr) const {
691 if (!IsIPv4()) {
692 return false;
693 }
694 assert(sizeof(*pipv4Addr) == m_addr.size());
695 memcpy(pipv4Addr, m_addr.data(), m_addr.size());
696 return true;
697}
698
709bool CNetAddr::GetIn6Addr(struct in6_addr *pipv6Addr) const {
710 if (!IsIPv6()) {
711 return false;
712 }
713 assert(sizeof(*pipv6Addr) == m_addr.size());
714 memcpy(pipv6Addr, m_addr.data(), m_addr.size());
715 return true;
716}
717
719 return IsRoutable() && (IsIPv4() || IsRFC6145() || IsRFC6052() ||
720 IsRFC3964() || IsRFC4380());
721}
722
723uint32_t CNetAddr::GetLinkedIPv4() const {
724 if (IsIPv4()) {
725 return ReadBE32(m_addr.data());
726 } else if (IsRFC6052() || IsRFC6145()) {
727 // mapped IPv4, SIIT translated IPv4: the IPv4 address is the last 4
728 // bytes of the address
729 return ReadBE32(Span{m_addr}.last(ADDR_IPV4_SIZE).data());
730 } else if (IsRFC3964()) {
731 // 6to4 tunneled IPv4: the IPv4 address is in bytes 2-6
732 return ReadBE32(Span{m_addr}.subspan(2, ADDR_IPV4_SIZE).data());
733 } else if (IsRFC4380()) {
734 // Teredo tunneled IPv4: the IPv4 address is in the last 4 bytes of the
735 // address, but bitflipped
736 return ~ReadBE32(Span{m_addr}.last(ADDR_IPV4_SIZE).data());
737 }
738 assert(false);
739}
740
742 // Make sure that if we return NET_IPV6, then IsIPv6() is true. The callers
743 // expect that.
744
745 // Check for "internal" first because such addresses are also !IsRoutable()
746 // and we don't want to return NET_UNROUTABLE in that case.
747 if (IsInternal()) {
748 return NET_INTERNAL;
749 }
750 if (!IsRoutable()) {
751 return NET_UNROUTABLE;
752 }
753 if (HasLinkedIPv4()) {
754 return NET_IPV4;
755 }
756 return m_net;
757}
758
759uint32_t CNetAddr::GetMappedAS(const std::vector<bool> &asmap) const {
760 uint32_t net_class = GetNetClass();
761 if (asmap.size() == 0 || (net_class != NET_IPV4 && net_class != NET_IPV6)) {
762 return 0; // Indicates not found, safe because AS0 is reserved per
763 // RFC7607.
764 }
765 std::vector<bool> ip_bits(128);
766 if (HasLinkedIPv4()) {
767 // For lookup, treat as if it was just an IPv4 address
768 // (IPV4_IN_IPV6_PREFIX + IPv4 bits)
769 for (int8_t byte_i = 0; byte_i < 12; ++byte_i) {
770 for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
771 ip_bits[byte_i * 8 + bit_i] =
772 (IPV4_IN_IPV6_PREFIX[byte_i] >> (7 - bit_i)) & 1;
773 }
774 }
775 uint32_t ipv4 = GetLinkedIPv4();
776 for (int i = 0; i < 32; ++i) {
777 ip_bits[96 + i] = (ipv4 >> (31 - i)) & 1;
778 }
779 } else {
780 // Use all 128 bits of the IPv6 address otherwise
781 assert(IsIPv6());
782 for (int8_t byte_i = 0; byte_i < 16; ++byte_i) {
783 uint8_t cur_byte = m_addr[byte_i];
784 for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
785 ip_bits[byte_i * 8 + bit_i] = (cur_byte >> (7 - bit_i)) & 1;
786 }
787 }
788 }
789 uint32_t mapped_as = Interpret(asmap, ip_bits);
790 return mapped_as;
791}
792
803std::vector<uint8_t> CNetAddr::GetGroup(const std::vector<bool> &asmap) const {
804 std::vector<uint8_t> vchRet;
805 uint32_t net_class = GetNetClass();
806 // If non-empty asmap is supplied and the address is IPv4/IPv6,
807 // return ASN to be used for bucketing.
808 uint32_t asn = GetMappedAS(asmap);
809 if (asn != 0) { // Either asmap was empty, or address has non-asmappable net
810 // class (e.g. TOR).
811 vchRet.push_back(NET_IPV6); // IPv4 and IPv6 with same ASN should be in
812 // the same bucket
813 for (int i = 0; i < 4; i++) {
814 vchRet.push_back((asn >> (8 * i)) & 0xFF);
815 }
816 return vchRet;
817 }
818
819 vchRet.push_back(net_class);
820 int nBits{0};
821
822 if (IsLocal()) {
823 // all local addresses belong to the same group
824 } else if (IsInternal()) {
825 // all internal-usage addresses get their own group
826 nBits = ADDR_INTERNAL_SIZE * 8;
827 } else if (!IsRoutable()) {
828 // all other unroutable addresses belong to the same group
829 } else if (HasLinkedIPv4()) {
830 // IPv4 addresses (and mapped IPv4 addresses) use /16 groups
831 uint32_t ipv4 = GetLinkedIPv4();
832 vchRet.push_back((ipv4 >> 24) & 0xFF);
833 vchRet.push_back((ipv4 >> 16) & 0xFF);
834 return vchRet;
835 } else if (IsTor() || IsI2P() || IsCJDNS()) {
836 nBits = 4;
837 } else if (IsHeNet()) {
838 // for he.net, use /36 groups
839 nBits = 36;
840 } else {
841 // for the rest of the IPv6 network, use /32 groups
842 nBits = 32;
843 }
844
845 // Push our address onto vchRet.
846 const size_t num_bytes = nBits / 8;
847 vchRet.insert(vchRet.end(), m_addr.begin(), m_addr.begin() + num_bytes);
848 nBits %= 8;
849 // ...for the last byte, push nBits and for the rest of the byte push 1's
850 if (nBits > 0) {
851 assert(num_bytes < m_addr.size());
852 vchRet.push_back(m_addr[num_bytes] | ((1 << (8 - nBits)) - 1));
853 }
854
855 return vchRet;
856}
857
858std::vector<uint8_t> CNetAddr::GetAddrBytes() const {
859 if (IsAddrV1Compatible()) {
860 uint8_t serialized[V1_SERIALIZATION_SIZE];
861 SerializeV1Array(serialized);
862 return {std::begin(serialized), std::end(serialized)};
863 }
864 return std::vector<uint8_t>(m_addr.begin(), m_addr.end());
865}
866
867// private extensions to enum Network, only returned by GetExtNetwork, and only
868// used in GetReachabilityFrom
869static const int NET_UNKNOWN = NET_MAX + 0;
870static const int NET_TEREDO = NET_MAX + 1;
871static int GetExtNetwork(const CNetAddr *addr) {
872 if (addr == nullptr) {
873 return NET_UNKNOWN;
874 }
875 if (addr->IsRFC4380()) {
876 return NET_TEREDO;
877 }
878 return addr->GetNetwork();
879}
880
882int CNetAddr::GetReachabilityFrom(const CNetAddr *paddrPartner) const {
883 enum Reachability {
884 REACH_UNREACHABLE,
885 REACH_DEFAULT,
886 REACH_TEREDO,
887 REACH_IPV6_WEAK,
888 REACH_IPV4,
889 REACH_IPV6_STRONG,
890 REACH_PRIVATE
891 };
892
893 if (!IsRoutable() || IsInternal()) {
894 return REACH_UNREACHABLE;
895 }
896
897 int ourNet = GetExtNetwork(this);
898 int theirNet = GetExtNetwork(paddrPartner);
899 bool fTunnel = IsRFC3964() || IsRFC6052() || IsRFC6145();
900
901 switch (theirNet) {
902 case NET_IPV4:
903 switch (ourNet) {
904 default:
905 return REACH_DEFAULT;
906 case NET_IPV4:
907 return REACH_IPV4;
908 }
909 case NET_IPV6:
910 switch (ourNet) {
911 default:
912 return REACH_DEFAULT;
913 case NET_TEREDO:
914 return REACH_TEREDO;
915 case NET_IPV4:
916 return REACH_IPV4;
917 // only prefer giving our IPv6 address if it's not tunnelled
918 case NET_IPV6:
919 return fTunnel ? REACH_IPV6_WEAK : REACH_IPV6_STRONG;
920 }
921 case NET_ONION:
922 switch (ourNet) {
923 default:
924 return REACH_DEFAULT;
925 // Tor users can connect to IPv4 as well
926 case NET_IPV4:
927 return REACH_IPV4;
928 case NET_ONION:
929 return REACH_PRIVATE;
930 }
931 case NET_I2P:
932 switch (ourNet) {
933 case NET_I2P:
934 return REACH_PRIVATE;
935 default:
936 return REACH_DEFAULT;
937 }
938 case NET_TEREDO:
939 switch (ourNet) {
940 default:
941 return REACH_DEFAULT;
942 case NET_TEREDO:
943 return REACH_TEREDO;
944 case NET_IPV6:
945 return REACH_IPV6_WEAK;
946 case NET_IPV4:
947 return REACH_IPV4;
948 }
949 case NET_UNKNOWN:
950 case NET_UNROUTABLE:
951 default:
952 switch (ourNet) {
953 default:
954 return REACH_DEFAULT;
955 case NET_TEREDO:
956 return REACH_TEREDO;
957 case NET_IPV6:
958 return REACH_IPV6_WEAK;
959 case NET_IPV4:
960 return REACH_IPV4;
961 // either from Tor, or don't care about our address
962 case NET_ONION:
963 return REACH_PRIVATE;
964 }
965 }
966}
967
968CService::CService() : port(0) {}
969
970CService::CService(const CNetAddr &cip, uint16_t portIn)
971 : CNetAddr(cip), port(portIn) {}
972
973CService::CService(const struct in_addr &ipv4Addr, uint16_t portIn)
974 : CNetAddr(ipv4Addr), port(portIn) {}
975
976CService::CService(const struct in6_addr &ipv6Addr, uint16_t portIn)
977 : CNetAddr(ipv6Addr), port(portIn) {}
978
979CService::CService(const struct sockaddr_in &addr)
980 : CNetAddr(addr.sin_addr), port(ntohs(addr.sin_port)) {
981 assert(addr.sin_family == AF_INET);
982}
983
984CService::CService(const struct sockaddr_in6 &addr)
985 : CNetAddr(addr.sin6_addr, addr.sin6_scope_id),
986 port(ntohs(addr.sin6_port)) {
987 assert(addr.sin6_family == AF_INET6);
988}
989
990bool CService::SetSockAddr(const struct sockaddr *paddr) {
991 switch (paddr->sa_family) {
992 case AF_INET:
993 *this =
994 CService(*reinterpret_cast<const struct sockaddr_in *>(paddr));
995 return true;
996 case AF_INET6:
997 *this =
998 CService(*reinterpret_cast<const struct sockaddr_in6 *>(paddr));
999 return true;
1000 default:
1001 return false;
1002 }
1003}
1004
1005uint16_t CService::GetPort() const {
1006 return port;
1007}
1008
1009bool operator==(const CService &a, const CService &b) {
1010 return static_cast<CNetAddr>(a) == static_cast<CNetAddr>(b) &&
1011 a.port == b.port;
1012}
1013
1014bool operator<(const CService &a, const CService &b) {
1015 return static_cast<CNetAddr>(a) < static_cast<CNetAddr>(b) ||
1016 (static_cast<CNetAddr>(a) == static_cast<CNetAddr>(b) &&
1017 a.port < b.port);
1018}
1019
1032bool CService::GetSockAddr(struct sockaddr *paddr, socklen_t *addrlen) const {
1033 if (IsIPv4()) {
1034 if (*addrlen < (socklen_t)sizeof(struct sockaddr_in)) {
1035 return false;
1036 }
1037 *addrlen = sizeof(struct sockaddr_in);
1038 struct sockaddr_in *paddrin =
1039 reinterpret_cast<struct sockaddr_in *>(paddr);
1040 memset(paddrin, 0, *addrlen);
1041 if (!GetInAddr(&paddrin->sin_addr)) {
1042 return false;
1043 }
1044 paddrin->sin_family = AF_INET;
1045 paddrin->sin_port = htons(port);
1046 return true;
1047 }
1048 if (IsIPv6()) {
1049 if (*addrlen < (socklen_t)sizeof(struct sockaddr_in6)) {
1050 return false;
1051 }
1052 *addrlen = sizeof(struct sockaddr_in6);
1053 struct sockaddr_in6 *paddrin6 =
1054 reinterpret_cast<struct sockaddr_in6 *>(paddr);
1055 memset(paddrin6, 0, *addrlen);
1056 if (!GetIn6Addr(&paddrin6->sin6_addr)) {
1057 return false;
1058 }
1059 paddrin6->sin6_scope_id = m_scope_id;
1060 paddrin6->sin6_family = AF_INET6;
1061 paddrin6->sin6_port = htons(port);
1062 return true;
1063 }
1064 return false;
1065}
1066
1070std::vector<uint8_t> CService::GetKey() const {
1071 auto key = GetAddrBytes();
1072 // most significant byte of our port
1073 key.push_back(port / 0x100);
1074 // least significant byte of our port
1075 key.push_back(port & 0x0FF);
1076 return key;
1077}
1078
1079std::string CService::ToStringPort() const {
1080 return strprintf("%u", port);
1081}
1082
1083std::string CService::ToStringIPPort() const {
1084 if (IsIPv4() || IsTor() || IsI2P() || IsInternal()) {
1085 return ToStringIP() + ":" + ToStringPort();
1086 } else {
1087 return "[" + ToStringIP() + "]:" + ToStringPort();
1088 }
1089}
1090
1091std::string CService::ToString() const {
1092 return ToStringIPPort();
1093}
1094
1095CSubNet::CSubNet() : valid(false) {
1096 memset(netmask, 0, sizeof(netmask));
1097}
1098
1099CSubNet::CSubNet(const CNetAddr &addr, uint8_t mask) : CSubNet() {
1100 valid = (addr.IsIPv4() && mask <= ADDR_IPV4_SIZE * 8) ||
1101 (addr.IsIPv6() && mask <= ADDR_IPV6_SIZE * 8);
1102 if (!valid) {
1103 return;
1104 }
1105
1106 assert(mask <= sizeof(netmask) * 8);
1107
1108 network = addr;
1109
1110 uint8_t n = mask;
1111 for (size_t i = 0; i < network.m_addr.size(); ++i) {
1112 const uint8_t bits = n < 8 ? n : 8;
1113 // Set first bits.
1114 netmask[i] = (uint8_t)((uint8_t)0xFF << (8 - bits));
1115 // Normalize network according to netmask.
1116 network.m_addr[i] &= netmask[i];
1117 n -= bits;
1118 }
1119}
1120
1125static inline int NetmaskBits(uint8_t x) {
1126 switch (x) {
1127 case 0x00:
1128 return 0;
1129 case 0x80:
1130 return 1;
1131 case 0xc0:
1132 return 2;
1133 case 0xe0:
1134 return 3;
1135 case 0xf0:
1136 return 4;
1137 case 0xf8:
1138 return 5;
1139 case 0xfc:
1140 return 6;
1141 case 0xfe:
1142 return 7;
1143 case 0xff:
1144 return 8;
1145 default:
1146 return -1;
1147 }
1148}
1149
1150CSubNet::CSubNet(const CNetAddr &addr, const CNetAddr &mask) : CSubNet() {
1151 valid = (addr.IsIPv4() || addr.IsIPv6()) && addr.m_net == mask.m_net;
1152 if (!valid) {
1153 return;
1154 }
1155 // Check if `mask` contains 1-bits after 0-bits (which is an invalid
1156 // netmask).
1157 bool zeros_found = false;
1158 for (auto b : mask.m_addr) {
1159 const int num_bits = NetmaskBits(b);
1160 if (num_bits == -1 || (zeros_found && num_bits != 0)) {
1161 valid = false;
1162 return;
1163 }
1164 if (num_bits < 8) {
1165 zeros_found = true;
1166 }
1167 }
1168
1169 assert(mask.m_addr.size() <= sizeof(netmask));
1170
1171 memcpy(netmask, mask.m_addr.data(), mask.m_addr.size());
1172
1173 network = addr;
1174
1175 // Normalize network according to netmask
1176 for (size_t x = 0; x < network.m_addr.size(); ++x) {
1177 network.m_addr[x] &= netmask[x];
1178 }
1179}
1180
1182 valid = addr.IsIPv4() || addr.IsIPv6();
1183 if (!valid) {
1184 return;
1185 }
1186
1187 assert(addr.m_addr.size() <= sizeof(netmask));
1188
1189 memset(netmask, 0xFF, addr.m_addr.size());
1190
1191 network = addr;
1192}
1193
1198bool CSubNet::Match(const CNetAddr &addr) const {
1199 if (!valid || !addr.IsValid() || network.m_net != addr.m_net) {
1200 return false;
1201 }
1202 assert(network.m_addr.size() == addr.m_addr.size());
1203 for (size_t x = 0; x < addr.m_addr.size(); ++x) {
1204 if ((addr.m_addr[x] & netmask[x]) != network.m_addr[x]) {
1205 return false;
1206 }
1207 }
1208 return true;
1209}
1210
1211std::string CSubNet::ToString() const {
1212 assert(network.m_addr.size() <= sizeof(netmask));
1213
1214 uint8_t cidr = 0;
1215
1216 for (size_t i = 0; i < network.m_addr.size(); ++i) {
1217 if (netmask[i] == 0x00) {
1218 break;
1219 }
1220 cidr += NetmaskBits(netmask[i]);
1221 }
1222
1223 return network.ToString() + strprintf("/%u", cidr);
1224}
1225
1226bool CSubNet::IsValid() const {
1227 return valid;
1228}
1229
1231 if (!(network.IsIPv4() || network.IsIPv6())) {
1232 return false;
1233 }
1234
1235 for (size_t x = 0; x < network.m_addr.size(); ++x) {
1236 if (network.m_addr[x] & ~netmask[x]) {
1237 return false;
1238 }
1239 }
1240
1241 return true;
1242}
1243
1244bool operator==(const CSubNet &a, const CSubNet &b) {
1245 return a.valid == b.valid && a.network == b.network &&
1246 !memcmp(a.netmask, b.netmask, 16);
1247}
1248
1249bool operator<(const CSubNet &a, const CSubNet &b) {
1250 return (a.network < b.network ||
1251 (a.network == b.network && memcmp(a.netmask, b.netmask, 16) < 0));
1252}
uint32_t Interpret(const std::vector< bool > &asmap, const std::vector< bool > &ip)
Definition: asmap.cpp:92
Network address.
Definition: netaddress.h:121
Network GetNetClass() const
Definition: netaddress.cpp:741
void SerializeV1Array(uint8_t(&arr)[V1_SERIALIZATION_SIZE]) const
Serialize in pre-ADDRv2/BIP155 format to an array.
Definition: netaddress.h:345
std::string ToStringIP() const
Definition: netaddress.cpp:623
prevector< ADDR_IPV6_SIZE, uint8_t > m_addr
Raw representation of the network address.
Definition: netaddress.h:127
bool IsBindAny() const
Definition: netaddress.cpp:329
bool IsRFC6052() const
Definition: netaddress.cpp:379
void SetIP(const CNetAddr &ip)
Definition: netaddress.cpp:122
bool SetSpecial(const std::string &addr)
Parse a Tor or I2P address and set this object to it.
Definition: netaddress.cpp:224
bool IsRFC7343() const
Definition: netaddress.cpp:414
bool GetIn6Addr(struct in6_addr *pipv6Addr) const
Try to get our IPv6 address.
Definition: netaddress.cpp:709
std::string ToString() const
Definition: netaddress.cpp:668
bool IsCJDNS() const
Check whether this object represents a CJDNS address.
Definition: netaddress.cpp:444
bool IsTor() const
Check whether this object represents a TOR address.
Definition: netaddress.cpp:430
bool IsRoutable() const
Definition: netaddress.cpp:509
bool GetInAddr(struct in_addr *pipv4Addr) const
Try to get our IPv4 address.
Definition: netaddress.cpp:690
bool HasLinkedIPv4() const
Whether this address has a linked IPv4 address (see GetLinkedIPv4()).
Definition: netaddress.cpp:718
Network m_net
Network to which this address belongs.
Definition: netaddress.h:132
bool IsRFC5737() const
Definition: netaddress.cpp:363
void SetLegacyIPv6(Span< const uint8_t > ipv6)
Set from a legacy IPv6 address.
Definition: netaddress.cpp:153
bool SetI2P(const std::string &addr)
Parse an I2P address and set this object to it.
Definition: netaddress.cpp:289
bool IsRFC6598() const
Definition: netaddress.cpp:359
bool IsRFC1918() const
Definition: netaddress.cpp:345
bool IsValid() const
Definition: netaddress.cpp:474
bool IsIPv4() const
Definition: netaddress.cpp:337
BIP155Network GetBIP155Network() const
Get the BIP155 network id of this address.
Definition: netaddress.cpp:25
uint32_t GetLinkedIPv4() const
For IPv4, mapped IPv4, SIIT translated IPv4, Teredo, 6to4 tunneled addresses, return the relevant IPv...
Definition: netaddress.cpp:723
bool SetTor(const std::string &addr)
Parse a Tor address and set this object to it.
Definition: netaddress.cpp:240
uint32_t m_scope_id
Scope id if scoped/link-local IPV6 address.
Definition: netaddress.h:138
bool IsRFC3849() const
Definition: netaddress.cpp:370
bool IsHeNet() const
Definition: netaddress.cpp:420
bool IsLocal() const
Definition: netaddress.cpp:448
static constexpr size_t V1_SERIALIZATION_SIZE
Size of CNetAddr when serialized as ADDRv1 (pre-BIP155) (in bytes).
Definition: netaddress.h:313
bool IsIPv6() const
Definition: netaddress.cpp:341
bool IsInternal() const
Definition: netaddress.cpp:521
std::vector< uint8_t > GetGroup(const std::vector< bool > &asmap) const
Get the canonical identifier of our network group.
Definition: netaddress.cpp:803
std::vector< uint8_t > GetAddrBytes() const
Definition: netaddress.cpp:858
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:56
bool SetInternal(const std::string &name)
Create an "internal" address that represents a name or FQDN.
Definition: netaddress.cpp:185
bool IsRFC4193() const
Definition: netaddress.cpp:397
uint32_t GetMappedAS(const std::vector< bool > &asmap) const
Definition: netaddress.cpp:759
int GetReachabilityFrom(const CNetAddr *paddrPartner=nullptr) const
Calculates a metric for how reachable (*this) is from a given partner.
Definition: netaddress.cpp:882
bool IsRFC2544() const
Definition: netaddress.cpp:351
enum Network GetNetwork() const
Definition: netaddress.cpp:546
bool IsRFC6145() const
Definition: netaddress.cpp:401
CNetAddr()
Construct an unspecified IPv6 network address (::/128).
Definition: netaddress.cpp:120
bool IsRFC3964() const
Definition: netaddress.cpp:375
bool IsRFC4380() const
Definition: netaddress.cpp:386
bool IsAddrV1Compatible() const
Check if the current object can be serialized in pre-ADDRv2/BIP155 format.
Definition: netaddress.cpp:525
BIP155Network
BIP155 network ids recognized by this software.
Definition: netaddress.h:301
bool IsRFC3927() const
Definition: netaddress.cpp:355
bool IsRFC4862() const
Definition: netaddress.cpp:391
bool IsRFC4843() const
Definition: netaddress.cpp:408
bool IsI2P() const
Check whether this object represents an I2P address.
Definition: netaddress.cpp:437
A hasher class for SHA-256.
Definition: sha256.h:13
CSHA256 & Write(const uint8_t *data, size_t len)
Definition: sha256.cpp:819
void Finalize(uint8_t hash[OUTPUT_SIZE])
Definition: sha256.cpp:844
A combination of a network address (CNetAddr) and a (TCP) port.
Definition: netaddress.h:545
std::string ToStringIPPort() const
std::string ToString() const
std::vector< uint8_t > GetKey() const
uint16_t GetPort() const
bool SetSockAddr(const struct sockaddr *paddr)
Definition: netaddress.cpp:990
std::string ToStringPort() const
uint16_t port
Definition: netaddress.h:548
bool GetSockAddr(struct sockaddr *paddr, socklen_t *addrlen) const
Obtain the IPv4/6 socket address this represents.
bool valid
Is this value valid? (only used to signal parse errors)
Definition: netaddress.h:502
CNetAddr network
Network (base) address.
Definition: netaddress.h:498
bool SanityCheck() const
uint8_t netmask[16]
Netmask, in network byte order.
Definition: netaddress.h:500
std::string ToString() const
bool IsValid() const
bool Match(const CNetAddr &addr) const
Definition: sha3.h:16
SHA3_256 & Finalize(Span< uint8_t > output)
Definition: sha3.cpp:232
SHA3_256 & Write(Span< const uint8_t > data)
Definition: sha3.cpp:202
static constexpr size_t OUTPUT_SIZE
Definition: sha3.h:33
constexpr std::size_t size() const noexcept
Definition: span.h:209
constexpr C * data() const noexcept
Definition: span.h:198
constexpr C * begin() const noexcept
Definition: span.h:199
constexpr C * end() const noexcept
Definition: span.h:200
Implements a drop-in replacement for std::vector<T> which stores up to N elements directly (without h...
Definition: prevector.h:38
size_type size() const
Definition: prevector.h:394
value_type * data()
Definition: prevector.h:618
iterator begin()
Definition: prevector.h:398
iterator end()
Definition: prevector.h:400
void assign(size_type n, const T &val)
Definition: prevector.h:326
static uint16_t ReadBE16(const uint8_t *ptr)
Definition: common.h:50
static uint32_t ReadBE32(const uint8_t *ptr)
Definition: common.h:56
@ I2P
Definition: logging.h:63
static const uint8_t VERSION[]
Definition: netaddress.cpp:199
static constexpr size_t CHECKSUM_LEN
Definition: netaddress.cpp:198
static void Checksum(Span< const uint8_t > addr_pubkey, uint8_t(&checksum)[CHECKSUM_LEN])
Definition: netaddress.cpp:203
static constexpr size_t TOTAL_LEN
Definition: netaddress.cpp:200
static const int NET_UNKNOWN
Definition: netaddress.cpp:869
static int GetExtNetwork(const CNetAddr *addr)
Definition: netaddress.cpp:871
static const int NET_TEREDO
Definition: netaddress.cpp:870
static int NetmaskBits(uint8_t x)
bool operator==(const CNetAddr &a, const CNetAddr &b)
Definition: netaddress.cpp:672
static std::string IPv6ToString(Span< const uint8_t > a, uint32_t scope_id)
Return an IPv6 address text representation with zero compression as described in RFC 5952 ("A Recomme...
Definition: netaddress.cpp:565
static std::string IPv4ToString(Span< const uint8_t > a)
Definition: netaddress.cpp:558
bool operator<(const CNetAddr &a, const CNetAddr &b)
Definition: netaddress.cpp:676
static constexpr size_t ADDR_CJDNS_SIZE
Size of CJDNS address (in bytes).
Definition: netaddress.h:110
static constexpr size_t ADDR_TORV3_SIZE
Size of TORv3 address (in bytes).
Definition: netaddress.h:104
static constexpr size_t ADDR_I2P_SIZE
Size of I2P address (in bytes).
Definition: netaddress.h:107
static constexpr size_t ADDR_INTERNAL_SIZE
Size of "internal" (NET_INTERNAL) address (in bytes).
Definition: netaddress.h:113
static constexpr size_t ADDR_TORV2_SIZE
Size of TORv2 address (in bytes).
Definition: netaddress.h:100
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:89
static constexpr size_t ADDR_IPV4_SIZE
Size of IPv4 address (in bytes).
Definition: netaddress.h:94
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:81
Network
A network type.
Definition: netaddress.h:44
@ NET_I2P
I2P.
Definition: netaddress.h:59
@ NET_CJDNS
CJDNS.
Definition: netaddress.h:62
@ NET_MAX
Dummy value to indicate the number of NET_* constants.
Definition: netaddress.h:69
@ NET_ONION
TOR (v2 or v3)
Definition: netaddress.h:56
@ NET_IPV6
IPv6.
Definition: netaddress.h:53
@ NET_IPV4
IPv4.
Definition: netaddress.h:50
@ NET_UNROUTABLE
Addresses from these networks are not publicly routable on the global Internet.
Definition: netaddress.h:47
@ NET_INTERNAL
A set of addresses that represent the hash of a string or FQDN.
Definition: netaddress.h:66
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:74
static constexpr size_t ADDR_IPV6_SIZE
Size of IPv6 address (in bytes).
Definition: netaddress.h:97
@ IPV4
Definition: netbase.cpp:308
@ IPV6
Definition: netbase.cpp:310
const char * prefix
Definition: rest.cpp:817
const char * name
Definition: rest.cpp:47
bool ContainsNoNUL(std::string_view str) noexcept
Check if a string does not contain any embedded NUL (\0) characters.
Definition: string.h:98
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:120
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1202
std::string EncodeBase32(Span< const uint8_t > input, bool pad)
Base32 encode.
std::string ToLower(std::string_view str)
Returns the lowercase equivalent of the given string.
std::optional< std::vector< uint8_t > > DecodeBase32(std::string_view str)
assert(!tx.IsCoinBase())