Merge to keep up with upstream

Merge 'monero-project/master' with blockchain

src/cryptonote_config.h

@@ -33,6 +33,8 @@
 #include <string>
 #include <boost/uuid/uuid.hpp>
 
+#define CRYPTONOTE_DNS_TIMEOUT_MS                       20000
+
 #define CRYPTONOTE_MAX_BLOCK_NUMBER                     500000000
 #define CRYPTONOTE_MAX_BLOCK_SIZE                       500000000  // block header blob limit, never used!
 #define CRYPTONOTE_GETBLOCKTEMPLATE_MAX_BLOCK_SIZE	196608 //size of block (bytes) that is the maximum that miners will produce

src/p2p/net_node.inl

@@ -31,6 +31,9 @@
 #pragma once
 
 #include <algorithm>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/thread/thread.hpp> 
+#include <atomic>
 
 #include "version.h"
 #include "string_tools.h"
@@ -252,19 +255,75 @@ namespace nodetool
       // add the result addresses as seed nodes
       // TODO: at some point add IPv6 support, but that won't be relevant
       // for some time yet.
+      
+      std::vector<std::vector<std::string>> dns_results;
+      dns_results.resize(m_seed_nodes_list.size());
+
+      std::list<boost::thread*> dns_threads;
+      uint64_t result_index = 0;
       for (const std::string& addr_str : m_seed_nodes_list)
       {
+        boost::thread* th = new boost::thread([=, &dns_results, &addr_str]
+        {
+          LOG_PRINT_L4("dns_threads[" << result_index << "] created for: " << addr_str)
           // TODO: care about dnssec avail/valid
           bool avail, valid;
-        std::vector<std::string> addr_list = tools::DNSResolver::instance().get_ipv4(addr_str, avail, valid);
+          std::vector<std::string> addr_list;
-        for (const std::string& a : addr_list)
+
+          try
           {
-          append_net_address(m_seed_nodes, a + ":18080");
+            addr_list = tools::DNSResolver().get_ipv4(addr_str, avail, valid);
+            LOG_PRINT_L4("dns_threads[" << result_index << "] DNS resolve done");
+            boost::this_thread::interruption_point();
           }
+          catch(const boost::thread_interrupted&)
+          {
+            // thread interruption request
+            // even if we now have results, finish thread without setting
+            // result variables, which are now out of scope in main thread
+            LOG_PRINT_L4("dns_threads[" << result_index << "] interrupted");
+            return;
+          }
+
+          LOG_PRINT_L4("dns_threads[" << result_index << "] addr_str: " << addr_str << "  number of results: " << addr_list.size());
+          dns_results[result_index] = addr_list;
+        });
+
+        dns_threads.push_back(th);
+        ++result_index;
+      }
+
+      LOG_PRINT_L4("dns_threads created, now waiting for completion or timeout of " << CRYPTONOTE_DNS_TIMEOUT_MS << "ms");
+      boost::chrono::system_clock::time_point deadline = boost::chrono::system_clock::now() + boost::chrono::milliseconds(CRYPTONOTE_DNS_TIMEOUT_MS);
+      uint64_t i = 0;
+      for (boost::thread* th : dns_threads)
+      {
+        if (! th->try_join_until(deadline))
+        {
+          LOG_PRINT_L4("dns_threads[" << i << "] timed out, sending interrupt");
+          th->interrupt();
+        }
+        ++i;
+      }
+
+      i = 0;
+      for (const auto& result : dns_results)
+      {
+        LOG_PRINT_L4("DNS lookup for " << m_seed_nodes_list[i] << ": " << result.size() << " results");
+        // if no results for node, thread's lookup likely timed out
+        if (result.size())
+        {
+          for (const auto& addr_string : result)
+          {
+            append_net_address(m_seed_nodes, addr_string + ":18080");
+          }
+        }
+        ++i;
       }
 
       if (!m_seed_nodes.size())
       {
+        LOG_PRINT_L0("DNS seed node lookup either timed out or failed, falling back to defaults");
         append_net_address(m_seed_nodes, "62.210.78.186:18080");
         append_net_address(m_seed_nodes, "195.12.60.154:18080");
         append_net_address(m_seed_nodes, "54.241.246.125:18080");

src/rpc/core_rpc_server.cpp

@@ -475,6 +475,7 @@ namespace cryptonote
       LOG_ERROR("Failed to calculate offset for ");
       return false;
     }
