375 lines
14 KiB
C++
Executable file
375 lines
14 KiB
C++
Executable file
// Copyright (c) 2011-2016 The Cryptonote developers
|
|
// Distributed under the MIT/X11 software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include <boost/optional.hpp>
|
|
#include <boost/program_options.hpp>
|
|
|
|
#include <System/ContextGroup.h>
|
|
#include <System/ContextGroupTimeout.h>
|
|
#include <System/Dispatcher.h>
|
|
#include <System/Event.h>
|
|
#include <System/InterruptedException.h>
|
|
#include <System/Ipv4Address.h>
|
|
#include <System/Ipv4Resolver.h>
|
|
#include <System/TcpConnection.h>
|
|
#include <System/TcpConnector.h>
|
|
#include <System/Timer.h>
|
|
|
|
#include "Common/CommandLine.h"
|
|
#include "Common/StringTools.h"
|
|
#include "crypto/crypto.h"
|
|
#include "P2p/P2pProtocolDefinitions.h"
|
|
#include "P2p/LevinProtocol.h"
|
|
#include "Rpc/CoreRpcServerCommandsDefinitions.h"
|
|
#include "Rpc/HttpClient.h"
|
|
#include "Serialization/SerializationTools.h"
|
|
#include "version.h"
|
|
|
|
namespace po = boost::program_options;
|
|
using namespace CryptoNote;
|
|
|
|
#ifndef ENDL
|
|
#define ENDL std::endl
|
|
#endif
|
|
|
|
namespace {
|
|
const command_line::arg_descriptor<std::string, true> arg_ip = {"ip", "set ip"};
|
|
const command_line::arg_descriptor<uint16_t> arg_port = { "port", "set port" };
|
|
const command_line::arg_descriptor<uint16_t> arg_rpc_port = {"rpc_port", "set rpc port"};
|
|
const command_line::arg_descriptor<uint32_t, true> arg_timeout = {"timeout", "set timeout"};
|
|
const command_line::arg_descriptor<std::string> arg_priv_key = {"private_key", "private key to subscribe debug command", "", true};
|
|
const command_line::arg_descriptor<uint64_t> arg_peer_id = {"peer_id", "peer_id if known(if not - will be requested)", 0};
|
|
const command_line::arg_descriptor<bool> arg_generate_keys = {"generate_keys_pair", "generate private and public keys pair"};
|
|
const command_line::arg_descriptor<bool> arg_request_stat_info = {"request_stat_info", "request statistics information"};
|
|
const command_line::arg_descriptor<bool> arg_request_net_state = {"request_net_state", "request network state information (peer list, connections count)"};
|
|
const command_line::arg_descriptor<bool> arg_get_daemon_info = {"rpc_get_daemon_info", "request daemon state info vie rpc (--rpc_port option should be set ).", "", true};
|
|
}
|
|
|
|
struct response_schema {
|
|
std::string status;
|
|
std::string COMMAND_REQUEST_STAT_INFO_status;
|
|
std::string COMMAND_REQUEST_NETWORK_STATE_status;
|
|
boost::optional<COMMAND_REQUEST_STAT_INFO::response> si_rsp;
|
|
boost::optional<COMMAND_REQUEST_NETWORK_STATE::response> ns_rsp;
|
|
};
|
|
|
|
void withTimeout(System::Dispatcher& dispatcher, unsigned timeout, std::function<void()> f) {
|
|
std::string result;
|
|
System::ContextGroup cg(dispatcher);
|
|
System::ContextGroupTimeout cgTimeout(dispatcher, cg, std::chrono::milliseconds(timeout));
|
|
|
|
cg.spawn([&] {
|
|
try {
|
|
f();
|
|
} catch (System::InterruptedException&) {
|
|
result = "Operation timeout";
|
|
} catch (std::exception& e) {
|
|
result = e.what();
|
|
}
|
|
});
|
|
|
|
cg.wait();
|
|
|
|
if (!result.empty()) {
|
|
throw std::runtime_error(result);
|
|
}
|
|
}
|
|
|
|
|
|
std::ostream& get_response_schema_as_json(std::ostream& ss, response_schema &rs) {
|
|
|
|
ss << "{" << ENDL
|
|
<< " \"status\": \"" << rs.status << "\"," << ENDL
|
|
<< " \"COMMAND_REQUEST_NETWORK_STATE_status\": \"" << rs.COMMAND_REQUEST_NETWORK_STATE_status << "\"," << ENDL
|
|
<< " \"COMMAND_REQUEST_STAT_INFO_status\": \"" << rs.COMMAND_REQUEST_STAT_INFO_status << "\"";
|
|
|
|
if (rs.si_rsp.is_initialized()) {
|
|
ss << "," << ENDL << " \"si_rsp\": " << storeToJson(rs.si_rsp.get());
|
|
}
|
|
|
|
if (rs.ns_rsp.is_initialized()) {
|
|
const auto& networkState = rs.ns_rsp.get();
|
|
|
|
ss << "," << ENDL << " \"ns_rsp\": {" << ENDL
|
|
<< " \"local_time\": " << networkState.local_time << "," << ENDL
|
|
<< " \"my_id\": \"" << networkState.my_id << "\"," << ENDL
|
|
<< " \"connections_list\": [" << ENDL;
|
|
|
|
size_t i = 0;
|
|
for (const connection_entry &ce : networkState.connections_list) {
|
|
ss << " {\"peer_id\": \"" << ce.id << "\", \"ip\": \"" << Common::ipAddressToString(ce.adr.ip) << "\", \"port\": " << ce.adr.port << ", \"is_income\": " << ce.is_income << "}";
|
|
if (networkState.connections_list.size() - 1 != i)
|
|
ss << ",";
|
|
ss << ENDL;
|
|
i++;
|
|
}
|
|
ss << " ]," << ENDL;
|
|
ss << " \"local_peerlist_white\": [" << ENDL;
|
|
i = 0;
|
|
for (const PeerlistEntry &pe : networkState.local_peerlist_white) {
|
|
ss << " {\"peer_id\": \"" << pe.id << "\", \"ip\": \"" << Common::ipAddressToString(pe.adr.ip) << "\", \"port\": " << pe.adr.port << ", \"last_seen\": " << networkState.local_time - pe.last_seen << "}";
|
|
if (networkState.local_peerlist_white.size() - 1 != i)
|
|
ss << ",";
|
|
ss << ENDL;
|
|
i++;
|
|
}
|
|
ss << " ]," << ENDL;
|
|
|
|
ss << " \"local_peerlist_gray\": [" << ENDL;
|
|
i = 0;
|
|
for (const PeerlistEntry &pe : networkState.local_peerlist_gray) {
|
|
ss << " {\"peer_id\": \"" << pe.id << "\", \"ip\": \"" << Common::ipAddressToString(pe.adr.ip) << "\", \"port\": " << pe.adr.port << ", \"last_seen\": " << networkState.local_time - pe.last_seen << "}";
|
|
if (networkState.local_peerlist_gray.size() - 1 != i)
|
|
ss << ",";
|
|
ss << ENDL;
|
|
i++;
|
|
}
|
|
ss << " ]" << ENDL << " }" << ENDL;
|
|
}
|
|
|
|
ss << "}";
|
|
|
|
return ss;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------
|
|
bool print_COMMAND_REQUEST_STAT_INFO(const COMMAND_REQUEST_STAT_INFO::response &si) {
|
|
std::cout << " ------ COMMAND_REQUEST_STAT_INFO ------ " << ENDL;
|
|
std::cout << "Version: " << si.version << ENDL;
|
|
std::cout << "OS Version: " << si.os_version << ENDL;
|
|
std::cout << "Connections: " << si.connections_count << ENDL;
|
|
std::cout << "INC Connections: " << si.incoming_connections_count << ENDL;
|
|
|
|
|
|
std::cout << "Tx pool size: " << si.payload_info.tx_pool_size << ENDL;
|
|
std::cout << "BC height: " << si.payload_info.blockchain_height << ENDL;
|
|
std::cout << "Mining speed: " << si.payload_info.mining_speed << ENDL;
|
|
std::cout << "Alternative blocks: " << si.payload_info.alternative_blocks << ENDL;
|
|
std::cout << "Top block id: " << si.payload_info.top_block_id_str << ENDL;
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------------------------------------------
|
|
bool print_COMMAND_REQUEST_NETWORK_STATE(const COMMAND_REQUEST_NETWORK_STATE::response &ns) {
|
|
std::cout << " ------ COMMAND_REQUEST_NETWORK_STATE ------ " << ENDL;
|
|
std::cout << "Peer id: " << ns.my_id << ENDL;
|
|
std::cout << "Active connections:" << ENDL;
|
|
|
|
for (const connection_entry &ce : ns.connections_list) {
|
|
std::cout << ce.id << "\t" << ce.adr << (ce.is_income ? "(INC)" : "(OUT)") << ENDL;
|
|
}
|
|
|
|
std::cout << "Peer list white:" << ns.my_id << ENDL;
|
|
for (const PeerlistEntry &pe : ns.local_peerlist_white) {
|
|
std::cout << pe.id << "\t" << pe.adr << "\t" << Common::timeIntervalToString(ns.local_time - pe.last_seen) << ENDL;
|
|
}
|
|
|
|
std::cout << "Peer list gray:" << ns.my_id << ENDL;
|
|
for (const PeerlistEntry &pe : ns.local_peerlist_gray) {
|
|
std::cout << pe.id << "\t" << pe.adr << "\t" << Common::timeIntervalToString(ns.local_time - pe.last_seen) << ENDL;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------------------------------------------
|
|
bool handle_get_daemon_info(po::variables_map& vm) {
|
|
if(!command_line::has_arg(vm, arg_rpc_port)) {
|
|
std::cout << "ERROR: rpc port not set" << ENDL;
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
System::Dispatcher dispatcher;
|
|
HttpClient httpClient(dispatcher, command_line::get_arg(vm, arg_ip), command_line::get_arg(vm, arg_rpc_port));
|
|
|
|
CryptoNote::COMMAND_RPC_GET_INFO::request req;
|
|
CryptoNote::COMMAND_RPC_GET_INFO::response res;
|
|
|
|
invokeJsonCommand(httpClient, "/getinfo", req, res); // TODO: timeout
|
|
|
|
std::cout << "OK" << ENDL
|
|
<< "height: " << res.height << ENDL
|
|
<< "difficulty: " << res.difficulty << ENDL
|
|
<< "tx_count: " << res.tx_count << ENDL
|
|
<< "tx_pool_size: " << res.tx_pool_size << ENDL
|
|
<< "alt_blocks_count: " << res.alt_blocks_count << ENDL
|
|
<< "outgoing_connections_count: " << res.outgoing_connections_count << ENDL
|
|
<< "incoming_connections_count: " << res.incoming_connections_count << ENDL
|
|
<< "white_peerlist_size: " << res.white_peerlist_size << ENDL
|
|
<< "grey_peerlist_size: " << res.grey_peerlist_size << ENDL;
|
|
|
|
} catch (const std::exception& e) {
|
|
std::cout << "ERROR: " << e.what() << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------------------------------------------
|
|
bool handle_request_stat(po::variables_map& vm, PeerIdType peer_id) {
|
|
if(!command_line::has_arg(vm, arg_priv_key)) {
|
|
std::cout << "{" << ENDL << " \"status\": \"ERROR: " << "secret key not set \"" << ENDL << "}";
|
|
return false;
|
|
}
|
|
|
|
Crypto::SecretKey prvk;
|
|
if (!Common::podFromHex(command_line::get_arg(vm, arg_priv_key), prvk)) {
|
|
std::cout << "{" << ENDL << " \"status\": \"ERROR: " << "wrong secret key set \"" << ENDL << "}";
|
|
return false;
|
|
}
|
|
|
|
response_schema rs;
|
|
unsigned timeout = command_line::get_arg(vm, arg_timeout);
|
|
|
|
try {
|
|
System::Dispatcher dispatcher;
|
|
System::TcpConnector connector(dispatcher);
|
|
System::Ipv4Resolver resolver(dispatcher);
|
|
|
|
std::cout << "Connecting to " << command_line::get_arg(vm, arg_ip) << ":" << command_line::get_arg(vm, arg_port) << ENDL;
|
|
|
|
auto addr = resolver.resolve(command_line::get_arg(vm, arg_ip));
|
|
|
|
System::TcpConnection connection;
|
|
|
|
withTimeout(dispatcher, timeout, [&] {
|
|
connection = connector.connect(addr, command_line::get_arg(vm, arg_port));
|
|
});
|
|
|
|
rs.status = "OK";
|
|
|
|
LevinProtocol levin(connection);
|
|
|
|
if (!peer_id) {
|
|
COMMAND_REQUEST_PEER_ID::request req;
|
|
COMMAND_REQUEST_PEER_ID::response rsp;
|
|
withTimeout(dispatcher, timeout, [&] {
|
|
levin.invoke(COMMAND_REQUEST_PEER_ID::ID, req, rsp);
|
|
});
|
|
peer_id = rsp.my_id;
|
|
}
|
|
|
|
proof_of_trust pot;
|
|
pot.peer_id = peer_id;
|
|
pot.time = time(NULL);
|
|
Crypto::PublicKey pubk;
|
|
Common::podFromHex(P2P_STAT_TRUSTED_PUB_KEY, pubk);
|
|
Crypto::Hash h = get_proof_of_trust_hash(pot);
|
|
Crypto::generate_signature(h, pubk, prvk, pot.sign);
|
|
|
|
if (command_line::get_arg(vm, arg_request_stat_info)) {
|
|
COMMAND_REQUEST_STAT_INFO::request req;
|
|
COMMAND_REQUEST_STAT_INFO::response res;
|
|
|
|
req.tr = pot;
|
|
|
|
try {
|
|
withTimeout(dispatcher, timeout, [&] {
|
|
levin.invoke(COMMAND_REQUEST_STAT_INFO::ID, req, res);
|
|
});
|
|
rs.si_rsp = std::move(res);
|
|
rs.COMMAND_REQUEST_STAT_INFO_status = "OK";
|
|
} catch (const std::exception &e) {
|
|
std::stringstream ss;
|
|
ss << "ERROR: Failed to invoke remote command COMMAND_REQUEST_STAT_INFO to "
|
|
<< command_line::get_arg(vm, arg_ip) << ":" << command_line::get_arg(vm, arg_port)
|
|
<< " - " << e.what();
|
|
rs.COMMAND_REQUEST_STAT_INFO_status = ss.str();
|
|
}
|
|
}
|
|
|
|
if (command_line::get_arg(vm, arg_request_net_state)) {
|
|
++pot.time;
|
|
h = get_proof_of_trust_hash(pot);
|
|
Crypto::generate_signature(h, pubk, prvk, pot.sign);
|
|
COMMAND_REQUEST_NETWORK_STATE::request req{ pot };
|
|
COMMAND_REQUEST_NETWORK_STATE::response res;
|
|
|
|
try {
|
|
withTimeout(dispatcher, timeout, [&] {
|
|
levin.invoke(COMMAND_REQUEST_NETWORK_STATE::ID, req, res);
|
|
});
|
|
rs.ns_rsp = std::move(res);
|
|
rs.COMMAND_REQUEST_NETWORK_STATE_status = "OK";
|
|
} catch (const std::exception &e) {
|
|
std::stringstream ss;
|
|
ss << "ERROR: Failed to invoke remote command COMMAND_REQUEST_NETWORK_STATE to "
|
|
<< command_line::get_arg(vm, arg_ip) << ":" << command_line::get_arg(vm, arg_port)
|
|
<< " - " << e.what();
|
|
rs.COMMAND_REQUEST_NETWORK_STATE_status = ss.str();
|
|
}
|
|
}
|
|
} catch (const std::exception& e) {
|
|
std::cout << "ERROR: " << e.what() << std::endl;
|
|
return false;
|
|
}
|
|
|
|
get_response_schema_as_json(std::cout, rs) << std::endl;
|
|
return true;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------
|
|
bool generate_and_print_keys() {
|
|
Crypto::PublicKey pk;
|
|
Crypto::SecretKey sk;
|
|
generate_keys(pk, sk);
|
|
std::cout << "PUBLIC KEY: " << Common::podToHex(pk) << ENDL
|
|
<< "PRIVATE KEY: " << Common::podToHex(sk);
|
|
return true;
|
|
}
|
|
|
|
int main(int argc, char *argv[]) {
|
|
// Declare the supported options.
|
|
po::options_description desc_general("General options");
|
|
command_line::add_arg(desc_general, command_line::arg_help);
|
|
|
|
po::options_description desc_params("Connectivity options");
|
|
command_line::add_arg(desc_params, arg_ip);
|
|
command_line::add_arg(desc_params, arg_port);
|
|
command_line::add_arg(desc_params, arg_rpc_port);
|
|
command_line::add_arg(desc_params, arg_timeout);
|
|
command_line::add_arg(desc_params, arg_request_stat_info);
|
|
command_line::add_arg(desc_params, arg_request_net_state);
|
|
command_line::add_arg(desc_params, arg_generate_keys);
|
|
command_line::add_arg(desc_params, arg_peer_id);
|
|
command_line::add_arg(desc_params, arg_priv_key);
|
|
command_line::add_arg(desc_params, arg_get_daemon_info);
|
|
|
|
po::options_description desc_all;
|
|
desc_all.add(desc_general).add(desc_params);
|
|
|
|
po::variables_map vm;
|
|
bool r = command_line::handle_error_helper(desc_all, [&]() {
|
|
po::store(command_line::parse_command_line(argc, argv, desc_general, true), vm);
|
|
if (command_line::get_arg(vm, command_line::arg_help))
|
|
{
|
|
std::cout << desc_all << ENDL;
|
|
return false;
|
|
}
|
|
|
|
po::store(command_line::parse_command_line(argc, argv, desc_params, false), vm);
|
|
po::notify(vm);
|
|
|
|
return true;
|
|
});
|
|
|
|
if (!r)
|
|
return 1;
|
|
|
|
if (command_line::has_arg(vm, arg_request_stat_info) || command_line::has_arg(vm, arg_request_net_state)) {
|
|
return handle_request_stat(vm, command_line::get_arg(vm, arg_peer_id)) ? 0 : 1;
|
|
}
|
|
|
|
if (command_line::has_arg(vm, arg_get_daemon_info)) {
|
|
return handle_get_daemon_info(vm) ? 0 : 1;
|
|
}
|
|
|
|
if (command_line::has_arg(vm, arg_generate_keys)) {
|
|
return generate_and_print_keys() ? 0 : 1;
|
|
}
|
|
|
|
std::cerr << "Not enough arguments." << ENDL;
|
|
std::cerr << desc_all << ENDL;
|
|
return 1;
|
|
}
|