LCOV - code coverage report
Current view: top level - src - netaddress.cpp (source / functions) Hit Total Coverage
Test: coverage.lcov Lines: 497 625 79.5 %
Date: 2020-06-23 11:20:36 Functions: 65 73 89.0 %
Legend: Modified by patch:
Lines: hit not hit | Branches: + taken - not taken # not executed

Not modified by patch:
Lines: hit not hit | Branches: + taken - not taken # not executed
Branches: 0 0 -

           Branch data     Line data    Source code
#       1                 :            : // Copyright (c) 2009-2010 Satoshi Nakamoto
#       2                 :            : // Copyright (c) 2009-2020 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                 :            : #include <hash.h>
#       8                 :            : #include <util/strencodings.h>
#       9                 :            : #include <util/asmap.h>
#      10                 :            : #include <tinyformat.h>
#      11                 :            : 
#      12                 :            : static const unsigned char pchIPv4[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff };
#      13                 :            : static const unsigned char pchOnionCat[] = {0xFD,0x87,0xD8,0x7E,0xEB,0x43};
#      14                 :            : 
#      15                 :            : // 0xFD + sha256("bitcoin")[0:5]
#      16                 :            : static const unsigned char g_internal_prefix[] = { 0xFD, 0x6B, 0x88, 0xC0, 0x87, 0x24 };
#      17                 :            : 
#      18                 :            : /**
#      19                 :            :  * Construct an unspecified IPv6 network address (::/128).
#      20                 :            :  *
#      21                 :            :  * @note This address is considered invalid by CNetAddr::IsValid()
#      22                 :            :  */
#      23                 :            : CNetAddr::CNetAddr()
#      24                 :     103606 : {
#      25                 :     103606 :     memset(ip, 0, sizeof(ip));
#      26                 :     103606 : }
#      27                 :            : 
#      28                 :            : void CNetAddr::SetIP(const CNetAddr& ipIn)
#      29                 :          2 : {
#      30                 :          2 :     memcpy(ip, ipIn.ip, sizeof(ip));
#      31                 :          2 : }
#      32                 :            : 
#      33                 :            : void CNetAddr::SetRaw(Network network, const uint8_t *ip_in)
#      34                 :      26574 : {
#      35                 :      26574 :     switch(network)
#      36                 :      26574 :     {
#      37                 :      26440 :         case NET_IPV4:
#      38                 :      26440 :             memcpy(ip, pchIPv4, 12);
#      39                 :      26440 :             memcpy(ip+12, ip_in, 4);
#      40                 :      26440 :             break;
#      41                 :        134 :         case NET_IPV6:
#      42                 :        134 :             memcpy(ip, ip_in, 16);
#      43                 :        134 :             break;
#      44                 :          0 :         default:
#      45                 :          0 :             assert(!"invalid network");
#      46                 :      26574 :     }
#      47                 :      26574 : }
#      48                 :            : 
#      49                 :            : /**
#      50                 :            :  * Try to make this a dummy address that maps the specified name into IPv6 like
#      51                 :            :  * so: (0xFD + %sha256("bitcoin")[0:5]) + %sha256(name)[0:10]. Such dummy
#      52                 :            :  * addresses have a prefix of fd6b:88c0:8724::/48 and are guaranteed to not be
#      53                 :            :  * publicly routable as it falls under RFC4193's fc00::/7 subnet allocated to
#      54                 :            :  * unique-local addresses.
#      55                 :            :  *
#      56                 :            :  * CAddrMan uses these fake addresses to keep track of which DNS seeds were
#      57                 :            :  * used.
#      58                 :            :  *
#      59                 :            :  * @returns Whether or not the operation was successful.
#      60                 :            :  *
#      61                 :            :  * @see CNetAddr::IsInternal(), CNetAddr::IsRFC4193()
#      62                 :            :  */
#      63                 :            : bool CNetAddr::SetInternal(const std::string &name)
#      64                 :        408 : {
#      65                 :        408 :     if (name.empty()) {
#      66                 :          0 :         return false;
#      67                 :          0 :     }
#      68                 :        408 :     unsigned char hash[32] = {};
#      69                 :        408 :     CSHA256().Write((const unsigned char*)name.data(), name.size()).Finalize(hash);
#      70                 :        408 :     memcpy(ip, g_internal_prefix, sizeof(g_internal_prefix));
#      71                 :        408 :     memcpy(ip + sizeof(g_internal_prefix), hash, sizeof(ip) - sizeof(g_internal_prefix));
#      72                 :        408 :     return true;
#      73                 :        408 : }
#      74                 :            : 
#      75                 :            : /**
#      76                 :            :  * Try to make this a dummy address that maps the specified onion address into
#      77                 :            :  * IPv6 using OnionCat's range and encoding. Such dummy addresses have a prefix
#      78                 :            :  * of fd87:d87e:eb43::/48 and are guaranteed to not be publicly routable as they
#      79                 :            :  * fall under RFC4193's fc00::/7 subnet allocated to unique-local addresses.
#      80                 :            :  *
#      81                 :            :  * @returns Whether or not the operation was successful.
#      82                 :            :  *
#      83                 :            :  * @see CNetAddr::IsTor(), CNetAddr::IsRFC4193()
#      84                 :            :  */
#      85                 :            : bool CNetAddr::SetSpecial(const std::string &strName)
#      86                 :      26552 : {
#      87                 :      26552 :     if (strName.size()>6 && strName.substr(strName.size() - 6, 6) == ".onion") {
#      88                 :          4 :         std::vector<unsigned char> vchAddr = DecodeBase32(strName.substr(0, strName.size() - 6).c_str());
#      89                 :          4 :         if (vchAddr.size() != 16-sizeof(pchOnionCat))
#      90                 :          0 :             return false;
#      91                 :          4 :         memcpy(ip, pchOnionCat, sizeof(pchOnionCat));
#      92                 :         44 :         for (unsigned int i=0; i<16-sizeof(pchOnionCat); i++)
#      93                 :         40 :             ip[i + sizeof(pchOnionCat)] = vchAddr[i];
#      94                 :          4 :         return true;
#      95                 :          4 :     }
#      96                 :      26548 :     return false;
#      97                 :      26548 : }
#      98                 :            : 
#      99                 :            : CNetAddr::CNetAddr(const struct in_addr& ipv4Addr)
#     100                 :      26440 : {
#     101                 :      26440 :     SetRaw(NET_IPV4, (const uint8_t*)&ipv4Addr);
#     102                 :      26440 : }
#     103                 :            : 
#     104                 :            : CNetAddr::CNetAddr(const struct in6_addr& ipv6Addr, const uint32_t scope)
#     105                 :        134 : {
#     106                 :        134 :     SetRaw(NET_IPV6, (const uint8_t*)&ipv6Addr);
#     107                 :        134 :     scopeId = scope;
#     108                 :        134 : }
#     109                 :            : 
#     110                 :            : unsigned int CNetAddr::GetByte(int n) const
#     111                 :    2994944 : {
#     112                 :    2994944 :     return ip[15-n];
#     113                 :    2994944 : }
#     114                 :            : 
#     115                 :            : bool CNetAddr::IsBindAny() const
#     116                 :          0 : {
#     117                 :          0 :     const int cmplen = IsIPv4() ? 4 : 16;
#     118                 :          0 :     for (int i = 0; i < cmplen; ++i) {
#     119                 :          0 :         if (GetByte(i)) return false;
#     120                 :          0 :     }
#     121                 :          0 : 
#     122                 :          0 :     return true;
#     123                 :          0 : }
#     124                 :            : 
#     125                 :            : bool CNetAddr::IsIPv4() const
#     126                 :    1588448 : {
#     127                 :    1588448 :     return (memcmp(ip, pchIPv4, sizeof(pchIPv4)) == 0);
#     128                 :    1588448 : }
#     129                 :            : 
#     130                 :            : bool CNetAddr::IsIPv6() const
#     131                 :        542 : {
#     132                 :        542 :     return (!IsIPv4() && !IsTor() && !IsInternal());
#     133                 :        542 : }
#     134                 :            : 
#     135                 :            : bool CNetAddr::IsRFC1918() const
#     136                 :     188154 : {
#     137                 :     188154 :     return IsIPv4() && (
#     138                 :     188054 :         GetByte(3) == 10 ||
#     139                 :     188054 :         (GetByte(3) == 192 && GetByte(2) == 168) ||
#     140                 :     188054 :         (GetByte(3) == 172 && (GetByte(2) >= 16 && GetByte(2) <= 31)));
#     141                 :     188154 : }
#     142                 :            : 
#     143                 :            : bool CNetAddr::IsRFC2544() const
#     144                 :     188130 : {
#     145                 :     188130 :     return IsIPv4() && GetByte(3) == 198 && (GetByte(2) == 18 || GetByte(2) == 19);
#     146                 :     188130 : }
#     147                 :            : 
#     148                 :            : bool CNetAddr::IsRFC3927() const
#     149                 :     188128 : {
#     150                 :     188128 :     return IsIPv4() && (GetByte(3) == 169 && GetByte(2) == 254);
#     151                 :     188128 : }
#     152                 :            : 
#     153                 :            : bool CNetAddr::IsRFC6598() const
#     154                 :     188120 : {
#     155                 :     188120 :     return IsIPv4() && GetByte(3) == 100 && GetByte(2) >= 64 && GetByte(2) <= 127;
#     156                 :     188120 : }
#     157                 :            : 
#     158                 :            : bool CNetAddr::IsRFC5737() const
#     159                 :     188120 : {
#     160                 :     188120 :     return IsIPv4() && ((GetByte(3) == 192 && GetByte(2) == 0 && GetByte(1) == 2) ||
#     161                 :     188020 :         (GetByte(3) == 198 && GetByte(2) == 51 && GetByte(1) == 100) ||
#     162                 :     188020 :         (GetByte(3) == 203 && GetByte(2) == 0 && GetByte(1) == 113));
#     163                 :     188120 : }
#     164                 :            : 
#     165                 :            : bool CNetAddr::IsRFC3849() const
#     166                 :     188298 : {
#     167                 :     188298 :     return GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0x0D && GetByte(12) == 0xB8;
#     168                 :     188298 : }
#     169                 :            : 
#     170                 :            : bool CNetAddr::IsRFC3964() const
#     171                 :         36 : {
#     172                 :         36 :     return (GetByte(15) == 0x20 && GetByte(14) == 0x02);
#     173                 :         36 : }
#     174                 :            : 
#     175                 :            : bool CNetAddr::IsRFC6052() const
#     176                 :         44 : {
#     177                 :         44 :     static const unsigned char pchRFC6052[] = {0,0x64,0xFF,0x9B,0,0,0,0,0,0,0,0};
#     178                 :         44 :     return (memcmp(ip, pchRFC6052, sizeof(pchRFC6052)) == 0);
#     179                 :         44 : }
#     180                 :            : 
#     181                 :            : bool CNetAddr::IsRFC4380() const
#     182                 :         28 : {
#     183                 :         28 :     return (GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0 && GetByte(12) == 0);
#     184                 :         28 : }
#     185                 :            : 
#     186                 :            : bool CNetAddr::IsRFC4862() const
#     187                 :     188122 : {
#     188                 :     188122 :     static const unsigned char pchRFC4862[] = {0xFE,0x80,0,0,0,0,0,0};
#     189                 :     188122 :     return (memcmp(ip, pchRFC4862, sizeof(pchRFC4862)) == 0);
#     190                 :     188122 : }
#     191                 :            : 
#     192                 :            : bool CNetAddr::IsRFC4193() const
#     193                 :     188122 : {
#     194                 :     188122 :     return ((GetByte(15) & 0xFE) == 0xFC);
#     195                 :     188122 : }
#     196                 :            : 
#     197                 :            : bool CNetAddr::IsRFC6145() const
#     198                 :         50 : {
#     199                 :         50 :     static const unsigned char pchRFC6145[] = {0,0,0,0,0,0,0,0,0xFF,0xFF,0,0};
#     200                 :         50 :     return (memcmp(ip, pchRFC6145, sizeof(pchRFC6145)) == 0);
#     201                 :         50 : }
#     202                 :            : 
#     203                 :            : bool CNetAddr::IsRFC4843() const
#     204                 :     188122 : {
#     205                 :     188122 :     return (GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0x00 && (GetByte(12) & 0xF0) == 0x10);
#     206                 :     188122 : }
#     207                 :            : 
#     208                 :            : bool CNetAddr::IsRFC7343() const
#     209                 :     188122 : {
#     210                 :     188122 :     return (GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0x00 && (GetByte(12) & 0xF0) == 0x20);
#     211                 :     188122 : }
#     212                 :            : 
#     213                 :            : bool CNetAddr::IsHeNet() const
#     214                 :          4 : {
#     215                 :          4 :     return (GetByte(15) == 0x20 && GetByte(14) == 0x01 && GetByte(13) == 0x04 && GetByte(12) == 0x70);
#     216                 :          4 : }
#     217                 :            : 
#     218                 :            : /**
#     219                 :            :  * @returns Whether or not this is a dummy address that maps an onion address
#     220                 :            :  *          into IPv6.
#     221                 :            :  *
#     222                 :            :  * @see CNetAddr::SetSpecial(const std::string &)
#     223                 :            :  */
#     224                 :            : bool CNetAddr::IsTor() const
#     225                 :      25848 : {
#     226                 :      25848 :     return (memcmp(ip, pchOnionCat, sizeof(pchOnionCat)) == 0);
#     227                 :      25848 : }
#     228                 :            : 
#     229                 :            : bool CNetAddr::IsLocal() const
#     230                 :     273580 : {
#     231                 :     273580 :     // IPv4 loopback (127.0.0.0/8 or 0.0.0.0/8)
#     232                 :     273580 :     if (IsIPv4() && (GetByte(3) == 127 || GetByte(3) == 0))
#     233                 :         48 :         return true;
#     234                 :     273532 : 
#     235                 :     273532 :     // IPv6 loopback (::1/128)
#     236                 :     273532 :     static const unsigned char pchLocal[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
#     237                 :     273532 :     if (memcmp(ip, pchLocal, 16) == 0)
#     238                 :          4 :         return true;
#     239                 :     273528 : 
#     240                 :     273528 :     return false;
#     241                 :     273528 : }
#     242                 :            : 
#     243                 :            : /**
#     244                 :            :  * @returns Whether or not this network address is a valid address that @a could
#     245                 :            :  *          be used to refer to an actual host.
#     246                 :            :  *
#     247                 :            :  * @note A valid address may or may not be publicly routable on the global
#     248                 :            :  *       internet. As in, the set of valid addresses is a superset of the set of
#     249                 :            :  *       publicly routable addresses.
#     250                 :            :  *
#     251                 :            :  * @see CNetAddr::IsRoutable()
#     252                 :            :  */
#     253                 :            : bool CNetAddr::IsValid() const
#     254                 :     188392 : {
#     255                 :     188392 :     // Cleanup 3-byte shifted addresses caused by garbage in size field
#     256                 :     188392 :     // of addr messages from versions before 0.2.9 checksum.
#     257                 :     188392 :     // Two consecutive addr messages look like this:
#     258                 :     188392 :     // header20 vectorlen3 addr26 addr26 addr26 header20 vectorlen3 addr26 addr26 addr26...
#     259                 :     188392 :     // so if the first length field is garbled, it reads the second batch
#     260                 :     188392 :     // of addr misaligned by 3 bytes.
#     261                 :     188392 :     if (memcmp(ip, pchIPv4+3, sizeof(pchIPv4)-3) == 0)
#     262                 :          0 :         return false;
#     263                 :     188392 : 
#     264                 :     188392 :     // unspecified IPv6 address (::/128)
#     265                 :     188392 :     unsigned char ipNone6[16] = {};
#     266                 :     188392 :     if (memcmp(ip, ipNone6, 16) == 0)
#     267                 :         96 :         return false;
#     268                 :     188296 : 
#     269                 :     188296 :     // documentation IPv6 address
#     270                 :     188296 :     if (IsRFC3849())
#     271                 :          0 :         return false;
#     272                 :     188296 : 
#     273                 :     188296 :     if (IsInternal())
#     274                 :          0 :         return false;
#     275                 :     188296 : 
#     276                 :     188296 :     if (IsIPv4())
#     277                 :     188160 :     {
#     278                 :     188160 :         // INADDR_NONE
#     279                 :     188160 :         uint32_t ipNone = INADDR_NONE;
#     280                 :     188160 :         if (memcmp(ip+12, &ipNone, 4) == 0)
#     281                 :          0 :             return false;
#     282                 :     188160 : 
#     283                 :     188160 :         // 0
#     284                 :     188160 :         ipNone = 0;
#     285                 :     188160 :         if (memcmp(ip+12, &ipNone, 4) == 0)
#     286                 :          2 :             return false;
#     287                 :     188294 :     }
#     288                 :     188294 : 
#     289                 :     188294 :     return true;
#     290                 :     188294 : }
#     291                 :            : 
#     292                 :            : /**
#     293                 :            :  * @returns Whether or not this network address is publicly routable on the
#     294                 :            :  *          global internet.
#     295                 :            :  *
#     296                 :            :  * @note A routable address is always valid. As in, the set of routable addresses
#     297                 :            :  *       is a subset of the set of valid addresses.
#     298                 :            :  *
#     299                 :            :  * @see CNetAddr::IsValid()
#     300                 :            :  */
#     301                 :            : bool CNetAddr::IsRoutable() const
#     302                 :     188202 : {
#     303                 :     188202 :     return IsValid() && !(IsRFC1918() || IsRFC2544() || IsRFC3927() || IsRFC4862() || IsRFC6598() || IsRFC5737() || (IsRFC4193() && !IsTor()) || IsRFC4843() || IsRFC7343() || IsLocal() || IsInternal());
#     304                 :     188202 : }
#     305                 :            : 
#     306                 :            : /**
#     307                 :            :  * @returns Whether or not this is a dummy address that maps a name into IPv6.
#     308                 :            :  *
#     309                 :            :  * @see CNetAddr::SetInternal(const std::string &)
#     310                 :            :  */
#     311                 :            : bool CNetAddr::IsInternal() const
#     312                 :     514178 : {
#     313                 :     514178 :    return memcmp(ip, g_internal_prefix, sizeof(g_internal_prefix)) == 0;
#     314                 :     514178 : }
#     315                 :            : 
#     316                 :            : enum Network CNetAddr::GetNetwork() const
#     317                 :         20 : {
#     318                 :         20 :     if (IsInternal())
#     319                 :          2 :         return NET_INTERNAL;
#     320                 :         18 : 
#     321                 :         18 :     if (!IsRoutable())
#     322                 :          4 :         return NET_UNROUTABLE;
#     323                 :         14 : 
#     324                 :         14 :     if (IsIPv4())
#     325                 :          8 :         return NET_IPV4;
#     326                 :          6 : 
#     327                 :          6 :     if (IsTor())
#     328                 :          2 :         return NET_ONION;
#     329                 :          4 : 
#     330                 :          4 :     return NET_IPV6;
#     331                 :          4 : }
#     332                 :            : 
#     333                 :            : std::string CNetAddr::ToStringIP() const
#     334                 :      25016 : {
#     335                 :      25016 :     if (IsTor())
#     336                 :          2 :         return EncodeBase32(&ip[6], 10) + ".onion";
#     337                 :      25014 :     if (IsInternal())
#     338                 :          0 :         return EncodeBase32(ip + sizeof(g_internal_prefix), sizeof(ip) - sizeof(g_internal_prefix)) + ".internal";
#     339                 :      25014 :     CService serv(*this, 0);
#     340                 :      25014 :     struct sockaddr_storage sockaddr;
#     341                 :      25014 :     socklen_t socklen = sizeof(sockaddr);
#     342                 :      25014 :     if (serv.GetSockAddr((struct sockaddr*)&sockaddr, &socklen)) {
#     343                 :      25014 :         char name[1025] = "";
#     344                 :      25014 :         if (!getnameinfo((const struct sockaddr*)&sockaddr, socklen, name, sizeof(name), nullptr, 0, NI_NUMERICHOST))
#     345                 :      25014 :             return std::string(name);
#     346                 :          0 :     }
#     347                 :          0 :     if (IsIPv4())
#     348                 :          0 :         return strprintf("%u.%u.%u.%u", GetByte(3), GetByte(2), GetByte(1), GetByte(0));
#     349                 :          0 :     else
#     350                 :          0 :         return strprintf("%x:%x:%x:%x:%x:%x:%x:%x",
#     351                 :          0 :                          GetByte(15) << 8 | GetByte(14), GetByte(13) << 8 | GetByte(12),
#     352                 :          0 :                          GetByte(11) << 8 | GetByte(10), GetByte(9) << 8 | GetByte(8),
#     353                 :          0 :                          GetByte(7) << 8 | GetByte(6), GetByte(5) << 8 | GetByte(4),
#     354                 :          0 :                          GetByte(3) << 8 | GetByte(2), GetByte(1) << 8 | GetByte(0));
#     355                 :          0 : }
#     356                 :            : 
#     357                 :            : std::string CNetAddr::ToString() const
#     358                 :       4568 : {
#     359                 :       4568 :     return ToStringIP();
#     360                 :       4568 : }
#     361                 :            : 
#     362                 :            : bool operator==(const CNetAddr& a, const CNetAddr& b)
#     363                 :       5506 : {
#     364                 :       5506 :     return (memcmp(a.ip, b.ip, 16) == 0);
#     365                 :       5506 : }
#     366                 :            : 
#     367                 :            : bool operator<(const CNetAddr& a, const CNetAddr& b)
#     368                 :     138194 : {
#     369                 :     138194 :     return (memcmp(a.ip, b.ip, 16) < 0);
#     370                 :     138194 : }
#     371                 :            : 
#     372                 :            : /**
#     373                 :            :  * Try to get our IPv4 address.
#     374                 :            :  *
#     375                 :            :  * @param[out] pipv4Addr The in_addr struct to which to copy.
#     376                 :            :  *
#     377                 :            :  * @returns Whether or not the operation was successful, in particular, whether
#     378                 :            :  *          or not our address was an IPv4 address.
#     379                 :            :  *
#     380                 :            :  * @see CNetAddr::IsIPv4()
#     381                 :            :  */
#     382                 :            : bool CNetAddr::GetInAddr(struct in_addr* pipv4Addr) const
#     383                 :      24744 : {
#     384                 :      24744 :     if (!IsIPv4())
#     385                 :          0 :         return false;
#     386                 :      24744 :     memcpy(pipv4Addr, ip+12, 4);
#     387                 :      24744 :     return true;
#     388                 :      24744 : }
#     389                 :            : 
#     390                 :            : /**
#     391                 :            :  * Try to get our IPv6 address.
#     392                 :            :  *
#     393                 :            :  * @param[out] pipv6Addr The in6_addr struct to which to copy.
#     394                 :            :  *
#     395                 :            :  * @returns Whether or not the operation was successful, in particular, whether
#     396                 :            :  *          or not our address was an IPv6 address.
#     397                 :            :  *
#     398                 :            :  * @see CNetAddr::IsIPv6()
#     399                 :            :  */
#     400                 :            : bool CNetAddr::GetIn6Addr(struct in6_addr* pipv6Addr) const
#     401                 :        270 : {
#     402                 :        270 :     if (!IsIPv6()) {
#     403                 :          0 :         return false;
#     404                 :          0 :     }
#     405                 :        270 :     memcpy(pipv6Addr, ip, 16);
#     406                 :        270 :     return true;
#     407                 :        270 : }
#     408                 :            : 
#     409                 :            : bool CNetAddr::HasLinkedIPv4() const
#     410                 :      98192 : {
#     411                 :      98192 :     return IsRoutable() && (IsIPv4() || IsRFC6145() || IsRFC6052() || IsRFC3964() || IsRFC4380());
#     412                 :      98192 : }
#     413                 :            : 
#     414                 :            : uint32_t CNetAddr::GetLinkedIPv4() const
#     415                 :      31504 : {
#     416                 :      31504 :     if (IsIPv4() || IsRFC6145() || IsRFC6052()) {
#     417                 :      31500 :         // IPv4, mapped IPv4, SIIT translated IPv4: the IPv4 address is the last 4 bytes of the address
#     418                 :      31500 :         return ReadBE32(ip + 12);
#     419                 :      31500 :     } else if (IsRFC3964()) {
#     420                 :          2 :         // 6to4 tunneled IPv4: the IPv4 address is in bytes 2-6
#     421                 :          2 :         return ReadBE32(ip + 2);
#     422                 :          2 :     } else if (IsRFC4380()) {
#     423                 :          2 :         // Teredo tunneled IPv4: the IPv4 address is in the last 4 bytes of the address, but bitflipped
#     424                 :          2 :         return ~ReadBE32(ip + 12);
#     425                 :          2 :     }
#     426                 :          0 :     assert(false);
#     427                 :          0 : }
#     428                 :            : 
#     429                 :      66734 : uint32_t CNetAddr::GetNetClass() const {
#     430                 :      66734 :     uint32_t net_class = NET_IPV6;
#     431                 :      66734 :     if (IsLocal()) {
#     432                 :          4 :         net_class = 255;
#     433                 :          4 :     }
#     434                 :      66734 :     if (IsInternal()) {
#     435                 :          4 :         net_class = NET_INTERNAL;
#     436                 :      66730 :     } else if (!IsRoutable()) {
#     437                 :         48 :         net_class = NET_UNROUTABLE;
#     438                 :      66682 :     } else if (HasLinkedIPv4()) {
#     439                 :      66670 :         net_class = NET_IPV4;
#     440                 :      66670 :     } else if (IsTor()) {
#     441                 :          4 :         net_class = NET_ONION;
#     442                 :          4 :     }
#     443                 :      66734 :     return net_class;
#     444                 :      66734 : }
#     445                 :            : 
#     446                 :      40774 : uint32_t CNetAddr::GetMappedAS(const std::vector<bool> &asmap) const {
#     447                 :      40774 :     uint32_t net_class = GetNetClass();
#     448                 :      40774 :     if (asmap.size() == 0 || (net_class != NET_IPV4 && net_class != NET_IPV6)) {
#     449                 :      27952 :         return 0; // Indicates not found, safe because AS0 is reserved per RFC7607.
#     450                 :      27952 :     }
#     451                 :      12822 :     std::vector<bool> ip_bits(128);
#     452                 :      12822 :     if (HasLinkedIPv4()) {
#     453                 :      12822 :         // For lookup, treat as if it was just an IPv4 address (pchIPv4 prefix + IPv4 bits)
#     454                 :     166686 :         for (int8_t byte_i = 0; byte_i < 12; ++byte_i) {
#     455                 :    1384776 :             for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
#     456                 :    1230912 :                 ip_bits[byte_i * 8 + bit_i] = (pchIPv4[byte_i] >> (7 - bit_i)) & 1;
#     457                 :    1230912 :             }
#     458                 :     153864 :         }
#     459                 :      12822 :         uint32_t ipv4 = GetLinkedIPv4();
#     460                 :     423126 :         for (int i = 0; i < 32; ++i) {
#     461                 :     410304 :             ip_bits[96 + i] = (ipv4 >> (31 - i)) & 1;
#     462                 :     410304 :         }
#     463                 :      12822 :     } else {
#     464                 :          0 :         // Use all 128 bits of the IPv6 address otherwise
#     465                 :          0 :         for (int8_t byte_i = 0; byte_i < 16; ++byte_i) {
#     466                 :          0 :             uint8_t cur_byte = GetByte(15 - byte_i);
#     467                 :          0 :             for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
#     468                 :          0 :                 ip_bits[byte_i * 8 + bit_i] = (cur_byte >> (7 - bit_i)) & 1;
#     469                 :          0 :             }
#     470                 :          0 :         }
#     471                 :          0 :     }
#     472                 :      12822 :     uint32_t mapped_as = Interpret(asmap, ip_bits);
#     473                 :      12822 :     return mapped_as;
#     474                 :      12822 : }
#     475                 :            : 
#     476                 :            : /**
#     477                 :            :  * Get the canonical identifier of our network group
#     478                 :            :  *
#     479                 :            :  * The groups are assigned in a way where it should be costly for an attacker to
#     480                 :            :  * obtain addresses with many different group identifiers, even if it is cheap
#     481                 :            :  * to obtain addresses with the same identifier.
#     482                 :            :  *
#     483                 :            :  * @note No two connections will be attempted to addresses with the same network
#     484                 :            :  *       group.
#     485                 :            :  */
#     486                 :            : std::vector<unsigned char> CNetAddr::GetGroup(const std::vector<bool> &asmap) const
#     487                 :      25960 : {
#     488                 :      25960 :     std::vector<unsigned char> vchRet;
#     489                 :      25960 :     uint32_t net_class = GetNetClass();
#     490                 :      25960 :     // If non-empty asmap is supplied and the address is IPv4/IPv6,
#     491                 :      25960 :     // return ASN to be used for bucketing.
#     492                 :      25960 :     uint32_t asn = GetMappedAS(asmap);
#     493                 :      25960 :     if (asn != 0) { // Either asmap was empty, or address has non-asmappable net class (e.g. TOR).
#     494                 :       7246 :         vchRet.push_back(NET_IPV6); // IPv4 and IPv6 with same ASN should be in the same bucket
#     495                 :      36230 :         for (int i = 0; i < 4; i++) {
#     496                 :      28984 :             vchRet.push_back((asn >> (8 * i)) & 0xFF);
#     497                 :      28984 :         }
#     498                 :       7246 :         return vchRet;
#     499                 :       7246 :     }
#     500                 :      18714 : 
#     501                 :      18714 :     vchRet.push_back(net_class);
#     502                 :      18714 :     int nStartByte = 0;
#     503                 :      18714 :     int nBits = 16;
#     504                 :      18714 : 
#     505                 :      18714 :     if (IsLocal()) {
#     506                 :          2 :         // all local addresses belong to the same group
#     507                 :          2 :         nBits = 0;
#     508                 :      18712 :     } else if (IsInternal()) {
#     509                 :          2 :         // all internal-usage addresses get their own group
#     510                 :          2 :         nStartByte = sizeof(g_internal_prefix);
#     511                 :          2 :         nBits = (sizeof(ip) - sizeof(g_internal_prefix)) * 8;
#     512                 :      18710 :     } else if (!IsRoutable()) {
#     513                 :         22 :         // all other unroutable addresses belong to the same group
#     514                 :         22 :         nBits = 0;
#     515                 :      18688 :     } else if (HasLinkedIPv4()) {
#     516                 :      18682 :         // IPv4 addresses (and mapped IPv4 addresses) use /16 groups
#     517                 :      18682 :         uint32_t ipv4 = GetLinkedIPv4();
#     518                 :      18682 :         vchRet.push_back((ipv4 >> 24) & 0xFF);
#     519                 :      18682 :         vchRet.push_back((ipv4 >> 16) & 0xFF);
#     520                 :      18682 :         return vchRet;
#     521                 :      18682 :     } else if (IsTor()) {
#     522                 :          2 :         nStartByte = 6;
#     523                 :          2 :         nBits = 4;
#     524                 :          4 :     } else if (IsHeNet()) {
#     525                 :          2 :         // for he.net, use /36 groups
#     526                 :          2 :         nBits = 36;
#     527                 :          2 :     } else {
#     528                 :          2 :         // for the rest of the IPv6 network, use /32 groups
#     529                 :          2 :         nBits = 32;
#     530                 :          2 :     }
#     531                 :      18714 : 
#     532                 :      18714 :     // push our ip onto vchRet byte by byte...
#     533                 :      18714 :     while (nBits >= 8)
#     534                 :         36 :     {
#     535                 :         36 :         vchRet.push_back(GetByte(15 - nStartByte));
#     536                 :         36 :         nStartByte++;
#     537                 :         36 :         nBits -= 8;
#     538                 :         36 :     }
#     539                 :         32 :     // ...for the last byte, push nBits and for the rest of the byte push 1's
#     540                 :         32 :     if (nBits > 0)
#     541                 :          4 :         vchRet.push_back(GetByte(15 - nStartByte) | ((1 << (8 - nBits)) - 1));
#     542                 :         32 : 
#     543                 :         32 :     return vchRet;
#     544                 :      18714 : }
#     545                 :            : 
#     546                 :            : uint64_t CNetAddr::GetHash() const
#     547                 :          0 : {
#     548                 :          0 :     uint256 hash = Hash(&ip[0], &ip[16]);
#     549                 :          0 :     uint64_t nRet;
#     550                 :          0 :     memcpy(&nRet, &hash, sizeof(nRet));
#     551                 :          0 :     return nRet;
#     552                 :          0 : }
#     553                 :            : 
#     554                 :            : std::vector<unsigned char> CNetAddr::GetAddrKey() const
#     555                 :    1255116 : {
#     556                 :    1255116 :     return std::vector<unsigned char>(ip, ip + sizeof(ip));
#     557                 :    1255116 : }
#     558                 :            : 
#     559                 :            : // private extensions to enum Network, only returned by GetExtNetwork,
#     560                 :            : // and only used in GetReachabilityFrom
#     561                 :            : static const int NET_UNKNOWN = NET_MAX + 0;
#     562                 :            : static const int NET_TEREDO  = NET_MAX + 1;
#     563                 :            : int static GetExtNetwork(const CNetAddr *addr)
#     564                 :          0 : {
#     565                 :          0 :     if (addr == nullptr)
#     566                 :          0 :         return NET_UNKNOWN;
#     567                 :          0 :     if (addr->IsRFC4380())
#     568                 :          0 :         return NET_TEREDO;
#     569                 :          0 :     return addr->GetNetwork();
#     570                 :          0 : }
#     571                 :            : 
#     572                 :            : /** Calculates a metric for how reachable (*this) is from a given partner */
#     573                 :            : int CNetAddr::GetReachabilityFrom(const CNetAddr *paddrPartner) const
#     574                 :          2 : {
#     575                 :          2 :     enum Reachability {
#     576                 :          2 :         REACH_UNREACHABLE,
#     577                 :          2 :         REACH_DEFAULT,
#     578                 :          2 :         REACH_TEREDO,
#     579                 :          2 :         REACH_IPV6_WEAK,
#     580                 :          2 :         REACH_IPV4,
#     581                 :          2 :         REACH_IPV6_STRONG,
#     582                 :          2 :         REACH_PRIVATE
#     583                 :          2 :     };
#     584                 :          2 : 
#     585                 :          2 :     if (!IsRoutable() || IsInternal())
#     586                 :          2 :         return REACH_UNREACHABLE;
#     587                 :          0 : 
#     588                 :          0 :     int ourNet = GetExtNetwork(this);
#     589                 :          0 :     int theirNet = GetExtNetwork(paddrPartner);
#     590                 :          0 :     bool fTunnel = IsRFC3964() || IsRFC6052() || IsRFC6145();
#     591                 :          0 : 
#     592                 :          0 :     switch(theirNet) {
#     593                 :          0 :     case NET_IPV4:
#     594                 :          0 :         switch(ourNet) {
#     595                 :          0 :         default:       return REACH_DEFAULT;
#     596                 :          0 :         case NET_IPV4: return REACH_IPV4;
#     597                 :          0 :         }
#     598                 :          0 :     case NET_IPV6:
#     599                 :          0 :         switch(ourNet) {
#     600                 :          0 :         default:         return REACH_DEFAULT;
#     601                 :          0 :         case NET_TEREDO: return REACH_TEREDO;
#     602                 :          0 :         case NET_IPV4:   return REACH_IPV4;
#     603                 :          0 :         case NET_IPV6:   return fTunnel ? REACH_IPV6_WEAK : REACH_IPV6_STRONG; // only prefer giving our IPv6 address if it's not tunnelled
#     604                 :          0 :         }
#     605                 :          0 :     case NET_ONION:
#     606                 :          0 :         switch(ourNet) {
#     607                 :          0 :         default:         return REACH_DEFAULT;
#     608                 :          0 :         case NET_IPV4:   return REACH_IPV4; // Tor users can connect to IPv4 as well
#     609                 :          0 :         case NET_ONION:    return REACH_PRIVATE;
#     610                 :          0 :         }
#     611                 :          0 :     case NET_TEREDO:
#     612                 :          0 :         switch(ourNet) {
#     613                 :          0 :         default:          return REACH_DEFAULT;
#     614                 :          0 :         case NET_TEREDO:  return REACH_TEREDO;
#     615                 :          0 :         case NET_IPV6:    return REACH_IPV6_WEAK;
#     616                 :          0 :         case NET_IPV4:    return REACH_IPV4;
#     617                 :          0 :         }
#     618                 :          0 :     case NET_UNKNOWN:
#     619                 :          0 :     case NET_UNROUTABLE:
#     620                 :          0 :     default:
#     621                 :          0 :         switch(ourNet) {
#     622                 :          0 :         default:          return REACH_DEFAULT;
#     623                 :          0 :         case NET_TEREDO:  return REACH_TEREDO;
#     624                 :          0 :         case NET_IPV6:    return REACH_IPV6_WEAK;
#     625                 :          0 :         case NET_IPV4:    return REACH_IPV4;
#     626                 :          0 :         case NET_ONION:     return REACH_PRIVATE; // either from Tor, or don't care about our address
#     627                 :          0 :         }
#     628                 :          0 :     }
#     629                 :          0 : }
#     630                 :            : 
#     631                 :            : CService::CService() : port(0)
#     632                 :      31710 : {
#     633                 :      31710 : }
#     634                 :            : 
#     635                 :            : CService::CService(const CNetAddr& cip, unsigned short portIn) : CNetAddr(cip), port(portIn)
#     636                 :      38350 : {
#     637                 :      38350 : }
#     638                 :            : 
#     639                 :            : CService::CService(const struct in_addr& ipv4Addr, unsigned short portIn) : CNetAddr(ipv4Addr), port(portIn)
#     640                 :          4 : {
#     641                 :          4 : }
#     642                 :            : 
#     643                 :            : CService::CService(const struct in6_addr& ipv6Addr, unsigned short portIn) : CNetAddr(ipv6Addr), port(portIn)
#     644                 :          2 : {
#     645                 :          2 : }
#     646                 :            : 
#     647                 :            : CService::CService(const struct sockaddr_in& addr) : CNetAddr(addr.sin_addr), port(ntohs(addr.sin_port))
#     648                 :          0 : {
#     649                 :          0 :     assert(addr.sin_family == AF_INET);
#     650                 :          0 : }
#     651                 :            : 
#     652                 :            : CService::CService(const struct sockaddr_in6 &addr) : CNetAddr(addr.sin6_addr, addr.sin6_scope_id), port(ntohs(addr.sin6_port))
#     653                 :          0 : {
#     654                 :          0 :    assert(addr.sin6_family == AF_INET6);
#     655                 :          0 : }
#     656                 :            : 
#     657                 :            : bool CService::SetSockAddr(const struct sockaddr *paddr)
#     658                 :          0 : {
#     659                 :          0 :     switch (paddr->sa_family) {
#     660                 :          0 :     case AF_INET:
#     661                 :          0 :         *this = CService(*(const struct sockaddr_in*)paddr);
#     662                 :          0 :         return true;
#     663                 :          0 :     case AF_INET6:
#     664                 :          0 :         *this = CService(*(const struct sockaddr_in6*)paddr);
#     665                 :          0 :         return true;
#     666                 :          0 :     default:
#     667                 :          0 :         return false;
#     668                 :          0 :     }
#     669                 :          0 : }
#     670                 :            : 
#     671                 :            : unsigned short CService::GetPort() const
#     672                 :         66 : {
#     673                 :         66 :     return port;
#     674                 :         66 : }
#     675                 :            : 
#     676                 :            : bool operator==(const CService& a, const CService& b)
#     677                 :        874 : {
#     678                 :        874 :     return static_cast<CNetAddr>(a) == static_cast<CNetAddr>(b) && a.port == b.port;
#     679                 :        874 : }
#     680                 :            : 
#     681                 :            : bool operator<(const CService& a, const CService& b)
#     682                 :          0 : {
#     683                 :          0 :     return static_cast<CNetAddr>(a) < static_cast<CNetAddr>(b) || (static_cast<CNetAddr>(a) == static_cast<CNetAddr>(b) && a.port < b.port);
#     684                 :          0 : }
#     685                 :            : 
#     686                 :            : /**
#     687                 :            :  * Obtain the IPv4/6 socket address this represents.
#     688                 :            :  *
#     689                 :            :  * @param[out] paddr The obtained socket address.
#     690                 :            :  * @param[in,out] addrlen The size, in bytes, of the address structure pointed
#     691                 :            :  *                        to by paddr. The value that's pointed to by this
#     692                 :            :  *                        parameter might change after calling this function if
#     693                 :            :  *                        the size of the corresponding address structure
#     694                 :            :  *                        changed.
#     695                 :            :  *
#     696                 :            :  * @returns Whether or not the operation was successful.
#     697                 :            :  */
#     698                 :            : bool CService::GetSockAddr(struct sockaddr* paddr, socklen_t *addrlen) const
#     699                 :      25014 : {
#     700                 :      25014 :     if (IsIPv4()) {
#     701                 :      24744 :         if (*addrlen < (socklen_t)sizeof(struct sockaddr_in))
#     702                 :          0 :             return false;
#     703                 :      24744 :         *addrlen = sizeof(struct sockaddr_in);
#     704                 :      24744 :         struct sockaddr_in *paddrin = (struct sockaddr_in*)paddr;
#     705                 :      24744 :         memset(paddrin, 0, *addrlen);
#     706                 :      24744 :         if (!GetInAddr(&paddrin->sin_addr))
#     707                 :          0 :             return false;
#     708                 :      24744 :         paddrin->sin_family = AF_INET;
#     709                 :      24744 :         paddrin->sin_port = htons(port);
#     710                 :      24744 :         return true;
#     711                 :      24744 :     }
#     712                 :        270 :     if (IsIPv6()) {
#     713                 :        270 :         if (*addrlen < (socklen_t)sizeof(struct sockaddr_in6))
#     714                 :          0 :             return false;
#     715                 :        270 :         *addrlen = sizeof(struct sockaddr_in6);
#     716                 :        270 :         struct sockaddr_in6 *paddrin6 = (struct sockaddr_in6*)paddr;
#     717                 :        270 :         memset(paddrin6, 0, *addrlen);
#     718                 :        270 :         if (!GetIn6Addr(&paddrin6->sin6_addr))
#     719                 :          0 :             return false;
#     720                 :        270 :         paddrin6->sin6_scope_id = scopeId;
#     721                 :        270 :         paddrin6->sin6_family = AF_INET6;
#     722                 :        270 :         paddrin6->sin6_port = htons(port);
#     723                 :        270 :         return true;
#     724                 :        270 :     }
#     725                 :          0 :     return false;
#     726                 :          0 : }
#     727                 :            : 
#     728                 :            : /**
#     729                 :            :  * @returns An identifier unique to this service's address and port number.
#     730                 :            :  */
#     731                 :            : std::vector<unsigned char> CService::GetKey() const
#     732                 :    1255116 : {
#     733                 :    1255116 :     auto key = GetAddrKey();
#     734                 :    1255116 :     key.push_back(port / 0x100); // most significant byte of our port
#     735                 :    1255116 :     key.push_back(port & 0x0FF); // least significant byte of our port
#     736                 :    1255116 :     return key;
#     737                 :    1255116 : }
#     738                 :            : 
#     739                 :            : std::string CService::ToStringPort() const
#     740                 :       5632 : {
#     741                 :       5632 :     return strprintf("%u", port);
#     742                 :       5632 : }
#     743                 :            : 
#     744                 :            : std::string CService::ToStringIPPort() const
#     745                 :       5632 : {
#     746                 :       5632 :     if (IsIPv4() || IsTor() || IsInternal()) {
#     747                 :       5386 :         return ToStringIP() + ":" + ToStringPort();
#     748                 :       5386 :     } else {
#     749                 :        246 :         return "[" + ToStringIP() + "]:" + ToStringPort();
#     750                 :        246 :     }
#     751                 :       5632 : }
#     752                 :            : 
#     753                 :            : std::string CService::ToString() const
#     754                 :       1146 : {
#     755                 :       1146 :     return ToStringIPPort();
#     756                 :       1146 : }
#     757                 :            : 
#     758                 :            : CSubNet::CSubNet():
#     759                 :            :     valid(false)
#     760                 :        188 : {
#     761                 :        188 :     memset(netmask, 0, sizeof(netmask));
#     762                 :        188 : }
#     763                 :            : 
#     764                 :            : CSubNet::CSubNet(const CNetAddr &addr, int32_t mask)
#     765                 :         72 : {
#     766                 :         72 :     valid = true;
#     767                 :         72 :     network = addr;
#     768                 :         72 :     // Default to /32 (IPv4) or /128 (IPv6), i.e. match single address
#     769                 :         72 :     memset(netmask, 255, sizeof(netmask));
#     770                 :         72 : 
#     771                 :         72 :     // IPv4 addresses start at offset 12, and first 12 bytes must match, so just offset n
#     772                 :         72 :     const int astartofs = network.IsIPv4() ? 12 : 0;
#     773                 :         72 : 
#     774                 :         72 :     int32_t n = mask;
#     775                 :         72 :     if(n >= 0 && n <= (128 - astartofs*8)) // Only valid if in range of bits of address
#     776                 :         64 :     {
#     777                 :         64 :         n += astartofs*8;
#     778                 :         64 :         // Clear bits [n..127]
#     779                 :       1986 :         for (; n < 128; ++n)
#     780                 :       1922 :             netmask[n>>3] &= ~(1<<(7-(n&7)));
#     781                 :         64 :     } else
#     782                 :          8 :         valid = false;
#     783                 :         72 : 
#     784                 :         72 :     // Normalize network according to netmask
#     785                 :       1224 :     for(int x=0; x<16; ++x)
#     786                 :       1152 :         network.ip[x] &= netmask[x];
#     787                 :         72 : }
#     788                 :            : 
#     789                 :            : CSubNet::CSubNet(const CNetAddr &addr, const CNetAddr &mask)
#     790                 :         90 : {
#     791                 :         90 :     valid = true;
#     792                 :         90 :     network = addr;
#     793                 :         90 :     // Default to /32 (IPv4) or /128 (IPv6), i.e. match single address
#     794                 :         90 :     memset(netmask, 255, sizeof(netmask));
#     795                 :         90 : 
#     796                 :         90 :     // IPv4 addresses start at offset 12, and first 12 bytes must match, so just offset n
#     797                 :         90 :     const int astartofs = network.IsIPv4() ? 12 : 0;
#     798                 :         90 : 
#     799                 :        570 :     for(int x=astartofs; x<16; ++x)
#     800                 :        480 :         netmask[x] = mask.ip[x];
#     801                 :         90 : 
#     802                 :         90 :     // Normalize network according to netmask
#     803                 :       1530 :     for(int x=0; x<16; ++x)
#     804                 :       1440 :         network.ip[x] &= netmask[x];
#     805                 :         90 : }
#     806                 :            : 
#     807                 :            : CSubNet::CSubNet(const CNetAddr &addr):
#     808                 :            :     valid(addr.IsValid())
#     809                 :         56 : {
#     810                 :         56 :     memset(netmask, 255, sizeof(netmask));
#     811                 :         56 :     network = addr;
#     812                 :         56 : }
#     813                 :            : 
#     814                 :            : /**
#     815                 :            :  * @returns True if this subnet is valid, the specified address is valid, and
#     816                 :            :  *          the specified address belongs in this subnet.
#     817                 :            :  */
#     818                 :            : bool CSubNet::Match(const CNetAddr &addr) const
#     819                 :         78 : {
#     820                 :         78 :     if (!valid || !addr.IsValid())
#     821                 :         12 :         return false;
#     822                 :       1044 :     for(int x=0; x<16; ++x)
#     823                 :        998 :         if ((addr.ip[x] & netmask[x]) != network.ip[x])
#     824                 :         20 :             return false;
#     825                 :         66 :     return true;
#     826                 :         66 : }
#     827                 :            : 
#     828                 :            : /**
#     829                 :            :  * @returns The number of 1-bits in the prefix of the specified subnet mask. If
#     830                 :            :  *          the specified subnet mask is not a valid one, -1.
#     831                 :            :  */
#     832                 :            : static inline int NetmaskBits(uint8_t x)
#     833                 :         86 : {
#     834                 :         86 :     switch(x) {
#     835                 :         24 :     case 0x00: return 0;
#     836                 :          8 :     case 0x80: return 1;
#     837                 :          8 :     case 0xc0: return 2;
#     838                 :          8 :     case 0xe0: return 3;
#     839                 :          8 :     case 0xf0: return 4;
#     840                 :          8 :     case 0xf8: return 5;
#     841                 :         10 :     case 0xfc: return 6;
#     842                 :         10 :     case 0xfe: return 7;
#     843                 :          0 :     case 0xff: return 8;
#     844                 :          2 :     default: return -1;
#     845                 :         86 :     }
#     846                 :         86 : }
#     847                 :            : 
#     848                 :            : std::string CSubNet::ToString() const
#     849                 :        108 : {
#     850                 :        108 :     /* Parse binary 1{n}0{N-n} to see if mask can be represented as /n */
#     851                 :        108 :     int cidr = 0;
#     852                 :        108 :     bool valid_cidr = true;
#     853                 :        108 :     int n = network.IsIPv4() ? 12 : 0;
#     854                 :        432 :     for (; n < 16 && netmask[n] == 0xff; ++n)
#     855                 :        324 :         cidr += 8;
#     856                 :        108 :     if (n < 16) {
#     857                 :         86 :         int bits = NetmaskBits(netmask[n]);
#     858                 :         86 :         if (bits < 0)
#     859                 :          2 :             valid_cidr = false;
#     860                 :         84 :         else
#     861                 :         84 :             cidr += bits;
#     862                 :         86 :         ++n;
#     863                 :         86 :     }
#     864                 :        306 :     for (; n < 16 && valid_cidr; ++n)
#     865                 :        198 :         if (netmask[n] != 0x00)
#     866                 :          2 :             valid_cidr = false;
#     867                 :        108 : 
#     868                 :        108 :     /* Format output */
#     869                 :        108 :     std::string strNetmask;
#     870                 :        108 :     if (valid_cidr) {
#     871                 :        104 :         strNetmask = strprintf("%u", cidr);
#     872                 :        104 :     } else {
#     873                 :          4 :         if (network.IsIPv4())
#     874                 :          2 :             strNetmask = strprintf("%u.%u.%u.%u", netmask[12], netmask[13], netmask[14], netmask[15]);
#     875                 :          2 :         else
#     876                 :          2 :             strNetmask = strprintf("%x:%x:%x:%x:%x:%x:%x:%x",
#     877                 :          2 :                              netmask[0] << 8 | netmask[1], netmask[2] << 8 | netmask[3],
#     878                 :          2 :                              netmask[4] << 8 | netmask[5], netmask[6] << 8 | netmask[7],
#     879                 :          2 :                              netmask[8] << 8 | netmask[9], netmask[10] << 8 | netmask[11],
#     880                 :          2 :                              netmask[12] << 8 | netmask[13], netmask[14] << 8 | netmask[15]);
#     881                 :          4 :     }
#     882                 :        108 : 
#     883                 :        108 :     return network.ToString() + "/" + strNetmask;
#     884                 :        108 : }
#     885                 :            : 
#     886                 :            : bool CSubNet::IsValid() const
#     887                 :        208 : {
#     888                 :        208 :     return valid;
#     889                 :        208 : }
#     890                 :            : 
#     891                 :            : bool operator==(const CSubNet& a, const CSubNet& b)
#     892                 :          4 : {
#     893                 :          4 :     return a.valid == b.valid && a.network == b.network && !memcmp(a.netmask, b.netmask, 16);
#     894                 :          4 : }
#     895                 :            : 
#     896                 :            : bool operator<(const CSubNet& a, const CSubNet& b)
#     897                 :         62 : {
#     898                 :         62 :     return (a.network < b.network || (a.network == b.network && memcmp(a.netmask, b.netmask, 16) < 0));
#     899                 :         62 : }
#     900                 :            : 
#     901                 :            : bool SanityCheckASMap(const std::vector<bool>& asmap)
#     902                 :          0 : {
#     903                 :          0 :     return SanityCheckASMap(asmap, 128); // For IP address lookups, the input is 128 bits
#     904                 :          0 : }

Generated by: LCOV version 1.14