501
502enum Network CNetAddr::GetNetwork() const
503{
504    if (IsInternal())
505        return NET_INTERNAL;
506
507    if (!IsRoutable())
508        return NET_UNROUTABLE;
509
510    return m_net;
511}
512
513static std::string IPv4ToString(std::span<const uint8_t> a)
514{
515    return strprintf("%u.%u.%u.%u", a[0], a[1], a[2], a[3]);
516}
517
518// Return an IPv6 address text representation with zero compression as described in RFC 5952
519// ("A Recommendation for IPv6 Address Text Representation").
520static std::string IPv6ToString(std::span<const uint8_t> a, uint32_t scope_id)
521{
522    assert(a.size() == ADDR_IPV6_SIZE);
523    const std::array groups{
524        ReadBE16(&a[0]),
525        ReadBE16(&a[2]),
526        ReadBE16(&a[4]),
527        ReadBE16(&a[6]),
528        ReadBE16(&a[8]),
529        ReadBE16(&a[10]),
530        ReadBE16(&a[12]),
531        ReadBE16(&a[14]),
532    };
533
534    // The zero compression implementation is inspired by Rust's std::net::Ipv6Addr, see
535    // https://github.com/rust-lang/rust/blob/cc4103089f40a163f6d143f06359cba7043da29b/library/std/src/net/ip.rs#L1635-L1683
536    struct ZeroSpan {
537        size_t start_index{0};
538        size_t len{0};
539    };
540
541    // Find longest sequence of consecutive all-zero fields. Use first zero sequence if two or more
542    // zero sequences of equal length are found.
543    ZeroSpan longest, current;
544    for (size_t i{0}; i < groups.size(); ++i) {
545        if (groups[i] != 0) {
546            current = {i + 1, 0};
547            continue;
548        }
549        current.len += 1;
550        if (current.len > longest.len) {
551            longest = current;
552        }
553    }
554
555    std::string r;
556    r.reserve(39);
557    for (size_t i{0}; i < groups.size(); ++i) {
558        // Replace the longest sequence of consecutive all-zero fields with two colons ("::").
559        if (longest.len >= 2 && i >= longest.start_index && i < longest.start_index + longest.len) {
560            if (i == longest.start_index) {
561                r += "::";
562            }
563            continue;
564        }
565        r += strprintf("%s%x", ((!r.empty() && r.back() != ':') ? ":" : ""), groups[i]);
566    }
567
568    if (scope_id != 0) {
569        r += strprintf("%%%u", scope_id);
570    }
571
572    return r;
573}
574
575std::string OnionToString(std::span<const uint8_t> addr)
576{
577    uint8_t checksum[torv3::CHECKSUM_LEN];
578    torv3::Checksum(addr, checksum);
579    // TORv3 onion_address = base32(PUBKEY | CHECKSUM | VERSION) + ".onion"
580    prevector<torv3::TOTAL_LEN, uint8_t> address{addr.begin(), addr.end()};
581    address.insert(address.end(), checksum, checksum + torv3::CHECKSUM_LEN);
582    address.insert(address.end(), torv3::VERSION, torv3::VERSION + sizeof(torv3::VERSION));
583    return EncodeBase32(address) + ".onion";
584}
585
586std::string CNetAddr::ToStringAddr() const
587{
588    switch (m_net) {
589    case NET_IPV4:
590        return IPv4ToString(m_addr);
591    case NET_IPV6:
592        return IPv6ToString(m_addr, m_scope_id);
593    case NET_ONION:
594        return OnionToString(m_addr);
595    case NET_I2P:
596        return EncodeBase32(m_addr, false /* don't pad with = */) + ".b32.i2p";
597    case NET_CJDNS:
598        return IPv6ToString(m_addr, 0);
599    case NET_INTERNAL:
600        return EncodeBase32(m_addr) + ".internal";
601    case NET_UNROUTABLE: // m_net is never and should not be set to NET_UNROUTABLE
602    case NET_MAX:        // m_net is never and should not be set to NET_MAX
603        assert(false);
604    } // no default case, so the compiler can warn about missing cases
605
606    assert(false);
607}
608
609bool operator==(const CNetAddr& a, const CNetAddr& b)
610{
611    return a.m_net == b.m_net && a.m_addr == b.m_addr;
612}
613
614bool operator<(const CNetAddr& a, const CNetAddr& b)
615{
616    return std::tie(a.m_net, a.m_addr) < std::tie(b.m_net, b.m_addr);
617}
618
619/**
620 * Try to get our IPv4 address.
621 *
622 * @param[out] pipv4Addr The in_addr struct to which to copy.
623 *
624 * @returns Whether or not the operation was successful, in particular, whether
625 *          or not our address was an IPv4 address.
626 *
627 * @see CNetAddr::IsIPv4()
628 */
629bool CNetAddr::GetInAddr(struct in_addr* pipv4Addr) const
630{
631    if (!IsIPv4())
632        return false;
633    assert(sizeof(*pipv4Addr) == m_addr.size());
634    memcpy(pipv4Addr, m_addr.data(), m_addr.size());
635    return true;
636}
637
638/**
639 * Try to get our IPv6 (or CJDNS) address.
640 *
641 * @param[out] pipv6Addr The in6_addr struct to which to copy.
642 *
643 * @returns Whether or not the operation was successful, in particular, whether
644 *          or not our address was an IPv6 address.
645 *
646 * @see CNetAddr::IsIPv6()
647 */
648bool CNetAddr::GetIn6Addr(struct in6_addr* pipv6Addr) const
649{
650    if (!IsIPv6() && !IsCJDNS()) {
651        return false;
652    }
653    assert(sizeof(*pipv6Addr) == m_addr.size());
654    memcpy(pipv6Addr, m_addr.data(), m_addr.size());
655    return true;
656}
657
658bool CNetAddr::HasLinkedIPv4() const
659{
660    return IsRoutable() && (IsIPv4() || IsRFC6145() || IsRFC6052() || IsRFC3964() || IsRFC4380());
661}
662
663uint32_t CNetAddr::GetLinkedIPv4() const
664{
665    if (IsIPv4()) {
666        return ReadBE32(m_addr.data());
667    } else if (IsRFC6052() || IsRFC6145()) {
668        // mapped IPv4, SIIT translated IPv4: the IPv4 address is the last 4 bytes of the address
669        return ReadBE32(std::span{m_addr}.last(ADDR_IPV4_SIZE).data());
670    } else if (IsRFC3964()) {
671        // 6to4 tunneled IPv4: the IPv4 address is in bytes 2-6
672        return ReadBE32(std::span{m_addr}.subspan(2, ADDR_IPV4_SIZE).data());
673    } else if (IsRFC4380()) {
674        // Teredo tunneled IPv4: the IPv4 address is in the last 4 bytes of the address, but bitflipped
675        return ~ReadBE32(std::span{m_addr}.last(ADDR_IPV4_SIZE).data());
676    }
677    assert(false);
678}
679
680Network CNetAddr::GetNetClass() const
681{
682    // Make sure that if we return NET_IPV6, then IsIPv6() is true. The callers expect that.
683
684    // Check for "internal" first because such addresses are also !IsRoutable()
685    // and we don't want to return NET_UNROUTABLE in that case.
686    if (IsInternal()) {
687        return NET_INTERNAL;
688    }
689    if (!IsRoutable()) {
690        return NET_UNROUTABLE;
691    }
692    if (HasLinkedIPv4()) {
693        return NET_IPV4;
694    }
695    return m_net;
696}
697
698std::vector<unsigned char> CNetAddr::GetAddrBytes() const
699{
700    if (IsAddrV1Compatible()) {
701        uint8_t serialized[V1_SERIALIZATION_SIZE];
702        SerializeV1Array(serialized);
703        return {std::begin(serialized), std::end(serialized)};
704    }
705    return std::vector<unsigned char>(m_addr.begin(), m_addr.end());
706}
707
708// private extensions to enum Network, only returned by GetExtNetwork,
709// and only used in GetReachabilityFrom
710static const int NET_TEREDO = NET_MAX;
711int static GetExtNetwork(const CNetAddr& addr)
712{
713    if (addr.IsRFC4380())
714        return NET_TEREDO;
715    return addr.GetNetwork();
716}
717
718/** Calculates a metric for how reachable (*this) is from a given partner */
719int CNetAddr::GetReachabilityFrom(const CNetAddr& paddrPartner) const
720{
721    enum Reachability {
722        REACH_UNREACHABLE,
723        REACH_DEFAULT,
724        REACH_TEREDO,
725        REACH_IPV6_WEAK,
726        REACH_IPV4,
727        REACH_IPV6_STRONG,
728        REACH_PRIVATE
729    };
730
731    if (!IsRoutable() || IsInternal())
732        return REACH_UNREACHABLE;
733
734    int ourNet = GetExtNetwork(*this);
735    int theirNet = GetExtNetwork(paddrPartner);
736    bool fTunnel = IsRFC3964() || IsRFC6052() || IsRFC6145();
737
738    switch(theirNet) {
739    case NET_IPV4:
740        switch(ourNet) {
741        default:       return REACH_DEFAULT;
742        case NET_IPV4: return REACH_IPV4;
743        }
744    case NET_IPV6:
745        switch(ourNet) {
746        default:         return REACH_DEFAULT;
747        case NET_TEREDO: return REACH_TEREDO;
748        case NET_IPV4:   return REACH_IPV4;
749        case NET_IPV6:   return fTunnel ? REACH_IPV6_WEAK : REACH_IPV6_STRONG; // only prefer giving our IPv6 address if it's not tunnelled
750        }