+    res.prev_hash = string_tools::pod_to_hex(b.prev_id);
     res.blocktemplate_blob = string_tools::buff_to_hex_nodelimer(block_blob);
     res.status = CORE_RPC_STATUS_OK;
     return true;

src/rpc/core_rpc_server_commands_defs.h

@@ -383,6 +383,7 @@ namespace cryptonote
       uint64_t difficulty;
       uint64_t height;
       uint64_t reserved_offset;
+      std::string prev_hash;
       blobdata blocktemplate_blob;
       std::string status;
 
@@ -390,6 +391,7 @@ namespace cryptonote
         KV_SERIALIZE(difficulty)
         KV_SERIALIZE(height)
         KV_SERIALIZE(reserved_offset)
+        KV_SERIALIZE(prev_hash)
         KV_SERIALIZE(blocktemplate_blob)
         KV_SERIALIZE(status)
       END_KV_SERIALIZE_MAP()

src/simplewallet/simplewallet.cpp

@@ -81,6 +81,7 @@ namespace
   const command_line::arg_descriptor<int> arg_daemon_port = {"daemon-port", "Use daemon instance at port <arg> instead of 8081", 0};
   const command_line::arg_descriptor<uint32_t> arg_log_level = {"set_log", "", 0, true};
   const command_line::arg_descriptor<bool> arg_testnet = {"testnet", "Used to deploy test nets. The daemon must be launched with --testnet flag", false};
+  const command_line::arg_descriptor<bool> arg_restricted = {"restricted-rpc", "Restricts RPC to view only commands", false};
 
   const command_line::arg_descriptor< std::vector<std::string> > arg_command = {"command", ""};
 
@@ -1336,6 +1337,7 @@ int main(int argc, char* argv[])
   command_line::add_arg(desc_params, arg_non_deterministic );
   command_line::add_arg(desc_params, arg_electrum_seed );
   command_line::add_arg(desc_params, arg_testnet);
+  command_line::add_arg(desc_params, arg_restricted);
   tools::wallet_rpc_server::init_options(desc_params);
 
   po::positional_options_description positional_options;
@@ -1406,6 +1408,7 @@ int main(int argc, char* argv[])
     }
 
     bool testnet = command_line::get_arg(vm, arg_testnet);
+    bool restricted = command_line::get_arg(vm, arg_restricted);
     std::string wallet_file     = command_line::get_arg(vm, arg_wallet_file);
     std::string wallet_password = command_line::get_arg(vm, arg_password);
     std::string daemon_address  = command_line::get_arg(vm, arg_daemon_address);
@@ -1418,7 +1421,7 @@ int main(int argc, char* argv[])
     if (daemon_address.empty())
       daemon_address = std::string("http://") + daemon_host + ":" + std::to_string(daemon_port);
 
