Peer network addresses, not payment addresses

751    case NET_ONION:
752        switch(ourNet) {
753        default:         return REACH_DEFAULT;
754        case NET_IPV4:   return REACH_IPV4; // Tor users can connect to IPv4 as well
755        case NET_ONION:    return REACH_PRIVATE;
756        }
757    case NET_I2P:
758        switch (ourNet) {
759        case NET_I2P: return REACH_PRIVATE;
760        default: return REACH_DEFAULT;
761        }
762    case NET_CJDNS:
763        switch (ourNet) {
764        case NET_CJDNS: return REACH_PRIVATE;
765        default: return REACH_DEFAULT;
766        }
767    case NET_TEREDO:
768        switch(ourNet) {
769        default:          return REACH_DEFAULT;
770        case NET_TEREDO:  return REACH_TEREDO;
771        case NET_IPV6:    return REACH_IPV6_WEAK;
772        case NET_IPV4:    return REACH_IPV4;
773        }
774    case NET_UNROUTABLE:
775    default:
776        switch(ourNet) {
777        default:          return REACH_DEFAULT;
778        case NET_TEREDO:  return REACH_TEREDO;
779        case NET_IPV6:    return REACH_IPV6_WEAK;
780        case NET_IPV4:    return REACH_IPV4;
781        case NET_ONION:     return REACH_PRIVATE; // either from Tor, or don't care about our address
782        }
783    }
784}
785
786CService::CService() : port(0)
787{
788}
789
790CService::CService(const CNetAddr& cip, uint16_t portIn) : CNetAddr(cip), port(portIn)
791{
792}
793
794CService::CService(const struct in_addr& ipv4Addr, uint16_t portIn) : CNetAddr(ipv4Addr), port(portIn)
795{
796}
797
798CService::CService(const struct in6_addr& ipv6Addr, uint16_t portIn) : CNetAddr(ipv6Addr), port(portIn)
799{
800}
801
802CService::CService(const struct sockaddr_in& addr) : CNetAddr(addr.sin_addr), port(ntohs(addr.sin_port))
803{
804    assert(addr.sin_family == AF_INET);
805}
806
807CService::CService(const struct sockaddr_in6 &addr) : CNetAddr(addr.sin6_addr, addr.sin6_scope_id), port(ntohs(addr.sin6_port))
808{
809   assert(addr.sin6_family == AF_INET6);
810}
811
812bool CService::SetSockAddr(const struct sockaddr *paddr, socklen_t addrlen)
813{
814    switch (paddr->sa_family) {
815    case AF_INET:
816        if (addrlen != sizeof(struct sockaddr_in)) return false;
817        *this = CService(*(const struct sockaddr_in*)paddr);
818        return true;
819    case AF_INET6:
820        if (addrlen != sizeof(struct sockaddr_in6)) return false;
821        *this = CService(*(const struct sockaddr_in6*)paddr);
822        return true;
823    default:
824        return false;
825    }
826}
827
828sa_family_t CService::GetSAFamily() const
829{
830    switch (m_net) {
831    case NET_IPV4:
832        return AF_INET;
833    case NET_IPV6:
834    case NET_CJDNS:
835        return AF_INET6;
836    default:
837        return AF_UNSPEC;
838    }
839}
840
841uint16_t CService::GetPort() const
842{
843    return port;
844}
845
846bool operator==(const CService& a, const CService& b)
847{
848    return static_cast<CNetAddr>(a) == static_cast<CNetAddr>(b) && a.port == b.port;
849}
850
851bool operator<(const CService& a, const CService& b)
852{
853    return static_cast<CNetAddr>(a) < static_cast<CNetAddr>(b) || (static_cast<CNetAddr>(a) == static_cast<CNetAddr>(b) && a.port < b.port);
854}
855
856/**
857 * Obtain the IPv4/6 socket address this represents.
858 *
859 * @param[out] paddr The obtained socket address.
860 * @param[in,out] addrlen The size, in bytes, of the address structure pointed
861 *                        to by paddr. The value that's pointed to by this
862 *                        parameter might change after calling this function if
863 *                        the size of the corresponding address structure
864 *                        changed.
865 *
866 * @returns Whether or not the operation was successful.
867 */
868bool CService::GetSockAddr(struct sockaddr* paddr, socklen_t *addrlen) const
869{
870    if (IsIPv4()) {
871        if (*addrlen < (socklen_t)sizeof(struct sockaddr_in))
872            return false;
873        *addrlen = sizeof(struct sockaddr_in);
874        struct sockaddr_in *paddrin = (struct sockaddr_in*)paddr;
875        memset(paddrin, 0, *addrlen);
876        if (!GetInAddr(&paddrin->sin_addr))
877            return false;
878        paddrin->sin_family = AF_INET;
879        paddrin->sin_port = htons(port);
880        return true;
881    }
882    if (IsIPv6() || IsCJDNS()) {
883        if (*addrlen < (socklen_t)sizeof(struct sockaddr_in6))
884            return false;
885        *addrlen = sizeof(struct sockaddr_in6);
886        struct sockaddr_in6 *paddrin6 = (struct sockaddr_in6*)paddr;
887        memset(paddrin6, 0, *addrlen);
888        if (!GetIn6Addr(&paddrin6->sin6_addr))
889            return false;
890        paddrin6->sin6_scope_id = m_scope_id;
891        paddrin6->sin6_family = AF_INET6;
892        paddrin6->sin6_port = htons(port);
893        return true;
894    }
895    return false;
896}
897
898/**
899 * @returns An identifier unique to this service's address and port number.
900 */
901std::vector<unsigned char> CService::GetKey() const
902{
903    auto key = GetAddrBytes();
904    key.push_back(port / 0x100); // most significant byte of our port
905    key.push_back(port & 0x0FF); // least significant byte of our port
906    return key;
907}
908
909std::string CService::ToStringAddrPort() const
910{
911    const auto port_str = strprintf("%u", port);
912
913    if (IsIPv4() || IsTor() || IsI2P() || IsInternal()) {
914        return ToStringAddr() + ":" + port_str;
915    } else {
916        return "[" + ToStringAddr() + "]:" + port_str;
917    }
918}
919
920CSubNet::CSubNet():
921    valid(false)
922{
923    memset(netmask, 0, sizeof(netmask));
924}
925
926CSubNet::CSubNet(const CNetAddr& addr, uint8_t mask) : CSubNet()
927{
928    valid = (addr.IsIPv4() && mask <= ADDR_IPV4_SIZE * 8) ||
929            (addr.IsIPv6() && mask <= ADDR_IPV6_SIZE * 8);
930    if (!valid) {
931        return;
932    }
933
934    assert(mask <= sizeof(netmask) * 8);
935
936    network = addr;
937
938    uint8_t n = mask;
939    for (size_t i = 0; i < network.m_addr.size(); ++i) {
940        const uint8_t bits = n < 8 ? n : 8;
941        netmask[i] = (uint8_t)((uint8_t)0xFF << (8 - bits)); // Set first bits.
942        network.m_addr[i] &= netmask[i]; // Normalize network according to netmask.
943        n -= bits;
944    }
945}
946
947/**
948 * @returns The number of 1-bits in the prefix of the specified subnet mask. If
949 *          the specified subnet mask is not a valid one, -1.
950 */
951static inline int NetmaskBits(uint8_t x)
952{
953    switch(x) {
954    case 0x00: return 0;
955    case 0x80: return 1;
956    case 0xc0: return 2;
957    case 0xe0: return 3;
958    case 0xf0: return 4;
959    case 0xf8: return 5;
960    case 0xfc: return 6;
961    case 0xfe: return 7;
962    case 0xff: return 8;
963    default: return -1;
964    }
965}
966
967CSubNet::CSubNet(const CNetAddr& addr, const CNetAddr& mask) : CSubNet()
968{
969    valid = (addr.IsIPv4() || addr.IsIPv6()) && addr.m_net == mask.m_net;
970    if (!valid) {
971        return;
972    }
973    // Check if `mask` contains 1-bits after 0-bits (which is an invalid netmask).
974    bool zeros_found = false;
975    for (auto b : mask.m_addr) {
976        const int num_bits = NetmaskBits(b);
977        if (num_bits == -1 || (zeros_found && num_bits != 0)) {
978            valid = false;
979            return;
980        }
981        if (num_bits < 8) {
982            zeros_found = true;
983        }
984    }
985
986    assert(mask.m_addr.size() <= sizeof(netmask));
987
988    memcpy(netmask, mask.m_addr.data(), mask.m_addr.size());
989
990    network = addr;
991
992    // Normalize network according to netmask
993    for (size_t x = 0; x < network.m_addr.size(); ++x) {
994        network.m_addr[x] &= netmask[x];
995    }
996}
997
998CSubNet::CSubNet(const CNetAddr& addr) : CSubNet()
999{
1000    switch (addr.m_net) {