Mirrors
/
monero
mirror of https://github.com/monero-project/monero.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge to keep up with upstream 

Merge 'monero-project/master' with blockchain
This commit is contained in:
Thomas Winget 2015-01-21 11:25:48 -05:00
parent acd4c369e4 9e0516c1dd
commit 9d52378029
No known key found for this signature in database
GPG Key ID: 58131A160789E630
10 changed files with 208 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/cryptonote_config.h
View File

@ -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

81
src/p2p/net_node.inl
View File

@ -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"
@ -46,13 +49,13 @@
// We have to look for miniupnpc headers in different places, dependent on if its compiled or external
#ifdef UPNP_STATIC
#include <miniupnpc/miniupnpc.h>
#include <miniupnpc/upnpcommands.h>
#include <miniupnpc/upnperrors.h>
#include <miniupnpc/miniupnpc.h>
#include <miniupnpc/upnpcommands.h>
#include <miniupnpc/upnperrors.h>
#else
#include "miniupnpc.h"
#include "upnpcommands.h"
#include "upnperrors.h"
#include "miniupnpc.h"
#include "upnpcommands.h"
#include "upnperrors.h"
#endif
#define NET_MAKE_IP(b1,b2,b3,b4) ((LPARAM)(((DWORD)(b1)<<24)+((DWORD)(b2)<<16)+((DWORD)(b3)<<8)+((DWORD)(b4))))
@ -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)
{
// TODO: care about dnssec avail/valid
bool avail, valid;
std::vector<std::string> addr_list = tools::DNSResolver::instance().get_ipv4(addr_str, avail, valid);
for (const std::string& a : addr_list)
boost::thread* th = new boost::thread([=, &dns_results, &addr_str]
{
append_net_address(m_seed_nodes, a + ":18080");
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;
try
{
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");

1
src/rpc/core_rpc_server.cpp
View File

@ -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;

2
src/rpc/core_rpc_server_commands_defs.h
View File

@ -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()

5
src/simplewallet/simplewallet.cpp
View File

@ -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...");

36
src/wallet/wallet2.cpp
View File

@ -227,24 +227,25 @@ 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))
{
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)
{
payment_details payment;
payment.m_tx_hash = cryptonote::get_transaction_hash(tx);
payment.m_amount = received;
payment.m_block_height = height;
payment.m_unlock_time = tx.unlock_time;
m_payments.emplace(payment_id, payment);
LOG_PRINT_L2("Payment found: " << payment_id << " / " << payment.m_tx_hash << " / " << payment.m_amount);
}
// 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)
{
payment_details payment;
payment.m_tx_hash = cryptonote::get_transaction_hash(tx);
payment.m_amount = received;
payment.m_block_height = height;
payment.m_unlock_time = tx.unlock_time;
m_payments.emplace(payment_id, payment);
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))

5
src/wallet/wallet2.h
View File

@ -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 */
};

48
src/wallet/wallet_rpc_server.cpp
View File

@ -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))

1
src/wallet/wallet_rpc_server_error_codes.h
View File

@ -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

52
utils/gpg_keys/moneromooo.asc Normal file
View File

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