Inspecting peers and controlling P2P networking

1001        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
1002{
1003    NodeContext& node = EnsureAnyNodeContext(request.context);
1004    const CConnman& connman = EnsureConnman(node);
1005
1006    const int count{request.params[0].isNull() ? 1 : request.params[0].getInt<int>()};
1007    if (count < 0) throw JSONRPCError(RPC_INVALID_PARAMETER, "Address count out of range");
1008
1009    const std::optional<Network> network{request.params[1].isNull() ? std::nullopt : std::optional<Network>{ParseNetwork(request.params[1].get_str())}};
1010    if (network == NET_UNROUTABLE) {
1011        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Network not recognized: %s", request.params[1].get_str()));
1012    }
1013
1014    // returns a shuffled list of CAddress
1015    const std::vector<CAddress> vAddr{connman.GetAddressesUnsafe(count, /*max_pct=*/0, network)};
1016    UniValue ret(UniValue::VARR);
1017
1018    for (const CAddress& addr : vAddr) {
1019        UniValue obj(UniValue::VOBJ);
1020        obj.pushKV("time", TicksSinceEpoch<std::chrono::seconds>(addr.nTime));
1021        obj.pushKV("services", static_cast<std::underlying_type_t<decltype(addr.nServices)>>(addr.nServices));
1022        obj.pushKV("address", addr.ToStringAddr());
1023        obj.pushKV("port", addr.GetPort());
1024        obj.pushKV("network", GetNetworkName(addr.GetNetClass()));
1025        ret.push_back(std::move(obj));
1026    }
1027    return ret;
1028},
1029    };
1030}
1031
1032static RPCMethod addpeeraddress()
1033{
1034    return RPCMethod{"addpeeraddress",
1035        "Add the address of a potential peer to an address manager table. This RPC is for testing only.",
1036        {
1037            {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The IP address of the peer"},
1038            {"port", RPCArg::Type::NUM, RPCArg::Optional::NO, "The port of the peer"},
1039            {"tried", RPCArg::Type::BOOL, RPCArg::Default{false}, "If true, attempt to add the peer to the tried addresses table"},
1040        },
1041        RPCResult{
1042            RPCResult::Type::OBJ, "", "",
1043            {
1044                {RPCResult::Type::BOOL, "success", "whether the peer address was successfully added to the address manager table"},
1045                {RPCResult::Type::STR, "error", /*optional=*/true, "error description, if the address could not be added"},
1046            },
1047        },
1048        RPCExamples{
1049            HelpExampleCli("addpeeraddress", "\"1.2.3.4\" 8333 true")
1050    + HelpExampleRpc("addpeeraddress", "\"1.2.3.4\", 8333, true")
1051        },
1052        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
1053{
1054    AddrMan& addrman = EnsureAnyAddrman(request.context);
1055
1056    const std::string& addr_string{request.params[0].get_str()};
1057    const auto port{request.params[1].getInt<uint16_t>()};
1058    const bool tried{request.params[2].isNull() ? false : request.params[2].get_bool()};
1059
1060    UniValue obj(UniValue::VOBJ);
1061    std::optional<CNetAddr> net_addr{LookupHost(addr_string, false)};
1062    if (!net_addr.has_value()) {
1063        throw JSONRPCError(RPC_CLIENT_INVALID_IP_OR_SUBNET, "Invalid IP address");
1064    }
1065
1066    bool success{false};
1067
1068    CService service{net_addr.value(), port};
1069    CAddress address{MaybeFlipIPv6toCJDNS(service), ServiceFlags{NODE_NETWORK | NODE_WITNESS}};
1070    address.nTime = Now<NodeSeconds>();
1071    // The source address is set equal to the address. This is equivalent to the peer
1072    // announcing itself.
1073    if (addrman.Add({address}, address)) {
1074        success = true;
1075        if (tried) {
1076            // Attempt to move the address to the tried addresses table.
1077            if (!addrman.Good(address)) {
1078                success = false;
1079                obj.pushKV("error", "failed-adding-to-tried");
1080            }
1081        }
1082    } else {
1083        obj.pushKV("error", "failed-adding-to-new");
1084    }
1085
1086    obj.pushKV("success", success);
1087    return obj;
1088},
1089    };
1090}
1091
1092static RPCMethod sendmsgtopeer()
1093{
1094    return RPCMethod{
1095        "sendmsgtopeer",
1096        "Send a p2p message to a peer specified by id.\n"
1097        "The message type and body must be provided, the message header will be generated.\n"
1098        "This RPC is for testing only.",
1099        {
1100            {"peer_id", RPCArg::Type::NUM, RPCArg::Optional::NO, "The peer to send the message to."},
1101            {"msg_type", RPCArg::Type::STR, RPCArg::Optional::NO, strprintf("The message type (maximum length %i)", CMessageHeader::MESSAGE_TYPE_SIZE)},
1102            {"msg", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The serialized message body to send, in hex, without a message header"},
1103        },
1104        RPCResult{RPCResult::Type::OBJ, "", "", std::vector<RPCResult>{}},
1105        RPCExamples{
1106            HelpExampleCli("sendmsgtopeer", "0 \"addr\" \"ffffff\"") + HelpExampleRpc("sendmsgtopeer", R"(0, "addr", "ffffff")")},
1107        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue {
1108            const NodeId peer_id{request.params[0].getInt<int64_t>()};
1109            const auto msg_type{self.Arg<std::string_view>("msg_type")};
1110            if (msg_type.size() > CMessageHeader::MESSAGE_TYPE_SIZE) {
1111                throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Error: msg_type too long, max length is %i", CMessageHeader::MESSAGE_TYPE_SIZE));
1112            }
1113            auto msg{TryParseHex<unsigned char>(self.Arg<std::string_view>("msg"))};
1114            if (!msg.has_value()) {
1115                throw JSONRPCError(RPC_INVALID_PARAMETER, "Error parsing input for msg");
1116            }
1117
1118            NodeContext& node = EnsureAnyNodeContext(request.context);
1119            CConnman& connman = EnsureConnman(node);
1120
1121            CSerializedNetMsg msg_ser;
1122            msg_ser.data = msg.value();
1123            msg_ser.m_type = msg_type;
1124
1125            bool success = connman.ForNode(peer_id, [&](CNode* node) {
1126                connman.PushMessage(node, std::move(msg_ser));
1127                return true;
1128            });
1129
1130            if (!success) {
1131                throw JSONRPCError(RPC_MISC_ERROR, "Error: Could not send message to peer");
1132            }
1133
1134            UniValue ret{UniValue::VOBJ};
1135            return ret;
1136        },
1137    };
1138}
1139
1140static RPCMethod getaddrmaninfo()
1141{
1142    return RPCMethod{
1143        "getaddrmaninfo",
1144        "Provides information about the node's address manager by returning the number of "
1145        "addresses in the `new` and `tried` tables and their sum for all networks.\n",
1146        {},
1147        RPCResult{
1148            RPCResult::Type::OBJ_DYN, "", "json object with network type as keys", {
1149                {RPCResult::Type::OBJ, "network", "the network (" + Join(GetNetworkNames(), ", ") + ", all_networks)", {
1150                {RPCResult::Type::NUM, "new", "number of addresses in the new table, which represent potential peers the node has discovered but hasn't yet successfully connected to."},
1151                {RPCResult::Type::NUM, "tried", "number of addresses in the tried table, which represent peers the node has successfully connected to in the past."},
1152                {RPCResult::Type::NUM, "total", "total number of addresses in both new/tried tables"},
1153            }},
1154        }},
1155        RPCExamples{HelpExampleCli("getaddrmaninfo", "") + HelpExampleRpc("getaddrmaninfo", "")},
1156        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue {
1157            AddrMan& addrman = EnsureAnyAddrman(request.context);
1158
1159            UniValue ret(UniValue::VOBJ);
1160            for (int n = 0; n < NET_MAX; ++n) {
1161                enum Network network = static_cast<enum Network>(n);
1162                if (network == NET_UNROUTABLE || network == NET_INTERNAL) continue;
1163                UniValue obj(UniValue::VOBJ);
1164                obj.pushKV("new", addrman.Size(network, true));
1165                obj.pushKV("tried", addrman.Size(network, false));
1166                obj.pushKV("total", addrman.Size(network));
1167                ret.pushKV(GetNetworkName(network), std::move(obj));
1168            }
1169            UniValue obj(UniValue::VOBJ);
1170            obj.pushKV("new", addrman.Size(std::nullopt, true));
1171            obj.pushKV("tried", addrman.Size(std::nullopt, false));
1172            obj.pushKV("total", addrman.Size());
1173            ret.pushKV("all_networks", std::move(obj));
1174            return ret;
1175        },
1176    };
1177}
1178
1179static RPCMethod exportasmap()
1180{
1181    return RPCMethod{
1182        "exportasmap",
1183        "Export the embedded ASMap data to a file. Any existing file at the path will be overwritten.\n",
1184        {
1185            {"path", RPCArg::Type::STR, RPCArg::Optional::NO, "Path to the output file. If relative, will be prefixed by datadir."},
1186        },
1187        RPCResult{
1188            RPCResult::Type::OBJ, "", "",
1189            {
1190                {RPCResult::Type::STR, "path", "the absolute path that the ASMap data was written to"},
1191                {RPCResult::Type::NUM, "bytes_written", "the number of bytes written to the file"},
1192                {RPCResult::Type::STR_HEX, "file_hash", "the SHA256 hash of the exported ASMap data"},
1193            }
1194        },
1195        RPCExamples{
1196            HelpExampleCli("exportasmap", "\"asmap.dat\"") + HelpExampleRpc("exportasmap", "\"asmap.dat\"")},
1197        [&](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue {
1198#ifndef ENABLE_EMBEDDED_ASMAP
1199            throw JSONRPCError(RPC_MISC_ERROR, "No embedded ASMap data available");
1200#else
1201            if (node::data::ip_asn.empty() || !CheckStandardAsmap(node::data::ip_asn)) {
1202                throw JSONRPCError(RPC_MISC_ERROR, "Embedded ASMap data appears to be corrupted");
1203            }
1204
1205            const ArgsManager& args{EnsureAnyArgsman(request.context)};
1206            const fs::path export_path{fsbridge::AbsPathJoin(args.GetDataDirNet(), fs::u8path(self.Arg<std::string_view>("path")))};
1207
1208            AutoFile file{fsbridge::fopen(export_path, "wb")};
1209            if (file.IsNull()) {
1210                throw JSONRPCError(RPC_MISC_ERROR, strprintf("Failed to open asmap file: %s", fs::PathToString(export_path)));
1211            }
1212
1213            file << node::data::ip_asn;
1214
1215            if (file.fclose() != 0) {
1216                throw JSONRPCError(RPC_MISC_ERROR, strprintf("Failed to close asmap file: %s", fs::PathToString(export_path)));
1217            }
1218
1219            UniValue result(UniValue::VOBJ);
1220            result.pushKV("path", export_path.utf8string());
1221            result.pushKV("bytes_written", node::data::ip_asn.size());
1222            result.pushKV("file_hash", HexStr(AsmapVersion(node::data::ip_asn)));
1223            return result;
1224#endif
1225        },
1226    };
1227}
1228
1229UniValue AddrmanEntryToJSON(const AddrInfo& info, const CConnman& connman)
1230{
1231    UniValue ret(UniValue::VOBJ);
1232    ret.pushKV("address", info.ToStringAddr());
1233    const uint32_t mapped_as{connman.GetMappedAS(info)};
1234    if (mapped_as) {
1235        ret.pushKV("mapped_as", mapped_as);
1236    }
1237    ret.pushKV("port", info.GetPort());
1238    ret.pushKV("services", static_cast<std::underlying_type_t<decltype(info.nServices)>>(info.nServices));
1239    ret.pushKV("time", TicksSinceEpoch<std::chrono::seconds>(info.nTime));
1240    ret.pushKV("network", GetNetworkName(info.GetNetClass()));
1241    ret.pushKV("source", info.source.ToStringAddr());
1242    ret.pushKV("source_network", GetNetworkName(info.source.GetNetClass()));
1243    const uint32_t source_mapped_as{connman.GetMappedAS(info.source)};
1244    if (source_mapped_as) {
1245        ret.pushKV("source_mapped_as", source_mapped_as);
1246    }
1247    return ret;
1248}
1249
1250UniValue AddrmanTableToJSON(const std::vector<std::pair<AddrInfo, AddressPosition>>& tableInfos, const CConnman& connman)