35 return BIP155Network::TORV3;
39 return BIP155Network::CJDNS;
51 switch (possible_bip155_net) {
57 throw std::ios_base::failure(
58 strprintf(
"BIP155 IPv4 address with length %u (should be %u)", address_size,
65 throw std::ios_base::failure(
66 strprintf(
"BIP155 IPv6 address with length %u (should be %u)", address_size,
68 case BIP155Network::TORV3:
73 throw std::ios_base::failure(
74 strprintf(
"BIP155 TORv3 address with length %u (should be %u)", address_size,
81 throw std::ios_base::failure(
82 strprintf(
"BIP155 I2P address with length %u (should be %u)", address_size,
84 case BIP155Network::CJDNS:
89 throw std::ios_base::failure(
90 strprintf(
"BIP155 CJDNS address with length %u (should be %u)", address_size,
110 switch (ipIn.
m_net) {
179 unsigned char hash[32] = {};
194 static const unsigned char prefix[] =
".onion checksum";
195 static constexpr
size_t prefix_len = 15;
200 hasher.
Write(addr_pubkey);
207 memcpy(checksum, checksum_full,
sizeof(checksum));
231 static const char* suffix{
".onion"};
232 static constexpr
size_t suffix_len{6};
234 if (addr.size() <= suffix_len || addr.substr(addr.size() - suffix_len) != suffix) {
239 const auto& input =
DecodeBase32(addr.substr(0, addr.size() - suffix_len).c_str(), &invalid);
257 if (input_checksum != calculated_checksum) {
262 m_addr.
assign(input_pubkey.begin(), input_pubkey.end());
272 static constexpr
size_t b32_len{52};
273 static const char* suffix{
".b32.i2p"};
274 static constexpr
size_t suffix_len{8};
276 if (addr.size() != b32_len + suffix_len ||
ToLower(addr.substr(b32_len)) != suffix) {
282 const std::string b32_padded = addr.substr(0, b32_len) +
"====";
285 const auto& address_bytes =
DecodeBase32(b32_padded.c_str(), &invalid);
292 m_addr.
assign(address_bytes.begin(), address_bytes.end());
300 const uint8_t* ptr =
reinterpret_cast<const uint8_t*
>(&ipv4Addr);
306 SetLegacyIPv6({
reinterpret_cast<const uint8_t*
>(&ipv6Addr),
sizeof(ipv6Addr)});
365 HasPrefix(
m_addr, std::array<uint8_t, 12>{0x00, 0x64, 0xFF, 0x9B, 0x00, 0x00,
366 0x00, 0x00, 0x00, 0x00, 0x00, 0x00});
377 0x00, 0x00, 0x00, 0x00});
388 HasPrefix(
m_addr, std::array<uint8_t, 12>{0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
389 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00});
395 (
m_addr[3] & 0xF0) == 0x10;
401 (
m_addr[3] & 0xF0) == 0x20;
433 static const unsigned char pchLocal[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
454 unsigned char ipNone6[16] = {};
473 if (addr == INADDR_ANY || addr == INADDR_NONE) {
537 return strprintf(
"%u.%u.%u.%u", a[0], a[1], a[2], a[3]);
545 const std::array groups{
559 size_t start_index{0};
565 ZeroSpan longest, current;
566 for (
size_t i{0}; i < groups.size(); ++i) {
567 if (groups[i] != 0) {
568 current = {i + 1, 0};
572 if (current.len > longest.len) {
579 for (
size_t i{0}; i < groups.size(); ++i) {
581 if (longest.len >= 2 && i >= longest.start_index && i < longest.start_index + longest.len) {
582 if (i == longest.start_index) {
587 r +=
strprintf(
"%s%x", ((!r.empty() && r.back() !=
':') ?
":" :
""), groups[i]);
727 if (asmap.size() == 0 || (net_class !=
NET_IPV4 && net_class !=
NET_IPV6)) {
730 std::vector<bool> ip_bits(128);
733 for (int8_t byte_i = 0; byte_i < 12; ++byte_i) {
734 for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
739 for (
int i = 0; i < 32; ++i) {
740 ip_bits[96 + i] = (ipv4 >> (31 - i)) & 1;
745 for (int8_t byte_i = 0; byte_i < 16; ++byte_i) {
746 uint8_t cur_byte =
m_addr[byte_i];
747 for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
748 ip_bits[byte_i * 8 + bit_i] = (cur_byte >> (7 - bit_i)) & 1;
752 uint32_t mapped_as =
Interpret(asmap, ip_bits);
768 std::vector<unsigned char> vchRet;
775 for (
int i = 0; i < 4; i++) {
776 vchRet.push_back((asn >> (8 * i)) & 0xFF);
781 vchRet.push_back(net_class);
794 vchRet.push_back((ipv4 >> 24) & 0xFF);
795 vchRet.push_back((ipv4 >> 16) & 0xFF);
814 const size_t num_bytes = nBits / 8;
820 vchRet.push_back(
m_addr[num_bytes] | ((1 << (8 - nBits)) - 1));
831 return {std::begin(serialized), std::end(serialized)};
840 memcpy(&nRet, &hash,
sizeof(nRet));
871 return REACH_UNREACHABLE;
880 default:
return REACH_DEFAULT;
885 default:
return REACH_DEFAULT;
888 case NET_IPV6:
return fTunnel ? REACH_IPV6_WEAK : REACH_IPV6_STRONG;
892 default:
return REACH_DEFAULT;
898 case NET_I2P:
return REACH_PRIVATE;
899 default:
return REACH_DEFAULT;
904 default:
return REACH_DEFAULT;
908 default:
return REACH_DEFAULT;
910 case NET_IPV6:
return REACH_IPV6_WEAK;
917 default:
return REACH_DEFAULT;
919 case NET_IPV6:
return REACH_IPV6_WEAK;
944 assert(addr.sin_family == AF_INET);
949 assert(addr.sin6_family == AF_INET6);
954 switch (paddr->sa_family) {
956 *
this =
CService(*(
const struct sockaddr_in*)paddr);
959 *
this =
CService(*(
const struct sockaddr_in6*)paddr);
996 if (*addrlen < (socklen_t)
sizeof(
struct sockaddr_in))
998 *addrlen =
sizeof(
struct sockaddr_in);
999 struct sockaddr_in *paddrin = (
struct sockaddr_in*)paddr;
1000 memset(paddrin, 0, *addrlen);
1003 paddrin->sin_family = AF_INET;
1004 paddrin->sin_port = htons(
port);
1008 if (*addrlen < (socklen_t)
sizeof(
struct sockaddr_in6))
1010 *addrlen =
sizeof(
struct sockaddr_in6);
1011 struct sockaddr_in6 *paddrin6 = (
struct sockaddr_in6*)paddr;
1012 memset(paddrin6, 0, *addrlen);
1016 paddrin6->sin6_family = AF_INET6;
1017 paddrin6->sin6_port = htons(
port);
1029 key.push_back(
port / 0x100);
1030 key.push_back(
port & 0x0FF);
1073 const uint8_t bits = n < 8 ? n : 8;
1074 netmask[i] = (uint8_t)((uint8_t)0xFF << (8 - bits));
1087 case 0x00:
return 0;
1088 case 0x80:
return 1;
1089 case 0xc0:
return 2;
1090 case 0xe0:
return 3;
1091 case 0xf0:
return 4;
1092 case 0xf8:
return 5;
1093 case 0xfc:
return 6;
1094 case 0xfe:
return 7;
1095 case 0xff:
return 8;
1107 bool zeros_found =
false;
1108 for (
auto b : mask.
m_addr) {
1110 if (num_bits == -1 || (zeros_found && num_bits != 0)) {
1133 switch (addr.
m_net) {
1178 for (
size_t x = 0; x < addr.
m_addr.
size(); ++x) {