-    tools::wallet2 wal(testnet);
+    tools::wallet2 wal(testnet,restricted);
     try
     {
       LOG_PRINT_L0("Loading wallet...");

src/wallet/wallet2.cpp

@@ -227,13 +227,16 @@ void wallet2::process_new_transaction(const cryptonote::transaction& tx, uint64_
   }
 
   tx_extra_nonce extra_nonce;
+  crypto::hash payment_id = null_hash;
   if (find_tx_extra_field_by_type(tx_extra_fields, extra_nonce))
   {
-    crypto::hash payment_id;
     if(get_payment_id_from_tx_extra_nonce(extra_nonce.nonce, payment_id))
     {
+      // We got a payment ID to go with this tx
+    }
+  }
   uint64_t received = (tx_money_spent_in_ins < tx_money_got_in_outs) ? tx_money_got_in_outs - tx_money_spent_in_ins : 0;
-      if (0 < received && null_hash != payment_id)
+  if (0 < received)
   {
     payment_details payment;
     payment.m_tx_hash      = cryptonote::get_transaction_hash(tx);
@@ -244,8 +247,6 @@ void wallet2::process_new_transaction(const cryptonote::transaction& tx, uint64_
     LOG_PRINT_L2("Payment found: " << payment_id << " / " << payment.m_tx_hash << " / " << payment.m_amount);
   }
 }
-  }
-}
 //----------------------------------------------------------------------------------------------------
 void wallet2::process_unconfirmed(const cryptonote::transaction& tx)
 {
@@ -816,6 +817,17 @@ void wallet2::get_payments(const crypto::hash& payment_id, std::list<wallet2::pa
   });
 }
 //----------------------------------------------------------------------------------------------------
