Merge pull request #243

51e3579 Fixed bug in static linking boost on MINGW (Thomas Winget)
f78bb00 Hopefully fixes build on Windows for real this time (Thomas Winget)
2b0583b Hopefully fixes build on Windows (Thomas Winget)
9dab105 DNS checkpoint loading for testnet should now be correct (Thomas Winget)
52f9629 sending commands to forked daemon works on testnet now (Thomas Winget)
76289d0 Fix tests building -- function signatures changed (Thomas Winget)
db53e19 revert stop_daemon method to use correct exit (Thomas Winget)
96cbecf RPC calls for background daemon added in (Thomas Winget)
9193d6f Daemonize changes pulled in -- daemon builds (Thomas Winget)

3 files changed, 286 insertions, 25 deletions

diff --git a/src/rpc/core_rpc_server.cpp b/src/rpc/core_rpc_server.cpp
index 7a41e9b9f..93e1f7a88 100644
--- a/src/rpc/core_rpc_server.cpp
+++ b/src/rpc/core_rpc_server.cpp
@@ -40,29 +40,10 @@ using namespace epee;
 #include "misc_language.h"
 #include "crypto/hash.h"
 #include "core_rpc_server_error_codes.h"
+#include "daemon/command_line_args.h"
 
 namespace cryptonote
 {
-  namespace
-  {
-    const command_line::arg_descriptor<std::string> arg_rpc_bind_ip   = {
-        "rpc-bind-ip"
-      , "IP for RPC server"
-      , "127.0.0.1"
-      };
-
-    const command_line::arg_descriptor<std::string> arg_rpc_bind_port = {
-        "rpc-bind-port"
-      , "Port for RPC server"
-      , std::to_string(config::RPC_DEFAULT_PORT)
-      };
-
-    const command_line::arg_descriptor<std::string> arg_testnet_rpc_bind_port = {
-        "testnet-rpc-bind-port"
-      , "Port for testnet RPC server"
-      , std::to_string(config::testnet::RPC_DEFAULT_PORT)
-      };
-  }
 
   //-----------------------------------------------------------------------------------
   void core_rpc_server::init_options(boost::program_options::options_description& desc)
@@ -75,11 +56,9 @@ namespace cryptonote
   core_rpc_server::core_rpc_server(
       core& cr
     , nodetool::node_server<cryptonote::t_cryptonote_protocol_handler<cryptonote::core> >& p2p
-    , bool testnet
     )
     : m_core(cr)
     , m_p2p(p2p)
-    , m_testnet(testnet)
   {}
   //------------------------------------------------------------------------------------------------------------------------------
   bool core_rpc_server::handle_command_line(
@@ -97,6 +76,8 @@ namespace cryptonote
       const boost::program_options::variables_map& vm
     )
   {
+    m_testnet = command_line::get_arg(vm, daemon_args::arg_testnet_on);
+
     m_net_server.set_threads_prefix("RPC");
     bool r = handle_command_line(vm);
     CHECK_AND_ASSERT_MES(r, false, "Failed to process command line in core_rpc_server");
@@ -366,6 +347,75 @@ namespace cryptonote
     return true;
   }
   //------------------------------------------------------------------------------------------------------------------------------
+  bool core_rpc_server::on_get_peer_list(const COMMAND_RPC_GET_PEER_LIST::request& req, COMMAND_RPC_GET_PEER_LIST::response& res, connection_context& cntx)
+  {
+    /*
+    std::list<nodetool::peerlist_entry> white_list;
+    std::list<nodetool::peerlist_entry> gray_list;
+    m_p2p.get_peerlist(white_list, gray_list);
+
+    for (auto & entry : white_list)
+    {
+      res.white_list.emplace_back(entry.id, entry.adr.ip, entry.adr.port, entry.last_seen);
+    }
+
+    for (auto & entry : gray_list)
+    {
+      res.gray_list.emplace_back(entry.id, entry.adr.ip, entry.adr.port, entry.last_seen);
+    }
+
+    */
+    res.status = CORE_RPC_STATUS_OK;
+    return true;
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
+  bool core_rpc_server::on_set_log_hash_rate(const COMMAND_RPC_SET_LOG_HASH_RATE::request& req, COMMAND_RPC_SET_LOG_HASH_RATE::response& res, connection_context& cntx)
+  {
+    if(m_core.get_miner().is_mining())
+    {
+      m_core.get_miner().do_print_hashrate(req.visible);
+      res.status = CORE_RPC_STATUS_OK;
+    }
+    else
+    {
+      res.status = CORE_RPC_STATUS_NOT_MINING;
+    }
+    return true;
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
+  bool core_rpc_server::on_set_log_level(const COMMAND_RPC_SET_LOG_LEVEL::request& req, COMMAND_RPC_SET_LOG_LEVEL::response& res, connection_context& cntx)
+  {
+    if (req.level < LOG_LEVEL_MIN || req.level > LOG_LEVEL_MAX)
+    {
+      res.status = "Error: log level not valid";
+    }
+    else
+    {
+      epee::log_space::log_singletone::get_set_log_detalisation_level(true, req.level);
+      res.status = CORE_RPC_STATUS_OK;
+    }
+    return true;
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
+  bool core_rpc_server::on_get_transaction_pool(const COMMAND_RPC_GET_TRANSACTION_POOL::request& req, COMMAND_RPC_GET_TRANSACTION_POOL::response& res, connection_context& cntx)
+  {
+    /*
+    CHECK_CORE_BUSY();
+    res.transactions = m_core.transaction_pool_info();
+    */
+    res.status = CORE_RPC_STATUS_OK;
+    return true;
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
+  bool core_rpc_server::on_stop_daemon(const COMMAND_RPC_STOP_DAEMON::request& req, COMMAND_RPC_STOP_DAEMON::response& res, connection_context& cntx)
+  {
+    // FIXME: replace back to original m_p2p.send_stop_signal() after
+    // investigating why that isn't working quite right.
+    m_p2p.send_stop_signal();
+    res.status = CORE_RPC_STATUS_OK;
+    return true;
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
   bool core_rpc_server::on_getblockcount(const COMMAND_RPC_GETBLOCKCOUNT::request& req, COMMAND_RPC_GETBLOCKCOUNT::response& res, connection_context& cntx)
   {
     CHECK_CORE_BUSY();
@@ -703,4 +753,23 @@ namespace cryptonote
     return true;
   }
   //------------------------------------------------------------------------------------------------------------------------------
-}
+
+  const command_line::arg_descriptor<std::string> core_rpc_server::arg_rpc_bind_ip   = {
+      "rpc-bind-ip"
+    , "IP for RPC server"
+    , "127.0.0.1"
+    };
+
+  const command_line::arg_descriptor<std::string> core_rpc_server::arg_rpc_bind_port = {
+      "rpc-bind-port"
+    , "Port for RPC server"
+    , std::to_string(config::RPC_DEFAULT_PORT)
+    };
+
+  const command_line::arg_descriptor<std::string> core_rpc_server::arg_testnet_rpc_bind_port = {
+      "testnet-rpc-bind-port"
+    , "Port for testnet RPC server"
+    , std::to_string(config::testnet::RPC_DEFAULT_PORT)
+    };
+
+}  // namespace cryptonote
diff --git a/src/rpc/core_rpc_server.h b/src/rpc/core_rpc_server.h
index cd9a0f162..aaddba44c 100644
--- a/src/rpc/core_rpc_server.h
+++ b/src/rpc/core_rpc_server.h
@@ -39,6 +39,10 @@
 #include "p2p/net_node.h"
 #include "cryptonote_protocol/cryptonote_protocol_handler.h"
 
+// yes, epee doesn't properly use its full namespace when calling its
+// functions from macros.  *sigh*
+using namespace epee;
+
 namespace cryptonote
 {
   /************************************************************************/
@@ -47,12 +51,16 @@ namespace cryptonote
   class core_rpc_server: public epee::http_server_impl_base<core_rpc_server>
   {
   public:
+
+    static const command_line::arg_descriptor<std::string> arg_rpc_bind_ip;
+    static const command_line::arg_descriptor<std::string> arg_rpc_bind_port;
+    static const command_line::arg_descriptor<std::string> arg_testnet_rpc_bind_port;
+
     typedef epee::net_utils::connection_context_base connection_context;
 
     core_rpc_server(
         core& cr
       , nodetool::node_server<cryptonote::t_cryptonote_protocol_handler<cryptonote::core> >& p2p
-      , bool testnet
       );
 
     static void init_options(boost::program_options::options_description& desc);
@@ -74,6 +82,12 @@ namespace cryptonote
       MAP_URI_AUTO_JON2("/stop_mining", on_stop_mining, COMMAND_RPC_STOP_MINING)
       MAP_URI_AUTO_JON2("/mining_status", on_mining_status, COMMAND_RPC_MINING_STATUS)
       MAP_URI_AUTO_JON2("/save_bc", on_save_bc, COMMAND_RPC_SAVE_BC)
+      MAP_URI_AUTO_JON2("/get_peer_list", on_get_peer_list, COMMAND_RPC_GET_PEER_LIST)
+      MAP_URI_AUTO_JON2("/set_log_hash_rate", on_set_log_hash_rate, COMMAND_RPC_SET_LOG_HASH_RATE)
+      MAP_URI_AUTO_JON2("/set_log_level", on_set_log_level, COMMAND_RPC_SET_LOG_LEVEL)
+      MAP_URI_AUTO_JON2("/get_transaction_pool", on_get_transaction_pool, COMMAND_RPC_GET_TRANSACTION_POOL)
+      MAP_URI_AUTO_JON2("/get_transaction_pool", on_get_transaction_pool, COMMAND_RPC_GET_TRANSACTION_POOL)
+      MAP_URI_AUTO_JON2("/stop_daemon", on_stop_daemon, COMMAND_RPC_STOP_DAEMON)
       MAP_URI_AUTO_JON2("/getinfo", on_get_info, COMMAND_RPC_GET_INFO)
       BEGIN_JSON_RPC_MAP("/json_rpc")
         MAP_JON_RPC("getblockcount",             on_getblockcount,              COMMAND_RPC_GETBLOCKCOUNT)
@@ -99,6 +113,11 @@ namespace cryptonote
     bool on_get_random_outs(const COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::request& req, COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::response& res, connection_context& cntx);        
     bool on_get_info(const COMMAND_RPC_GET_INFO::request& req, COMMAND_RPC_GET_INFO::response& res, connection_context& cntx);        
     bool on_save_bc(const COMMAND_RPC_SAVE_BC::request& req, COMMAND_RPC_SAVE_BC::response& res, connection_context& cntx);
+    bool on_get_peer_list(const COMMAND_RPC_GET_PEER_LIST::request& req, COMMAND_RPC_GET_PEER_LIST::response& res, connection_context& cntx);
+    bool on_set_log_hash_rate(const COMMAND_RPC_SET_LOG_HASH_RATE::request& req, COMMAND_RPC_SET_LOG_HASH_RATE::response& res, connection_context& cntx);
+    bool on_set_log_level(const COMMAND_RPC_SET_LOG_LEVEL::request& req, COMMAND_RPC_SET_LOG_LEVEL::response& res, connection_context& cntx);
+    bool on_get_transaction_pool(const COMMAND_RPC_GET_TRANSACTION_POOL::request& req, COMMAND_RPC_GET_TRANSACTION_POOL::response& res, connection_context& cntx);
+    bool on_stop_daemon(const COMMAND_RPC_STOP_DAEMON::request& req, COMMAND_RPC_STOP_DAEMON::response& res, connection_context& cntx);
     
     //json_rpc
     bool on_getblockcount(const COMMAND_RPC_GETBLOCKCOUNT::request& req, COMMAND_RPC_GETBLOCKCOUNT::response& res, connection_context& cntx);
diff --git a/src/rpc/core_rpc_server_commands_defs.h b/src/rpc/core_rpc_server_commands_defs.h
index 9fea933cb..5cb547521 100644
--- a/src/rpc/core_rpc_server_commands_defs.h
+++ b/src/rpc/core_rpc_server_commands_defs.h
@@ -39,6 +39,7 @@ namespace cryptonote
   //-----------------------------------------------
 #define CORE_RPC_STATUS_OK   "OK"
 #define CORE_RPC_STATUS_BUSY   "BUSY"
+#define CORE_RPC_STATUS_NOT_MINING "NOT MINING"
 
   struct COMMAND_RPC_GET_HEIGHT
   {
@@ -440,7 +441,7 @@ namespace cryptonote
         KV_SERIALIZE(reward)
       END_KV_SERIALIZE_MAP()
   };
-  
+
   struct COMMAND_RPC_GET_LAST_BLOCK_HEADER
   {
     struct request
@@ -510,6 +511,135 @@ namespace cryptonote
 
   };
 
+  struct peer {
+    uint64_t id;
+    uint32_t ip;
+    uint16_t port;
+    uint64_t last_seen;
+
+    peer() = default;
+
+    peer(uint64_t id, uint32_t ip, uint16_t port, uint64_t last_seen)
+      : id(id), ip(ip), port(port), last_seen(last_seen)
+    {}
+
+    BEGIN_KV_SERIALIZE_MAP()
+      KV_SERIALIZE(id)
+      KV_SERIALIZE(ip)
+      KV_SERIALIZE(port)
+      KV_SERIALIZE(last_seen)
+    END_KV_SERIALIZE_MAP()
+  };
+
+  struct COMMAND_RPC_GET_PEER_LIST
+  {
+    struct request
+    {
+      BEGIN_KV_SERIALIZE_MAP()
+      END_KV_SERIALIZE_MAP()
+    };
+
+    struct response
+    {
+      std::string status;
+      std::vector<peer> white_list;
+      std::vector<peer> gray_list;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(status)
+        KV_SERIALIZE(white_list)
+        KV_SERIALIZE(gray_list)
+      END_KV_SERIALIZE_MAP()
+    };
+  };
+
+  struct COMMAND_RPC_SET_LOG_HASH_RATE
+  {
+    struct request
+    {
+      bool visible;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(visible)
+      END_KV_SERIALIZE_MAP()
+    };
+
+    struct response
+    {
+      std::string status;
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(status)
+      END_KV_SERIALIZE_MAP()
+    };
+  };
+
+  struct COMMAND_RPC_SET_LOG_LEVEL
+  {
+    struct request
+    {
+      int8_t level;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(level)
+      END_KV_SERIALIZE_MAP()
+    };
+
+    struct response
+    {
+      std::string status;
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(status)
+      END_KV_SERIALIZE_MAP()
+    };
+  };
+
+  struct tx_info
+  {
+    std::string id_hash;
+    std::string tx_json; // TODO - expose this data directly
+    uint64_t blob_size;
+    uint64_t fee;
+    std::string max_used_block_id_hash;
+    uint64_t max_used_block_height;
+    bool kept_by_block;
+    uint64_t last_failed_height;
+    std::string last_failed_id_hash;
+    uint64_t receive_time;
+
+    BEGIN_KV_SERIALIZE_MAP()
+      KV_SERIALIZE(id_hash)
+      KV_SERIALIZE(tx_json)
+      KV_SERIALIZE(blob_size)
+      KV_SERIALIZE(fee)
+      KV_SERIALIZE(max_used_block_id_hash)
+      KV_SERIALIZE(max_used_block_height)
+      KV_SERIALIZE(kept_by_block)
+      KV_SERIALIZE(last_failed_height)
+      KV_SERIALIZE(last_failed_id_hash)
+      KV_SERIALIZE(receive_time)
+    END_KV_SERIALIZE_MAP()
+  };
+  
+  struct COMMAND_RPC_GET_TRANSACTION_POOL
+  {
+    struct request
+    {
+      BEGIN_KV_SERIALIZE_MAP()
+      END_KV_SERIALIZE_MAP()
+    };
+
+    struct response
+    {
+      std::string status;
+      std::vector<tx_info> transactions;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(status)
+        KV_SERIALIZE(transactions)
+      END_KV_SERIALIZE_MAP()
+    };
+  };
+
   struct COMMAND_RPC_GET_CONNECTIONS
   {
     struct request
@@ -530,5 +660,48 @@ namespace cryptonote
     };
 
   };
+
+  struct COMMAND_RPC_GET_BLOCK_HEADERS_RANGE
+  {
+    struct request
+    {
+      uint64_t start_height;
+      uint64_t end_height;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(start_height)
+        KV_SERIALIZE(end_height)
+      END_KV_SERIALIZE_MAP()
+    };
+
+    struct response
+    {
+      std::string status;
+      std::vector<block_header_responce> headers;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(status)
+        KV_SERIALIZE(headers)
+      END_KV_SERIALIZE_MAP()
+    };
+  };
+
+  struct COMMAND_RPC_STOP_DAEMON
+  {
+    struct request
+    {
+      BEGIN_KV_SERIALIZE_MAP()
+      END_KV_SERIALIZE_MAP()
+    };
+
+    struct response
+    {
+      std::string status;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(status)
+      END_KV_SERIALIZE_MAP()
+    };
+  };
 }