Inspecting peers and controlling P2P networking

751    obj.pushKV("localservicesnames", GetServicesNames(services));
752    auto peerman_info{EnsurePeerman(node).GetInfo()};
753    obj.pushKV("localrelay", !peerman_info.ignores_incoming_txs);
754    obj.pushKV("timeoffset", Ticks<std::chrono::seconds>(peerman_info.median_outbound_time_offset));
755    obj.pushKV("tx_send_rate", peerman_info.tx_send_rate);
756    auto buckjson = [&](const auto& buckinfo) {
757        UniValue b{UniValue::VOBJ};
758        b.pushKV("backlog", buckinfo.backlog_count);
759        b.pushKV("count_tok", buckinfo.count_bucket);
760        b.pushKV("size_tok", buckinfo.size_bucket);
761        return b;
762    };
763    UniValue invbuckets{UniValue::VOBJ};
764    invbuckets.pushKV("inbound", buckjson(peerman_info.inbound_bucket));
765    invbuckets.pushKV("outbound", buckjson(peerman_info.outbound_bucket));
766    obj.pushKV("inv_buckets", invbuckets);
767    obj.pushKV("networkactive", connman.GetNetworkActive());
768    obj.pushKV("connections", connman.GetNodeCount(ConnectionDirection::Both));
769    obj.pushKV("connections_in", connman.GetNodeCount(ConnectionDirection::In));
770    obj.pushKV("connections_out", connman.GetNodeCount(ConnectionDirection::Out));
771    obj.pushKV("networks",      GetNetworksInfo());
772    const NetGroupManager& netgroupman{*CHECK_NONFATAL(node.netgroupman)};
773    if (netgroupman.UsingASMap()) {
774        obj.pushKV("asmap_version", HexStr(netgroupman.GetAsmapVersion()));
775    }
776    const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
777    // Those fields can be deprecated, to be replaced by the getmempoolinfo fields
778    obj.pushKV("relayfee", ValueFromAmount(mempool.m_opts.min_relay_feerate.GetFeePerK()));
779    obj.pushKV("incrementalfee", ValueFromAmount(mempool.m_opts.incremental_relay_feerate.GetFeePerK()));
780    UniValue localAddresses(UniValue::VARR);
781    {
782        LOCK(g_maplocalhost_mutex);
783        for (const std::pair<const CNetAddr, LocalServiceInfo> &item : mapLocalHost)
784        {
785            UniValue rec(UniValue::VOBJ);
786            rec.pushKV("address", item.first.ToStringAddr());
787            rec.pushKV("port", item.second.nPort);
788            rec.pushKV("score", item.second.nScore);
789            localAddresses.push_back(std::move(rec));
790        }
791    }
792    obj.pushKV("localaddresses", std::move(localAddresses));
793    obj.pushKV("warnings", node::GetWarningsForRpc(*CHECK_NONFATAL(node.warnings), IsDeprecatedRPCEnabled("warnings")));
794    return obj;
795},
796    };
797}
798
799static RPCMethod setban()
800{
801    return RPCMethod{
802        "setban",
803        "Attempts to add or remove an IP/Subnet from the banned list.\n",
804                {
805                    {"subnet", RPCArg::Type::STR, RPCArg::Optional::NO, "The IP/Subnet (see getpeerinfo for nodes IP) with an optional netmask (default is /32 = single IP)"},
806                    {"command", RPCArg::Type::STR, RPCArg::Optional::NO, "'add' to add an IP/Subnet to the list, 'remove' to remove an IP/Subnet from the list"},
807                    {"bantime", RPCArg::Type::NUM, RPCArg::Default{0}, "time in seconds how long (or until when if [absolute] is set) the IP is banned (0 or empty means using the default time of 24h which can also be overwritten by the -bantime startup argument)"},
808                    {"absolute", RPCArg::Type::BOOL, RPCArg::Default{false}, "If set, the bantime must be an absolute timestamp expressed in " + UNIX_EPOCH_TIME},
809                },
810                RPCResult{RPCResult::Type::NONE, "", ""},
811                RPCExamples{
812                    HelpExampleCli("setban", "\"192.168.0.6\" \"add\" 86400")
813                            + HelpExampleCli("setban", "\"192.168.0.0/24\" \"add\"")
814                            + HelpExampleRpc("setban", "\"192.168.0.6\", \"add\", 86400")
815                },
816        [](const RPCMethod& help, const JSONRPCRequest& request) -> UniValue
817{
818    auto command{help.Arg<std::string_view>("command")};
819    if (command != "add" && command != "remove") {
820        throw std::runtime_error(help.ToString());
821    }
822    NodeContext& node = EnsureAnyNodeContext(request.context);
823    BanMan& banman = EnsureBanman(node);
824
825    CSubNet subNet;
826    CNetAddr netAddr;
827    std::string subnet_arg{help.Arg<std::string_view>("subnet")};
828    const bool isSubnet{subnet_arg.find('/') != subnet_arg.npos};
829
830    if (!isSubnet) {
831        const std::optional<CNetAddr> addr{LookupHost(subnet_arg, false)};
832        if (addr.has_value()) {
833            netAddr = static_cast<CNetAddr>(MaybeFlipIPv6toCJDNS(CService{addr.value(), /*port=*/0}));
834        }
835    } else {
836        subNet = LookupSubNet(subnet_arg);
837    }
838
839    if (! (isSubnet ? subNet.IsValid() : netAddr.IsValid()) ) {
840        throw JSONRPCError(RPC_CLIENT_INVALID_IP_OR_SUBNET, "Error: Invalid IP/Subnet");
841    }
842
843    if (command == "add") {
844        if (isSubnet ? banman.IsBanned(subNet) : banman.IsBanned(netAddr)) {
845            throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED, "Error: IP/Subnet already banned");
846        }
847
848        int64_t banTime = 0; //use standard bantime if not specified
849        if (!request.params[2].isNull())
850            banTime = request.params[2].getInt<int64_t>();
851
852        const bool absolute{request.params[3].isNull() ? false : request.params[3].get_bool()};
853
854        if (absolute && banTime < GetTime()) {
855            throw JSONRPCError(RPC_INVALID_PARAMETER, "Error: Absolute timestamp is in the past");
856        }
857
858        if (isSubnet) {
859            banman.Ban(subNet, banTime, absolute);
860            if (node.connman) {
861                node.connman->DisconnectNode(subNet);
862            }
863        } else {
864            banman.Ban(netAddr, banTime, absolute);
865            if (node.connman) {
866                node.connman->DisconnectNode(netAddr);
867            }
868        }
869    } else if(command == "remove") {
870        if (!( isSubnet ? banman.Unban(subNet) : banman.Unban(netAddr) )) {
871            throw JSONRPCError(RPC_CLIENT_INVALID_IP_OR_SUBNET, "Error: Unban failed. Requested address/subnet was not previously manually banned.");
872        }
873    }
874    return UniValue::VNULL;
875},
876    };
877}
878
879static RPCMethod listbanned()
880{
881    return RPCMethod{
882        "listbanned",
883        "List all manually banned IPs/Subnets.\n",
884                {},
885        RPCResult{RPCResult::Type::ARR, "", "",
886            {
887                {RPCResult::Type::OBJ, "", "",
888                    {
889                        {RPCResult::Type::STR, "address", "The IP/Subnet of the banned node"},
890                        {RPCResult::Type::NUM_TIME, "ban_created", "The " + UNIX_EPOCH_TIME + " the ban was created"},
891                        {RPCResult::Type::NUM_TIME, "banned_until", "The " + UNIX_EPOCH_TIME + " the ban expires"},
892                        {RPCResult::Type::NUM_TIME, "ban_duration", "The ban duration, in seconds"},
893                        {RPCResult::Type::NUM_TIME, "time_remaining", "The time remaining until the ban expires, in seconds"},
894                    }},
895            }},
896                RPCExamples{
897                    HelpExampleCli("listbanned", "")
898                            + HelpExampleRpc("listbanned", "")
899                },
900        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
901{
902    BanMan& banman = EnsureAnyBanman(request.context);
903
904    banmap_t banMap;
905    banman.GetBanned(banMap);
906    const int64_t current_time{GetTime()};
907
908    UniValue bannedAddresses(UniValue::VARR);
909    for (const auto& entry : banMap)
910    {
911        const CBanEntry& banEntry = entry.second;
912        UniValue rec(UniValue::VOBJ);
913        rec.pushKV("address", entry.first.ToString());
914        rec.pushKV("ban_created", banEntry.nCreateTime);
915        rec.pushKV("banned_until", banEntry.nBanUntil);
916        rec.pushKV("ban_duration", (banEntry.nBanUntil - banEntry.nCreateTime));
917        rec.pushKV("time_remaining", (banEntry.nBanUntil - current_time));
918
919        bannedAddresses.push_back(std::move(rec));
920    }
921
922    return bannedAddresses;
923},
924    };
925}
926
927static RPCMethod clearbanned()
928{
929    return RPCMethod{
930        "clearbanned",
931        "Clear all banned IPs.\n",
932                {},
933                RPCResult{RPCResult::Type::NONE, "", ""},
934                RPCExamples{
935                    HelpExampleCli("clearbanned", "")
936                            + HelpExampleRpc("clearbanned", "")
937                },
938        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
939{
940    BanMan& banman = EnsureAnyBanman(request.context);
941
942    banman.ClearBanned();
943
944    return UniValue::VNULL;
945},
946    };
947}
948
949static RPCMethod setnetworkactive()
950{
951    return RPCMethod{
952        "setnetworkactive",
953        "Disable/enable all p2p network activity.\n",
954                {
955                    {"state", RPCArg::Type::BOOL, RPCArg::Optional::NO, "true to enable networking, false to disable"},
956                },
957                RPCResult{RPCResult::Type::BOOL, "", "The value that was passed in"},
958                RPCExamples{""},
959        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
960{
961    NodeContext& node = EnsureAnyNodeContext(request.context);
962    CConnman& connman = EnsureConnman(node);
963
964    connman.SetNetworkActive(request.params[0].get_bool());
965
966    return connman.GetNetworkActive();
967},
968    };
969}
970
971static RPCMethod getnodeaddresses()
972{
973    return RPCMethod{"getnodeaddresses",
974                "Return known addresses, after filtering for quality and recency.\n"
975                "These can potentially be used to find new peers in the network.\n"
976                "The total number of addresses known to the node may be higher.",
977                {
978                    {"count", RPCArg::Type::NUM, RPCArg::Default{1}, "The maximum number of addresses to return. Specify 0 to return all known addresses."},
979                    {"network", RPCArg::Type::STR, RPCArg::DefaultHint{"all networks"}, "Return only addresses of the specified network. Can be one of: " + Join(GetNetworkNames(), ", ") + "."},
980                },
981                RPCResult{
982                    RPCResult::Type::ARR, "", "",
983                    {
984                        {RPCResult::Type::OBJ, "", "",
985                        {
986                            {RPCResult::Type::NUM_TIME, "time", "The " + UNIX_EPOCH_TIME + " when the node was last seen"},
987                            {RPCResult::Type::NUM, "services", "The services offered by the node"},
988                            {RPCResult::Type::STR, "address", "The address of the node"},
989                            {RPCResult::Type::NUM, "port", "The port number of the node"},
990                            {RPCResult::Type::STR, "network", "The network (" + Join(GetNetworkNames(), ", ") + ") the node connected through"},
991                        }},
992                    }
993                },
994                RPCExamples{
995                    HelpExampleCli("getnodeaddresses", "8")
996                    + HelpExampleCli("getnodeaddresses", "4 \"i2p\"")
997                    + HelpExampleCli("-named getnodeaddresses", "network=onion count=12")
998                    + HelpExampleRpc("getnodeaddresses", "8")
999                    + HelpExampleRpc("getnodeaddresses", "4, \"i2p\"")
1000                },