Hush Full Node software. We were censored from Github, this is where all development happens now.
https://hush.is
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
686 lines
29 KiB
686 lines
29 KiB
// Copyright (c) 2009-2014 The Bitcoin Core developers
|
|
// Copyright (c) 2019-2020 The Hush developers
|
|
// Distributed under the GPLv3 software license, see the accompanying
|
|
// file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html
|
|
|
|
/******************************************************************************
|
|
* Copyright © 2014-2019 The SuperNET Developers. *
|
|
* *
|
|
* See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at *
|
|
* the top-level directory of this distribution for the individual copyright *
|
|
* holder information and the developer policies on copyright and licensing. *
|
|
* *
|
|
* Unless otherwise agreed in a custom licensing agreement, no part of the *
|
|
* SuperNET software, including this file may be copied, modified, propagated *
|
|
* or distributed except according to the terms contained in the LICENSE file *
|
|
* *
|
|
* Removal or modification of this copyright notice is prohibited. *
|
|
* *
|
|
******************************************************************************/
|
|
|
|
#include "rpc/server.h"
|
|
|
|
#include "clientversion.h"
|
|
#include "main.h"
|
|
#include "net.h"
|
|
#include "netbase.h"
|
|
#include "protocol.h"
|
|
#include "sync.h"
|
|
#include "timedata.h"
|
|
#include "util.h"
|
|
#include "version.h"
|
|
#include "deprecation.h"
|
|
#include "hush/utiltls.h"
|
|
|
|
#include <boost/foreach.hpp>
|
|
|
|
#include <univalue.h>
|
|
|
|
using namespace std;
|
|
using namespace hush;
|
|
|
|
UniValue getconnectioncount(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
if (fHelp || params.size() != 0)
|
|
throw runtime_error(
|
|
"getconnectioncount\n"
|
|
"\nReturns the number of connections to other nodes.\n"
|
|
"\nbResult:\n"
|
|
"n (numeric) The connection count\n"
|
|
"\nExamples:\n"
|
|
+ HelpExampleCli("getconnectioncount", "")
|
|
+ HelpExampleRpc("getconnectioncount", "")
|
|
);
|
|
|
|
LOCK2(cs_main, cs_vNodes);
|
|
|
|
return (int)vNodes.size();
|
|
}
|
|
|
|
UniValue ping(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
if (fHelp || params.size() != 0)
|
|
throw runtime_error(
|
|
"ping\n"
|
|
"\nRequests that a ping be sent to all other nodes, to measure ping time.\n"
|
|
"Results provided in getpeerinfo, pingtime and pingwait fields are decimal seconds.\n"
|
|
"Ping command is handled in queue with all other commands, so it measures processing backlog, not just network ping.\n"
|
|
"\nExamples:\n"
|
|
+ HelpExampleCli("ping", "")
|
|
+ HelpExampleRpc("ping", "")
|
|
);
|
|
|
|
// Request that each node send a ping during next message processing pass
|
|
LOCK2(cs_main, cs_vNodes);
|
|
|
|
BOOST_FOREACH(CNode* pNode, vNodes) {
|
|
pNode->fPingQueued = true;
|
|
}
|
|
|
|
return NullUniValue;
|
|
}
|
|
|
|
UniValue getpeerinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
if (fHelp || params.size() != 0)
|
|
throw runtime_error(
|
|
"getpeerinfo\n"
|
|
"\nReturns data about each connected network node as a json array of objects.\n"
|
|
"\nbResult:\n"
|
|
"[\n"
|
|
" {\n"
|
|
" \"id\": n, (numeric) Peer index\n"
|
|
" \"addr\":\"host:port\", (string) The ip address and port of the peer\n"
|
|
" \"addrlocal\":\"ip:port\", (string) local address\n"
|
|
" \"services\":\"xxxxxxxxxxxxxxxx\", (string) The services offered\n"
|
|
" \"tls_established\": true:false, (boolean) Status of TLS connection\n"
|
|
" \"lastsend\": ttt, (numeric) The time in seconds since epoch (Jan 1 1970 GMT) of the last send\n"
|
|
" \"lastrecv\": ttt, (numeric) The time in seconds since epoch (Jan 1 1970 GMT) of the last receive\n"
|
|
" \"bytessent\": n, (numeric) The total bytes sent\n"
|
|
" \"bytesrecv\": n, (numeric) The total bytes received\n"
|
|
" \"conntime\": ttt, (numeric) The connection time in seconds since epoch (Jan 1 1970 GMT)\n"
|
|
" \"timeoffset\": ttt, (numeric) The time offset in seconds (deprecated, always 0)\n"
|
|
" \"pingtime\": n, (numeric) ping time\n"
|
|
" \"pingwait\": n, (numeric) ping wait\n"
|
|
" \"version\": v, (numeric) The peer version, such as 170002\n"
|
|
" \"subver\": \"/MagicBean:x.y.z[-v]/\", (string) The string version\n"
|
|
" \"inbound\": true|false, (boolean) Inbound (true) or Outbound (false)\n"
|
|
" \"startingheight\": n, (numeric) The starting height (block) of the peer\n"
|
|
" \"banscore\": n, (numeric) The ban score\n"
|
|
" \"synced_headers\": n, (numeric) The last header we have in common with this peer\n"
|
|
" \"synced_blocks\": n, (numeric) The last block we have in common with this peer\n"
|
|
" \"inflight\": [\n"
|
|
" n, (numeric) The heights of blocks we're currently asking from this peer\n"
|
|
" ...\n"
|
|
" ]\n"
|
|
" }\n"
|
|
" ,...\n"
|
|
"]\n"
|
|
"\nExamples:\n"
|
|
+ HelpExampleCli("getpeerinfo", "")
|
|
+ HelpExampleRpc("getpeerinfo", "")
|
|
);
|
|
|
|
LOCK(cs_main);
|
|
|
|
vector<CNodeStats> vstats;
|
|
CopyNodeStats(vstats);
|
|
|
|
UniValue ret(UniValue::VARR);
|
|
|
|
BOOST_FOREACH(const CNodeStats& stats, vstats) {
|
|
UniValue obj(UniValue::VOBJ);
|
|
CNodeStateStats statestats;
|
|
bool fStateStats = GetNodeStateStats(stats.nodeid, statestats);
|
|
obj.push_back(Pair("id", stats.nodeid));
|
|
obj.push_back(Pair("addr", stats.addrName));
|
|
if (!(stats.addrLocal.empty()))
|
|
obj.push_back(Pair("addrlocal", stats.addrLocal));
|
|
// if (stats.addrBind.IsValid())
|
|
// obj.push_back(Pair("addrbind", stats.addrBind.ToString()));
|
|
if (stats.m_mapped_as != 0) {
|
|
obj.push_back(Pair("mapped_as", uint64_t(stats.m_mapped_as)));
|
|
}
|
|
obj.push_back(Pair("services", strprintf("%016x", stats.nServices)));
|
|
obj.push_back(Pair("tls_established", stats.fTLSEstablished));
|
|
obj.push_back(Pair("lastsend", stats.nLastSend));
|
|
obj.push_back(Pair("lastrecv", stats.nLastRecv));
|
|
obj.push_back(Pair("bytessent", stats.nSendBytes));
|
|
obj.push_back(Pair("bytesrecv", stats.nRecvBytes));
|
|
obj.push_back(Pair("conntime", stats.nTimeConnected));
|
|
obj.push_back(Pair("timeoffset", 0));
|
|
obj.push_back(Pair("pingtime", stats.dPingTime));
|
|
if (stats.dPingWait > 0.0)
|
|
obj.push_back(Pair("pingwait", stats.dPingWait));
|
|
obj.push_back(Pair("version", stats.nVersion));
|
|
// Use the sanitized form of subver here, to avoid tricksy remote peers from
|
|
// corrupting or modifying the JSON output by putting special characters in
|
|
// their ver message.
|
|
obj.push_back(Pair("subver", stats.cleanSubVer));
|
|
obj.push_back(Pair("inbound", stats.fInbound));
|
|
obj.push_back(Pair("startingheight", stats.nStartingHeight));
|
|
if (fStateStats) {
|
|
obj.push_back(Pair("banscore", statestats.nMisbehavior));
|
|
obj.push_back(Pair("synced_headers", statestats.nSyncHeight));
|
|
obj.push_back(Pair("synced_blocks", statestats.nCommonHeight));
|
|
UniValue heights(UniValue::VARR);
|
|
BOOST_FOREACH(int height, statestats.vHeightInFlight) {
|
|
heights.push_back(height);
|
|
}
|
|
obj.push_back(Pair("inflight", heights));
|
|
}
|
|
obj.push_back(Pair("whitelisted", stats.fWhitelisted));
|
|
|
|
ret.push_back(obj);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int32_t KOMODO_LONGESTCHAIN;
|
|
int32_t komodo_longestchain()
|
|
{
|
|
static int32_t depth;
|
|
int32_t ht,n=0,num=0,maxheight=0,height = 0;
|
|
if ( depth < 0 )
|
|
depth = 0;
|
|
if ( depth == 0 )
|
|
{
|
|
depth++;
|
|
vector<CNodeStats> vstats;
|
|
{
|
|
//LOCK(cs_main);
|
|
CopyNodeStats(vstats);
|
|
}
|
|
BOOST_FOREACH(const CNodeStats& stats, vstats)
|
|
{
|
|
//fprintf(stderr,"komodo_longestchain iter.%d\n",n);
|
|
CNodeStateStats statestats;
|
|
bool fStateStats = GetNodeStateStats(stats.nodeid,statestats);
|
|
if ( statestats.nSyncHeight < 0 )
|
|
continue;
|
|
ht = 0;
|
|
if ( stats.nStartingHeight > ht )
|
|
ht = stats.nStartingHeight;
|
|
if ( statestats.nSyncHeight > ht )
|
|
ht = statestats.nSyncHeight;
|
|
if ( statestats.nCommonHeight > ht )
|
|
ht = statestats.nCommonHeight;
|
|
if ( maxheight == 0 || ht > maxheight*1.01 )
|
|
maxheight = ht, num = 1;
|
|
else if ( ht > maxheight*0.99 )
|
|
num++;
|
|
if ( ht > height )
|
|
height = ht;
|
|
}
|
|
depth--;
|
|
if ( num > (n >> 1) )
|
|
{
|
|
if ( 0 && height != KOMODO_LONGESTCHAIN )
|
|
fprintf(stderr,"set %s KOMODO_LONGESTCHAIN <- %d\n",ASSETCHAINS_SYMBOL,height);
|
|
KOMODO_LONGESTCHAIN = height;
|
|
return(height);
|
|
}
|
|
KOMODO_LONGESTCHAIN = 0;
|
|
}
|
|
return(KOMODO_LONGESTCHAIN);
|
|
}
|
|
|
|
UniValue addnode(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
string strCommand;
|
|
if (params.size() == 2)
|
|
strCommand = params[1].get_str();
|
|
if (fHelp || params.size() != 2 ||
|
|
(strCommand != "onetry" && strCommand != "add" && strCommand != "remove"))
|
|
throw runtime_error(
|
|
"addnode \"node\" \"add|remove|onetry\"\n"
|
|
"\nAttempts add or remove a node from the addnode list.\n"
|
|
"Or try a connection to a node once.\n"
|
|
"\nArguments:\n"
|
|
"1. \"node\" (string, required) The node (see getpeerinfo for nodes)\n"
|
|
"2. \"command\" (string, required) 'add' to add a node to the list, 'remove' to remove a node from the list, 'onetry' to try a connection to the node once\n"
|
|
"\nExamples:\n"
|
|
+ HelpExampleCli("addnode", "\"192.168.0.6:8233\" \"onetry\"")
|
|
+ HelpExampleRpc("addnode", "\"192.168.0.6:8233\", \"onetry\"")
|
|
);
|
|
|
|
string strNode = params[0].get_str();
|
|
|
|
if (strCommand == "onetry")
|
|
{
|
|
CAddress addr;
|
|
OpenNetworkConnection(addr, NULL, strNode.c_str());
|
|
return NullUniValue;
|
|
}
|
|
|
|
LOCK(cs_vAddedNodes);
|
|
vector<string>::iterator it = vAddedNodes.begin();
|
|
for(; it != vAddedNodes.end(); it++)
|
|
if (strNode == *it)
|
|
break;
|
|
|
|
if (strCommand == "add")
|
|
{
|
|
if (it != vAddedNodes.end())
|
|
throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED, "Error: Node already added");
|
|
vAddedNodes.push_back(strNode);
|
|
}
|
|
else if(strCommand == "remove")
|
|
{
|
|
if (it == vAddedNodes.end())
|
|
throw JSONRPCError(RPC_CLIENT_NODE_NOT_ADDED, "Error: Node has not been added.");
|
|
vAddedNodes.erase(it);
|
|
}
|
|
|
|
return NullUniValue;
|
|
}
|
|
|
|
UniValue disconnectnode(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
if (fHelp || params.size() != 1)
|
|
throw runtime_error(
|
|
"disconnectnode \"node\" \n"
|
|
"\nImmediately disconnects from the specified node.\n"
|
|
"\nArguments:\n"
|
|
"1. \"node\" (string, required) The node (see getpeerinfo for nodes)\n"
|
|
"\nExamples:\n"
|
|
+ HelpExampleCli("disconnectnode", "\"192.168.0.6:8233\"")
|
|
+ HelpExampleRpc("disconnectnode", "\"192.168.0.6:8233\"")
|
|
);
|
|
|
|
CNode* pNode = FindNode(params[0].get_str());
|
|
if (pNode == NULL)
|
|
throw JSONRPCError(RPC_CLIENT_NODE_NOT_CONNECTED, "Node not found in connected nodes");
|
|
|
|
pNode->fDisconnect = true;
|
|
|
|
return NullUniValue;
|
|
}
|
|
|
|
UniValue getaddednodeinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
if (fHelp || params.size() < 1 || params.size() > 2)
|
|
throw runtime_error(
|
|
"getaddednodeinfo dns ( \"node\" )\n"
|
|
"\nReturns information about the given added node, or all added nodes\n"
|
|
"(note that onetry addnodes are not listed here)\n"
|
|
"If dns is false, only a list of added nodes will be provided,\n"
|
|
"otherwise connected information will also be available.\n"
|
|
"\nArguments:\n"
|
|
"1. dns (boolean, required) If false, only a list of added nodes will be provided, otherwise connected information will also be available.\n"
|
|
"2. \"node\" (string, optional) If provided, return information about this specific node, otherwise all nodes are returned.\n"
|
|
"\nResult:\n"
|
|
"[\n"
|
|
" {\n"
|
|
" \"addednode\" : \"192.168.0.201\", (string) The node ip address\n"
|
|
" \"connected\" : true|false, (boolean) If connected\n"
|
|
" \"addresses\" : [\n"
|
|
" {\n"
|
|
" \"address\" : \"192.168.0.201:8233\", (string) The Hush server host and port\n"
|
|
" \"connected\" : \"outbound\" (string) connection, inbound or outbound\n"
|
|
" }\n"
|
|
" ,...\n"
|
|
" ]\n"
|
|
" }\n"
|
|
" ,...\n"
|
|
"]\n"
|
|
"\nExamples:\n"
|
|
+ HelpExampleCli("getaddednodeinfo", "true")
|
|
+ HelpExampleCli("getaddednodeinfo", "true \"192.168.0.201\"")
|
|
+ HelpExampleRpc("getaddednodeinfo", "true, \"192.168.0.201\"")
|
|
);
|
|
|
|
bool fDns = params[0].get_bool();
|
|
|
|
list<string> laddedNodes(0);
|
|
if (params.size() == 1)
|
|
{
|
|
LOCK(cs_vAddedNodes);
|
|
BOOST_FOREACH(const std::string& strAddNode, vAddedNodes)
|
|
laddedNodes.push_back(strAddNode);
|
|
}
|
|
else
|
|
{
|
|
string strNode = params[1].get_str();
|
|
LOCK(cs_vAddedNodes);
|
|
BOOST_FOREACH(const std::string& strAddNode, vAddedNodes) {
|
|
if (strAddNode == strNode)
|
|
{
|
|
laddedNodes.push_back(strAddNode);
|
|
break;
|
|
}
|
|
}
|
|
if (laddedNodes.size() == 0)
|
|
throw JSONRPCError(RPC_CLIENT_NODE_NOT_ADDED, "Error: Node has not been added.");
|
|
}
|
|
|
|
UniValue ret(UniValue::VARR);
|
|
if (!fDns)
|
|
{
|
|
BOOST_FOREACH (const std::string& strAddNode, laddedNodes) {
|
|
UniValue obj(UniValue::VOBJ);
|
|
obj.push_back(Pair("addednode", strAddNode));
|
|
ret.push_back(obj);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
list<pair<string, vector<CService> > > laddedAddreses(0);
|
|
BOOST_FOREACH(const std::string& strAddNode, laddedNodes) {
|
|
vector<CService> vservNode(0);
|
|
if(Lookup(strAddNode.c_str(), vservNode, Params().GetDefaultPort(), fNameLookup, 0))
|
|
laddedAddreses.push_back(make_pair(strAddNode, vservNode));
|
|
else
|
|
{
|
|
UniValue obj(UniValue::VOBJ);
|
|
obj.push_back(Pair("addednode", strAddNode));
|
|
obj.push_back(Pair("connected", false));
|
|
UniValue addresses(UniValue::VARR);
|
|
obj.push_back(Pair("addresses", addresses));
|
|
}
|
|
}
|
|
|
|
LOCK(cs_vNodes);
|
|
for (list<pair<string, vector<CService> > >::iterator it = laddedAddreses.begin(); it != laddedAddreses.end(); it++)
|
|
{
|
|
UniValue obj(UniValue::VOBJ);
|
|
obj.push_back(Pair("addednode", it->first));
|
|
|
|
UniValue addresses(UniValue::VARR);
|
|
bool fConnected = false;
|
|
BOOST_FOREACH(const CService& addrNode, it->second) {
|
|
bool fFound = false;
|
|
UniValue node(UniValue::VOBJ);
|
|
node.push_back(Pair("address", addrNode.ToString()));
|
|
BOOST_FOREACH(CNode* pnode, vNodes) {
|
|
if (pnode->addr == addrNode)
|
|
{
|
|
fFound = true;
|
|
fConnected = true;
|
|
node.push_back(Pair("connected", pnode->fInbound ? "inbound" : "outbound"));
|
|
break;
|
|
}
|
|
}
|
|
if (!fFound)
|
|
node.push_back(Pair("connected", "false"));
|
|
addresses.push_back(node);
|
|
}
|
|
obj.push_back(Pair("connected", fConnected));
|
|
obj.push_back(Pair("addresses", addresses));
|
|
ret.push_back(obj);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
UniValue getnettotals(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
if (fHelp || params.size() > 0)
|
|
throw runtime_error(
|
|
"getnettotals\n"
|
|
"\nReturns information about network traffic, including bytes in, bytes out,\n"
|
|
"and current time.\n"
|
|
"\nResult:\n"
|
|
"{\n"
|
|
" \"totalbytesrecv\": n, (numeric) Total bytes received\n"
|
|
" \"totalbytessent\": n, (numeric) Total bytes sent\n"
|
|
" \"timemillis\": t (numeric) Total cpu time\n"
|
|
"}\n"
|
|
"\nExamples:\n"
|
|
+ HelpExampleCli("getnettotals", "")
|
|
+ HelpExampleRpc("getnettotals", "")
|
|
);
|
|
|
|
UniValue obj(UniValue::VOBJ);
|
|
obj.push_back(Pair("totalbytesrecv", CNode::GetTotalBytesRecv()));
|
|
obj.push_back(Pair("totalbytessent", CNode::GetTotalBytesSent()));
|
|
obj.push_back(Pair("timemillis", GetTimeMillis()));
|
|
return obj;
|
|
}
|
|
|
|
static UniValue GetNetworksInfo()
|
|
{
|
|
UniValue networks(UniValue::VARR);
|
|
for(int n=0; n<NET_MAX; ++n)
|
|
{
|
|
enum Network network = static_cast<enum Network>(n);
|
|
if(network == NET_UNROUTABLE)
|
|
continue;
|
|
proxyType proxy;
|
|
UniValue obj(UniValue::VOBJ);
|
|
GetProxy(network, proxy);
|
|
obj.push_back(Pair("name", GetNetworkName(network)));
|
|
obj.push_back(Pair("limited", IsLimited(network)));
|
|
obj.push_back(Pair("reachable", IsReachable(network)));
|
|
obj.push_back(Pair("proxy", proxy.IsValid() ? proxy.proxy.ToStringIPPort() : string()));
|
|
obj.push_back(Pair("proxy_randomize_credentials", proxy.randomize_credentials));
|
|
networks.push_back(obj);
|
|
}
|
|
return networks;
|
|
}
|
|
|
|
UniValue getdeprecationinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
const CChainParams& chainparams = Params();
|
|
if (fHelp || params.size() != 0 || chainparams.NetworkIDString() != "main")
|
|
throw runtime_error(
|
|
"getdeprecationinfo\n"
|
|
"Returns an object containing current version and deprecation block height. Applicable only on mainnet.\n"
|
|
"\nResult:\n"
|
|
"{\n"
|
|
" \"version\": xxxxx, (numeric) the server version\n"
|
|
" \"subversion\": \"/MagicBean:x.y.z[-v]/\", (string) the server subversion string\n"
|
|
" \"deprecationheight\": xxxxx, (numeric) the block height at which this version will deprecate and shut down\n"
|
|
"}\n"
|
|
"\nExamples:\n"
|
|
+ HelpExampleCli("getdeprecationinfo", "")
|
|
+ HelpExampleRpc("getdeprecationinfo", "")
|
|
);
|
|
|
|
UniValue obj(UniValue::VOBJ);
|
|
obj.push_back(Pair("version", CLIENT_VERSION));
|
|
obj.push_back(Pair("subversion",
|
|
FormatSubVersion(GetArg("-clientname","MagicBean"), CLIENT_VERSION, std::vector<string>())));
|
|
obj.push_back(Pair("deprecationheight", DEPRECATION_HEIGHT));
|
|
|
|
return obj;
|
|
}
|
|
|
|
UniValue getnetworkinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
if (fHelp || params.size() != 0)
|
|
throw runtime_error(
|
|
"getnetworkinfo\n"
|
|
"Returns an object containing various state info regarding P2P networking.\n"
|
|
"\nResult:\n"
|
|
"{\n"
|
|
" \"version\": xxxxx, (numeric) the server version\n"
|
|
" \"subversion\": \"/MagicBean:x.y.z[-v]/\", (string) the server subversion string\n"
|
|
" \"protocolversion\": xxxxx, (numeric) the protocol version\n"
|
|
" \"localservices\": \"xxxxxxxxxxxxxxxx\", (string) the services we offer to the network\n"
|
|
" \"timeoffset\": xxxxx, (numeric) the time offset (deprecated, always 0)\n"
|
|
" \"connections\": xxxxx, (numeric) the number of connections\n"
|
|
" \"tls_connections\": xxxxx, (numeric) the number of TLS connections\n"
|
|
" \"networks\": [ (array) information per network\n"
|
|
" {\n"
|
|
" \"name\": \"xxx\", (string) network (ipv4, ipv6 or onion)\n"
|
|
" \"limited\": true|false, (boolean) is the network limited using -onlynet?\n"
|
|
" \"reachable\": true|false, (boolean) is the network reachable?\n"
|
|
" \"proxy\": \"host:port\" (string) the proxy that is used for this network, or empty if none\n"
|
|
" }\n"
|
|
" ,...\n"
|
|
" ],\n"
|
|
" \"relayfee\": x.xxxxxxxx, (numeric) minimum relay fee for non-free transactions in " + CURRENCY_UNIT + "/kB\n"
|
|
" \"localaddresses\": [ (array) list of local addresses\n"
|
|
" {\n"
|
|
" \"address\": \"xxxx\", (string) network address\n"
|
|
" \"port\": xxx, (numeric) network port\n"
|
|
" \"score\": xxx (numeric) relative score\n"
|
|
" }\n"
|
|
" ,...\n"
|
|
" ]\n"
|
|
" \"warnings\": \"...\" (string) any network warnings (such as alert messages) \n"
|
|
"}\n"
|
|
"\nExamples:\n"
|
|
+ HelpExampleCli("getnetworkinfo", "")
|
|
+ HelpExampleRpc("getnetworkinfo", "")
|
|
);
|
|
|
|
LOCK(cs_main);
|
|
|
|
UniValue obj(UniValue::VOBJ);
|
|
obj.push_back(Pair("version", CLIENT_VERSION));
|
|
obj.push_back(Pair("subversion", strSubVersion));
|
|
obj.push_back(Pair("protocolversion",PROTOCOL_VERSION));
|
|
obj.push_back(Pair("localservices", strprintf("%016x", nLocalServices)));
|
|
obj.push_back(Pair("timeoffset", 0));
|
|
obj.push_back(Pair("connections", (int)vNodes.size()));
|
|
obj.push_back(Pair("tls_connections", (int)std::count_if(vNodes.begin(), vNodes.end(), [](CNode* n) {return n->ssl != NULL;})));
|
|
obj.push_back(Pair("networks", GetNetworksInfo()));
|
|
obj.push_back(Pair("relayfee", ValueFromAmount(::minRelayTxFee.GetFeePerK())));
|
|
UniValue localAddresses(UniValue::VARR);
|
|
{
|
|
LOCK(cs_mapLocalHost);
|
|
BOOST_FOREACH(const PAIRTYPE(CNetAddr, LocalServiceInfo) &item, mapLocalHost)
|
|
{
|
|
UniValue rec(UniValue::VOBJ);
|
|
rec.push_back(Pair("address", item.first.ToString()));
|
|
rec.push_back(Pair("port", item.second.nPort));
|
|
rec.push_back(Pair("score", item.second.nScore));
|
|
localAddresses.push_back(rec);
|
|
}
|
|
}
|
|
obj.push_back(Pair("localaddresses", localAddresses));
|
|
obj.push_back(Pair("warnings", GetWarnings("statusbar")));
|
|
return obj;
|
|
}
|
|
|
|
UniValue setban(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
string strCommand;
|
|
if (params.size() >= 2)
|
|
strCommand = params[1].get_str();
|
|
if (fHelp || params.size() < 2 ||
|
|
(strCommand != "add" && strCommand != "remove"))
|
|
throw runtime_error(
|
|
"setban \"ip(/netmask)\" \"add|remove\" (bantime) (absolute)\n"
|
|
"\nAttempts add or remove a IP/Subnet from the banned list.\n"
|
|
"\nArguments:\n"
|
|
"1. \"ip(/netmask)\" (string, required) The IP/Subnet (see getpeerinfo for nodes ip) with a optional netmask (default is /32 = single ip)\n"
|
|
"2. \"command\" (string, required) 'add' to add a IP/Subnet to the list, 'remove' to remove a IP/Subnet from the list\n"
|
|
"3. \"bantime\" (numeric, optional) 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)\n"
|
|
"4. \"absolute\" (boolean, optional) If set, the bantime must be a absolute timestamp in seconds since epoch (Jan 1 1970 GMT)\n"
|
|
"\nExamples:\n"
|
|
+ HelpExampleCli("setban", "\"192.168.0.6\" \"add\" 86400")
|
|
+ HelpExampleCli("setban", "\"192.168.0.0/24\" \"add\"")
|
|
+ HelpExampleRpc("setban", "\"192.168.0.6\", \"add\" 86400")
|
|
);
|
|
|
|
CSubNet subNet;
|
|
CNetAddr netAddr;
|
|
bool isSubnet = false;
|
|
|
|
if (params[0].get_str().find("/") != string::npos)
|
|
isSubnet = true;
|
|
|
|
if (!isSubnet)
|
|
netAddr = CNetAddr(params[0].get_str());
|
|
else
|
|
subNet = CSubNet(params[0].get_str());
|
|
|
|
if (! (isSubnet ? subNet.IsValid() : netAddr.IsValid()) )
|
|
throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED, "Error: Invalid IP/Subnet");
|
|
|
|
if (strCommand == "add")
|
|
{
|
|
if (isSubnet ? CNode::IsBanned(subNet) : CNode::IsBanned(netAddr))
|
|
throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED, "Error: IP/Subnet already banned");
|
|
|
|
int64_t banTime = 0; //use standard bantime if not specified
|
|
if (params.size() >= 3 && !params[2].isNull())
|
|
banTime = params[2].get_int64();
|
|
|
|
bool absolute = false;
|
|
if (params.size() == 4 && params[3].isTrue())
|
|
absolute = true;
|
|
|
|
isSubnet ? CNode::Ban(subNet, banTime, absolute) : CNode::Ban(netAddr, banTime, absolute);
|
|
|
|
//disconnect possible nodes
|
|
while(CNode *bannedNode = (isSubnet ? FindNode(subNet) : FindNode(netAddr)))
|
|
bannedNode->fDisconnect = true;
|
|
}
|
|
else if(strCommand == "remove")
|
|
{
|
|
if (!( isSubnet ? CNode::Unban(subNet) : CNode::Unban(netAddr) ))
|
|
throw JSONRPCError(RPC_MISC_ERROR, "Error: Unban failed");
|
|
}
|
|
|
|
return NullUniValue;
|
|
}
|
|
|
|
UniValue listbanned(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
if (fHelp || params.size() != 0)
|
|
throw runtime_error(
|
|
"listbanned\n"
|
|
"\nList all banned IPs/Subnets.\n"
|
|
"\nExamples:\n"
|
|
+ HelpExampleCli("listbanned", "")
|
|
+ HelpExampleRpc("listbanned", "")
|
|
);
|
|
|
|
std::map<CSubNet, int64_t> banMap;
|
|
CNode::GetBanned(banMap);
|
|
|
|
UniValue bannedAddresses(UniValue::VARR);
|
|
for (std::map<CSubNet, int64_t>::iterator it = banMap.begin(); it != banMap.end(); it++)
|
|
{
|
|
UniValue rec(UniValue::VOBJ);
|
|
rec.push_back(Pair("address", (*it).first.ToString()));
|
|
rec.push_back(Pair("banned_until", (*it).second));
|
|
bannedAddresses.push_back(rec);
|
|
}
|
|
|
|
return bannedAddresses;
|
|
}
|
|
|
|
UniValue clearbanned(const UniValue& params, bool fHelp, const CPubKey& mypk)
|
|
{
|
|
if (fHelp || params.size() != 0)
|
|
throw runtime_error(
|
|
"clearbanned\n"
|
|
"\nClear all banned IPs.\n"
|
|
"\nExamples:\n"
|
|
+ HelpExampleCli("clearbanned", "")
|
|
+ HelpExampleRpc("clearbanned", "")
|
|
);
|
|
|
|
CNode::ClearBanned();
|
|
|
|
return NullUniValue;
|
|
}
|
|
|
|
static const CRPCCommand commands[] =
|
|
{ // category name actor (function) okSafeMode
|
|
// --------------------- ------------------------ ----------------------- ----------
|
|
{ "network", "getconnectioncount", &getconnectioncount, true },
|
|
{ "network", "getdeprecationinfo", &getdeprecationinfo, true },
|
|
{ "network", "ping", &ping, true },
|
|
{ "network", "getpeerinfo", &getpeerinfo, true },
|
|
{ "network", "addnode", &addnode, true },
|
|
{ "network", "disconnectnode", &disconnectnode, true },
|
|
{ "network", "getaddednodeinfo", &getaddednodeinfo, true },
|
|
{ "network", "getnettotals", &getnettotals, true },
|
|
{ "network", "getnetworkinfo", &getnetworkinfo, true },
|
|
{ "network", "setban", &setban, true },
|
|
{ "network", "listbanned", &listbanned, true },
|
|
{ "network", "clearbanned", &clearbanned, true },
|
|
};
|
|
|
|
void RegisterNetRPCCommands(CRPCTable &tableRPC)
|
|
{
|
|
for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++)
|
|
tableRPC.appendCommand(commands[vcidx].name, &commands[vcidx]);
|
|
}
|
|
|