+void wallet2::get_payments(std::list<std::pair<crypto::hash,wallet2::payment_details>>& payments, uint64_t min_height) const
+{
+  auto range = std::make_pair(m_payments.begin(), m_payments.end());
+  std::for_each(range.first, range.second, [&payments, &min_height](const payment_container::value_type& x) {
+    if (min_height < x.second.m_block_height)
+    {
+      payments.push_back(x);
+    }
+  });
+}
+//----------------------------------------------------------------------------------------------------
 bool wallet2::is_transfer_unlocked(const transfer_details& td) const
 {
   if(!is_tx_spendtime_unlocked(td.m_tx.unlock_time))

src/wallet/wallet2.h

@@ -82,7 +82,7 @@ namespace tools
   {
     wallet2(const wallet2&) : m_run(true), m_callback(0), m_testnet(false) {};
   public:
-    wallet2(bool testnet = false) : m_run(true), m_callback(0), m_testnet(testnet), is_old_file_format(false) {};
+    wallet2(bool testnet = false, bool restricted = false) : m_run(true), m_callback(0), m_testnet(testnet), m_restricted(restricted), is_old_file_format(false) {};
     struct transfer_details
     {
       uint64_t m_block_height;
@@ -196,6 +196,7 @@ namespace tools
     bool refresh(size_t & blocks_fetched, bool& received_money, bool& ok);
 
     bool testnet() { return m_testnet; }
+    bool restricted() const { return m_restricted; }
 
     uint64_t balance();
     uint64_t unlocked_balance();
@@ -211,6 +212,7 @@ namespace tools
     bool check_connection();
     void get_transfers(wallet2::transfer_container& incoming_transfers) const;
     void get_payments(const crypto::hash& payment_id, std::list<wallet2::payment_details>& payments, uint64_t min_height = 0) const;
+    void get_payments(std::list<std::pair<crypto::hash,wallet2::payment_details>>& payments, uint64_t min_height) const;
     uint64_t get_blockchain_current_height() const { return m_local_bc_height; }
     template <class t_archive>
     inline void serialize(t_archive &a, const unsigned int ver)
@@ -296,6 +298,7 @@ namespace tools
 
     i_wallet2_callback* m_callback;
     bool m_testnet;
+    bool m_restricted;
     std::string seed_language; /*!< Language of the mnemonics (seed). */
     bool is_old_file_format; /*!< Whether the wallet file is of an old file format */
   };

src/wallet/wallet_rpc_server.cpp

@@ -167,6 +167,13 @@ namespace tools
     std::vector<cryptonote::tx_destination_entry> dsts;
     std::vector<uint8_t> extra;
 
+    if (m_wallet.restricted())
+    {
+      er.code = WALLET_RPC_ERROR_CODE_DENIED;
+      er.message = "Command unavailable in restricted mode.";
+      return false;
+    }
+
     // validate the transfer requested and populate dsts & extra
     if (!validate_transfer(req.destinations, req.payment_id, dsts, extra, er))
     {
@@ -218,6 +225,13 @@ namespace tools
     std::vector<cryptonote::tx_destination_entry> dsts;
     std::vector<uint8_t> extra;
 
+    if (m_wallet.restricted())
+    {
+      er.code = WALLET_RPC_ERROR_CODE_DENIED;
+      er.message = "Command unavailable in restricted mode.";
+      return false;
+    }
+
     // validate the transfer requested and populate dsts & extra; RPC_TRANSFER::request and RPC_TRANSFER_SPLIT::request are identical types.
     if (!validate_transfer(req.destinations, req.payment_id, dsts, extra, er))
     {
@@ -261,6 +275,13 @@ namespace tools
   //------------------------------------------------------------------------------------------------------------------------------
   bool wallet_rpc_server::on_store(const wallet_rpc::COMMAND_RPC_STORE::request& req, wallet_rpc::COMMAND_RPC_STORE::response& res, epee::json_rpc::error& er, connection_context& cntx)
   {
+    if (m_wallet.restricted())
+    {
+      er.code = WALLET_RPC_ERROR_CODE_DENIED;
+      er.message = "Command unavailable in restricted mode.";
+      return false;
+    }
+
     try
     {
       m_wallet.store();
@@ -315,6 +336,26 @@ namespace tools
   {
     res.payments.clear();
 
+    /* If the payment ID list is empty, we get payments to any payment ID (or lack thereof) */
+    if (req.payment_ids.empty())
+    {
+      std::list<std::pair<crypto::hash,wallet2::payment_details>> payment_list;
+      m_wallet.get_payments(payment_list, req.min_block_height);
+
+      for (auto & payment : payment_list)
+      {
+        wallet_rpc::payment_details rpc_payment;
+        rpc_payment.payment_id   = epee::string_tools::pod_to_hex(payment.first);
+        rpc_payment.tx_hash      = epee::string_tools::pod_to_hex(payment.second.m_tx_hash);
+        rpc_payment.amount       = payment.second.m_amount;
+        rpc_payment.block_height = payment.second.m_block_height;
+        rpc_payment.unlock_time  = payment.second.m_unlock_time;
+        res.payments.push_back(std::move(rpc_payment));
+      }
+
+      return true;
+    }
+
     for (auto & payment_id_str : req.payment_ids)
     {
       crypto::hash payment_id;
@@ -409,6 +450,13 @@ namespace tools
   //------------------------------------------------------------------------------------------------------------------------------
   bool wallet_rpc_server::on_query_key(const wallet_rpc::COMMAND_RPC_QUERY_KEY::request& req, wallet_rpc::COMMAND_RPC_QUERY_KEY::response& res, epee::json_rpc::error& er, connection_context& cntx)
   {
+      if (m_wallet.restricted())
+      {
+        er.code = WALLET_RPC_ERROR_CODE_DENIED;
+        er.message = "Command unavailable in restricted mode.";
+        return false;
+      }
+
       if (req.key_type.compare("mnemonic") == 0)
       {
         if (!m_wallet.get_seed(res.key))

src/wallet/wallet_rpc_server_error_codes.h

@@ -37,3 +37,4 @@
 #define WALLET_RPC_ERROR_CODE_GENERIC_TRANSFER_ERROR  -4
 #define WALLET_RPC_ERROR_CODE_WRONG_PAYMENT_ID        -5
 #define WALLET_RPC_ERROR_CODE_TRANSFER_TYPE           -6
+#define WALLET_RPC_ERROR_CODE_DENIED                  -7

utils/gpg_keys/moneromooo.asc

@@ -0,0 +1,52 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+Version: GnuPG v2
+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+=itPR
+-----END PGP PUBLIC KEY BLOCK-----