mirror of https://github.com/oxen-io/oxen-core.git
Merge commit '8fad35f' into LokiMergeUpstream
This commit is contained in:
commit
ce980e31f0
|
@ -119,6 +119,7 @@ namespace net_utils
|
|||
//----------------- i_service_endpoint ---------------------
|
||||
virtual bool do_send(const void* ptr, size_t cb); ///< (see do_send from i_service_endpoint)
|
||||
virtual bool do_send_chunk(const void* ptr, size_t cb); ///< will send (or queue) a part of data
|
||||
virtual bool send_done();
|
||||
virtual bool close();
|
||||
virtual bool call_run_once_service_io();
|
||||
virtual bool request_callback();
|
||||
|
@ -137,8 +138,11 @@ namespace net_utils
|
|||
|
||||
/// reset connection timeout timer and callback
|
||||
void reset_timer(boost::posix_time::milliseconds ms, bool add);
|
||||
boost::posix_time::milliseconds get_default_time() const;
|
||||
boost::posix_time::milliseconds get_timeout_from_bytes_read(size_t bytes) const;
|
||||
boost::posix_time::milliseconds get_default_timeout();
|
||||
boost::posix_time::milliseconds get_timeout_from_bytes_read(size_t bytes);
|
||||
|
||||
/// host connection count tracking
|
||||
unsigned int host_count(const std::string &host, int delta = 0);
|
||||
|
||||
/// Buffer for incoming data.
|
||||
boost::array<char, 8192> buffer_;
|
||||
|
@ -165,6 +169,8 @@ namespace net_utils
|
|||
|
||||
boost::asio::deadline_timer m_timer;
|
||||
bool m_local;
|
||||
bool m_ready_to_close;
|
||||
std::string m_host;
|
||||
|
||||
public:
|
||||
void setRpcStation();
|
||||
|
|
|
@ -56,8 +56,8 @@
|
|||
#undef LOKI_DEFAULT_LOG_CATEGORY
|
||||
#define LOKI_DEFAULT_LOG_CATEGORY "net"
|
||||
|
||||
#define DEFAULT_TIMEOUT_MS_LOCAL boost::posix_time::milliseconds(120000) // 2 minutes
|
||||
#define DEFAULT_TIMEOUT_MS_REMOTE boost::posix_time::milliseconds(10000) // 10 seconds
|
||||
#define DEFAULT_TIMEOUT_MS_LOCAL 1800000 // 30 minutes
|
||||
#define DEFAULT_TIMEOUT_MS_REMOTE 300000 // 5 minutes
|
||||
#define TIMEOUT_EXTRA_MS_PER_BYTE 0.2
|
||||
|
||||
PRAGMA_WARNING_PUSH
|
||||
|
@ -86,7 +86,8 @@ PRAGMA_WARNING_DISABLE_VS(4355)
|
|||
m_throttle_speed_in("speed_in", "throttle_speed_in"),
|
||||
m_throttle_speed_out("speed_out", "throttle_speed_out"),
|
||||
m_timer(io_service),
|
||||
m_local(false)
|
||||
m_local(false),
|
||||
m_ready_to_close(false)
|
||||
{
|
||||
MDEBUG("test, connection constructor set m_connection_type="<<m_connection_type);
|
||||
}
|
||||
|
@ -146,7 +147,7 @@ PRAGMA_WARNING_DISABLE_VS(4355)
|
|||
|
||||
context = boost::value_initialized<t_connection_context>();
|
||||
const unsigned long ip_{boost::asio::detail::socket_ops::host_to_network_long(remote_ep.address().to_v4().to_ulong())};
|
||||
m_local = epee::net_utils::is_ip_loopback(ip_);
|
||||
m_local = epee::net_utils::is_ip_loopback(ip_) || epee::net_utils::is_ip_local(ip_);
|
||||
|
||||
// create a random uuid
|
||||
boost::uuids::uuid random_uuid;
|
||||
|
@ -165,9 +166,12 @@ PRAGMA_WARNING_DISABLE_VS(4355)
|
|||
return false;
|
||||
}
|
||||
|
||||
m_host = context.m_remote_address.host_str();
|
||||
try { host_count(m_host, 1); } catch(...) { /* ignore */ }
|
||||
|
||||
m_protocol_handler.after_init_connection();
|
||||
|
||||
reset_timer(get_default_time(), false);
|
||||
reset_timer(get_default_timeout(), false);
|
||||
|
||||
socket_.async_read_some(boost::asio::buffer(buffer_),
|
||||
strand_.wrap(
|
||||
|
@ -324,6 +328,7 @@ PRAGMA_WARNING_DISABLE_VS(4355)
|
|||
logger_handle_net_read(bytes_transferred);
|
||||
context.m_last_recv = time(NULL);
|
||||
context.m_recv_cnt += bytes_transferred;
|
||||
m_ready_to_close = false;
|
||||
bool recv_res = m_protocol_handler.handle_recv(buffer_.data(), bytes_transferred);
|
||||
if(!recv_res)
|
||||
{
|
||||
|
@ -356,6 +361,13 @@ PRAGMA_WARNING_DISABLE_VS(4355)
|
|||
_dbg3("[sock " << socket_.native_handle() << "] Some problems at read: " << e.message() << ':' << e.value());
|
||||
shutdown();
|
||||
}
|
||||
else
|
||||
{
|
||||
_dbg3("[sock " << socket_.native_handle() << "] peer closed connection");
|
||||
if (m_ready_to_close)
|
||||
shutdown();
|
||||
}
|
||||
m_ready_to_close = true;
|
||||
}
|
||||
// If an error occurs then no new asynchronous operations are started. This
|
||||
// means that all shared_ptr references to the connection object will
|
||||
|
@ -531,7 +543,7 @@ PRAGMA_WARNING_DISABLE_VS(4355)
|
|||
if(m_send_que.size() > 1)
|
||||
{ // active operation should be in progress, nothing to do, just wait last operation callback
|
||||
auto size_now = cb;
|
||||
MDEBUG("do_send() NOW just queues: packet="<<size_now<<" B, is added to queue-size="<<m_send_que.size());
|
||||
MDEBUG("do_send_chunk() NOW just queues: packet="<<size_now<<" B, is added to queue-size="<<m_send_que.size());
|
||||
//do_send_handler_delayed( ptr , size_now ); // (((H))) // empty function
|
||||
|
||||
LOG_TRACE_CC(context, "[sock " << socket_.native_handle() << "] Async send requested " << m_send_que.front().size());
|
||||
|
@ -546,12 +558,12 @@ PRAGMA_WARNING_DISABLE_VS(4355)
|
|||
}
|
||||
|
||||
auto size_now = m_send_que.front().size();
|
||||
MDEBUG("do_send() NOW SENSD: packet="<<size_now<<" B");
|
||||
MDEBUG("do_send_chunk() NOW SENSD: packet="<<size_now<<" B");
|
||||
if (speed_limit_is_enabled())
|
||||
do_send_handler_write( ptr , size_now ); // (((H)))
|
||||
|
||||
CHECK_AND_ASSERT_MES( size_now == m_send_que.front().size(), false, "Unexpected queue size");
|
||||
reset_timer(get_default_time(), false);
|
||||
reset_timer(get_default_timeout(), false);
|
||||
boost::asio::async_write(socket_, boost::asio::buffer(m_send_que.front().data(), size_now ) ,
|
||||
//strand_.wrap(
|
||||
boost::bind(&connection<t_protocol_handler>::handle_write, self, _1, _2)
|
||||
|
@ -566,29 +578,51 @@ PRAGMA_WARNING_DISABLE_VS(4355)
|
|||
|
||||
return true;
|
||||
|
||||
CATCH_ENTRY_L0("connection<t_protocol_handler>::do_send", false);
|
||||
CATCH_ENTRY_L0("connection<t_protocol_handler>::do_send_chunk", false);
|
||||
} // do_send_chunk
|
||||
//---------------------------------------------------------------------------------
|
||||
template<class t_protocol_handler>
|
||||
boost::posix_time::milliseconds connection<t_protocol_handler>::get_default_time() const
|
||||
boost::posix_time::milliseconds connection<t_protocol_handler>::get_default_timeout()
|
||||
{
|
||||
unsigned count;
|
||||
try { count = host_count(m_host); } catch (...) { count = 0; }
|
||||
const unsigned shift = std::min(std::max(count, 1u) - 1, 8u);
|
||||
boost::posix_time::milliseconds timeout(0);
|
||||
if (m_local)
|
||||
return DEFAULT_TIMEOUT_MS_LOCAL;
|
||||
timeout = boost::posix_time::milliseconds(DEFAULT_TIMEOUT_MS_LOCAL >> shift);
|
||||
else
|
||||
return DEFAULT_TIMEOUT_MS_REMOTE;
|
||||
timeout = boost::posix_time::milliseconds(DEFAULT_TIMEOUT_MS_REMOTE >> shift);
|
||||
return timeout;
|
||||
}
|
||||
//---------------------------------------------------------------------------------
|
||||
template<class t_protocol_handler>
|
||||
boost::posix_time::milliseconds connection<t_protocol_handler>::get_timeout_from_bytes_read(size_t bytes) const
|
||||
boost::posix_time::milliseconds connection<t_protocol_handler>::get_timeout_from_bytes_read(size_t bytes)
|
||||
{
|
||||
boost::posix_time::milliseconds ms = (boost::posix_time::milliseconds)(unsigned)(bytes * TIMEOUT_EXTRA_MS_PER_BYTE);
|
||||
ms += m_timer.expires_from_now();
|
||||
if (ms > get_default_time())
|
||||
ms = get_default_time();
|
||||
if (ms > get_default_timeout())
|
||||
ms = get_default_timeout();
|
||||
return ms;
|
||||
}
|
||||
//---------------------------------------------------------------------------------
|
||||
template<class t_protocol_handler>
|
||||
unsigned int connection<t_protocol_handler>::host_count(const std::string &host, int delta)
|
||||
{
|
||||
static boost::mutex hosts_mutex;
|
||||
CRITICAL_REGION_LOCAL(hosts_mutex);
|
||||
static std::map<std::string, unsigned int> hosts;
|
||||
unsigned int &val = hosts[host];
|
||||
if (delta > 0)
|
||||
MTRACE("New connection from host " << host << ": " << val);
|
||||
else if (delta < 0)
|
||||
MTRACE("Closed connection from host " << host << ": " << val);
|
||||
CHECK_AND_ASSERT_THROW_MES(delta >= 0 || val >= (unsigned)-delta, "Count would go negative");
|
||||
CHECK_AND_ASSERT_THROW_MES(delta <= 0 || val <= std::numeric_limits<unsigned int>::max() - (unsigned)delta, "Count would wrap");
|
||||
val += delta;
|
||||
return val;
|
||||
}
|
||||
//---------------------------------------------------------------------------------
|
||||
template<class t_protocol_handler>
|
||||
void connection<t_protocol_handler>::reset_timer(boost::posix_time::milliseconds ms, bool add)
|
||||
{
|
||||
if (m_connection_type != e_connection_type_RPC)
|
||||
|
@ -621,6 +655,11 @@ PRAGMA_WARNING_DISABLE_VS(4355)
|
|||
socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both, ignored_ec);
|
||||
m_was_shutdown = true;
|
||||
m_protocol_handler.release_protocol();
|
||||
if (!m_host.empty())
|
||||
{
|
||||
try { host_count(m_host, -1); } catch (...) { /* ignore */ }
|
||||
m_host = "";
|
||||
}
|
||||
return true;
|
||||
}
|
||||
//---------------------------------------------------------------------------------
|
||||
|
@ -645,6 +684,15 @@ PRAGMA_WARNING_DISABLE_VS(4355)
|
|||
}
|
||||
//---------------------------------------------------------------------------------
|
||||
template<class t_protocol_handler>
|
||||
bool connection<t_protocol_handler>::send_done()
|
||||
{
|
||||
if (m_ready_to_close)
|
||||
return close();
|
||||
m_ready_to_close = true;
|
||||
return true;
|
||||
}
|
||||
//---------------------------------------------------------------------------------
|
||||
template<class t_protocol_handler>
|
||||
bool connection<t_protocol_handler>::cancel()
|
||||
{
|
||||
return close();
|
||||
|
@ -687,7 +735,7 @@ PRAGMA_WARNING_DISABLE_VS(4355)
|
|||
}else
|
||||
{
|
||||
//have more data to send
|
||||
reset_timer(get_default_time(), false);
|
||||
reset_timer(get_default_timeout(), false);
|
||||
auto size_now = m_send_que.front().size();
|
||||
MDEBUG("handle_write() NOW SENDS: packet="<<size_now<<" B" <<", from queue size="<<m_send_que.size());
|
||||
if (speed_limit_is_enabled())
|
||||
|
|
|
@ -400,7 +400,7 @@ namespace net_utils
|
|||
template<class t_connection_context>
|
||||
bool simple_http_connection_handler<t_connection_context>::analize_cached_request_header_and_invoke_state(size_t pos)
|
||||
{
|
||||
//LOG_PRINT_L4("HTTP HEAD:\r\n" << m_cache.substr(0, pos));
|
||||
LOG_PRINT_L3("HTTP HEAD:\r\n" << m_cache.substr(0, pos));
|
||||
|
||||
m_query_info.m_full_request_buf_size = pos;
|
||||
m_query_info.m_request_head.assign(m_cache.begin(), m_cache.begin()+pos);
|
||||
|
@ -583,6 +583,7 @@ namespace net_utils
|
|||
m_psnd_hndlr->do_send((void*)response_data.data(), response_data.size());
|
||||
if ((response.m_body.size() && (query_info.m_http_method != http::http_method_head)) || (query_info.m_http_method == http::http_method_options))
|
||||
m_psnd_hndlr->do_send((void*)response.m_body.data(), response.m_body.size());
|
||||
m_psnd_hndlr->send_done();
|
||||
return res;
|
||||
}
|
||||
//-----------------------------------------------------------------------------------
|
||||
|
|
|
@ -281,6 +281,7 @@ namespace net_utils
|
|||
{
|
||||
virtual bool do_send(const void* ptr, size_t cb)=0;
|
||||
virtual bool close()=0;
|
||||
virtual bool send_done()=0;
|
||||
virtual bool call_run_once_service_io()=0;
|
||||
virtual bool request_callback()=0;
|
||||
virtual boost::asio::io_service& get_io_service()=0;
|
||||
|
|
Binary file not shown.
Before Width: | Height: | Size: 19 KiB After Width: | Height: | Size: 1.5 KiB |
|
@ -594,8 +594,8 @@ int main(int argc, char* argv[])
|
|||
const command_line::arg_descriptor<std::string> arg_database = {
|
||||
"database", available_dbs.c_str(), default_db_type
|
||||
};
|
||||
const command_line::arg_descriptor<bool> arg_verify = {"guard-against-pwnage",
|
||||
"Verify blocks and transactions during import (only disable if you exported the file yourself)", true};
|
||||
const command_line::arg_descriptor<bool> arg_noverify = {"dangerous-unverified-import",
|
||||
"Blindly trust the import file and use potentially malicious blocks and transactions during import (only enable if you exported the file yourself)", false};
|
||||
const command_line::arg_descriptor<bool> arg_batch = {"batch",
|
||||
"Batch transactions for faster import", true};
|
||||
const command_line::arg_descriptor<bool> arg_resume = {"resume",
|
||||
|
@ -615,7 +615,7 @@ int main(int argc, char* argv[])
|
|||
// call add_options() directly for these arguments since
|
||||
// command_line helpers support only boolean switch, not boolean argument
|
||||
desc_cmd_sett.add_options()
|
||||
(arg_verify.name, make_semantic(arg_verify), arg_verify.description)
|
||||
(arg_noverify.name, make_semantic(arg_noverify), arg_noverify.description)
|
||||
(arg_batch.name, make_semantic(arg_batch), arg_batch.description)
|
||||
(arg_resume.name, make_semantic(arg_resume), arg_resume.description)
|
||||
;
|
||||
|
@ -634,7 +634,7 @@ int main(int argc, char* argv[])
|
|||
if (! r)
|
||||
return 1;
|
||||
|
||||
opt_verify = command_line::get_arg(vm, arg_verify);
|
||||
opt_verify = !command_line::get_arg(vm, arg_noverify);
|
||||
opt_batch = command_line::get_arg(vm, arg_batch);
|
||||
opt_resume = command_line::get_arg(vm, arg_resume);
|
||||
block_stop = command_line::get_arg(vm, arg_block_stop);
|
||||
|
@ -739,6 +739,18 @@ int main(int argc, char* argv[])
|
|||
MINFO("bootstrap file path: " << import_file_path);
|
||||
MINFO("database path: " << m_config_folder);
|
||||
|
||||
if (!opt_verify)
|
||||
{
|
||||
MCLOG_RED(el::Level::Warning, "global", "\n"
|
||||
"Import is set to proceed WITHOUT VERIFICATION.\n"
|
||||
"This is a DANGEROUS operation: if the file was tampered with in transit, or obtained from a malicious source,\n"
|
||||
"you could end up with a compromised database. It is recommended to NOT use " << arg_noverify.name << ".\n"
|
||||
"*****************************************************************************************\n"
|
||||
"You have 90 seconds to press ^C or terminate this program before unverified import starts\n"
|
||||
"*****************************************************************************************");
|
||||
sleep(90);
|
||||
}
|
||||
|
||||
cryptonote::cryptonote_protocol_stub pr; //TODO: stub only for this kind of test, make real validation of relayed objects
|
||||
cryptonote::core core(&pr);
|
||||
|
||||
|
|
|
@ -164,7 +164,7 @@ namespace
|
|||
while (true)
|
||||
{
|
||||
if (message)
|
||||
std::cout << message <<": ";
|
||||
std::cout << message <<": " << std::flush;
|
||||
if (!read_from_tty(pass1))
|
||||
return false;
|
||||
if (verify)
|
||||
|
|
|
@ -4815,12 +4815,11 @@ bool wallet2::sign_tx(unsigned_tx_set &exported_txs, std::vector<wallet2::pendin
|
|||
LOG_PRINT_L1(" " << (n+1) << ": " << sd.sources.size() << " inputs, ring size " << sd.sources[0].outputs.size());
|
||||
signed_txes.ptx.push_back(pending_tx());
|
||||
tools::wallet2::pending_tx &ptx = signed_txes.ptx.back();
|
||||
bool bulletproof = sd.use_rct && !ptx.tx.rct_signatures.p.bulletproofs.empty();
|
||||
crypto::secret_key tx_key;
|
||||
std::vector<crypto::secret_key> additional_tx_keys;
|
||||
rct::multisig_out msout;
|
||||
bool per_output_unlock = use_fork_rules(9, 10);
|
||||
bool r = cryptonote::construct_tx_and_get_tx_key(m_account.get_keys(), m_subaddresses, sd.sources, sd.splitted_dsts, sd.change_dts, sd.extra, ptx.tx, sd.unlock_time, tx_key, additional_tx_keys, sd.use_rct, bulletproof, m_multisig ? &msout : NULL, per_output_unlock);
|
||||
bool r = cryptonote::construct_tx_and_get_tx_key(m_account.get_keys(), m_subaddresses, sd.sources, sd.splitted_dsts, sd.change_dts, sd.extra, ptx.tx, sd.unlock_time, tx_key, additional_tx_keys, sd.use_rct, sd.use_bulletproofs, m_multisig ? &msout : NULL, per_output_unlock);
|
||||
THROW_WALLET_EXCEPTION_IF(!r, error::tx_not_constructed, sd.sources, sd.splitted_dsts, sd.unlock_time, m_nettype);
|
||||
// we don't test tx size, because we don't know the current limit, due to not having a blockchain,
|
||||
// and it's a bit pointless to fail there anyway, since it'd be a (good) guess only. We sign anyway,
|
||||
|
@ -5233,9 +5232,8 @@ bool wallet2::sign_multisig_tx(multisig_tx_set &exported_txs, std::vector<crypto
|
|||
cryptonote::transaction tx;
|
||||
rct::multisig_out msout = ptx.multisig_sigs.front().msout;
|
||||
auto sources = sd.sources;
|
||||
const bool bulletproof = sd.use_rct && (ptx.tx.rct_signatures.type == rct::RCTTypeFullBulletproof || ptx.tx.rct_signatures.type == rct::RCTTypeSimpleBulletproof);
|
||||
bool per_output_unlock = use_fork_rules(9, 10);
|
||||
bool r = cryptonote::construct_tx_with_tx_key(m_account.get_keys(), m_subaddresses, sources, sd.splitted_dsts, ptx.change_dts, sd.extra, tx, sd.unlock_time, ptx.tx_key, ptx.additional_tx_keys, sd.use_rct, bulletproof, &msout, per_output_unlock, false);
|
||||
bool r = cryptonote::construct_tx_with_tx_key(m_account.get_keys(), m_subaddresses, sources, sd.splitted_dsts, ptx.change_dts, sd.extra, tx, sd.unlock_time, ptx.tx_key, ptx.additional_tx_keys, sd.use_rct, sd.use_bulletproofs, &msout, per_output_unlock, false);
|
||||
THROW_WALLET_EXCEPTION_IF(!r, error::tx_not_constructed, sd.sources, sd.splitted_dsts, sd.unlock_time, m_nettype);
|
||||
|
||||
THROW_WALLET_EXCEPTION_IF(get_transaction_prefix_hash (tx) != get_transaction_prefix_hash(ptx.tx),
|
||||
|
@ -6528,6 +6526,7 @@ void wallet2::transfer_selected(const std::vector<cryptonote::tx_destination_ent
|
|||
ptx.construction_data.extra = tx.extra;
|
||||
ptx.construction_data.unlock_time = unlock_time;
|
||||
ptx.construction_data.use_rct = false;
|
||||
ptx.construction_data.use_bulletproofs = false;
|
||||
ptx.construction_data.dests = dsts;
|
||||
// record which subaddress indices are being used as inputs
|
||||
ptx.construction_data.subaddr_account = subaddr_account;
|
||||
|
@ -6785,6 +6784,7 @@ void wallet2::transfer_selected_rct(std::vector<cryptonote::tx_destination_entry
|
|||
ptx.construction_data.extra = tx.extra;
|
||||
ptx.construction_data.unlock_time = unlock_time;
|
||||
ptx.construction_data.use_rct = true;
|
||||
ptx.construction_data.use_bulletproofs = !tx.rct_signatures.p.bulletproofs.empty();
|
||||
ptx.construction_data.dests = dsts;
|
||||
// record which subaddress indices are being used as inputs
|
||||
ptx.construction_data.subaddr_account = subaddr_account;
|
||||
|
|
|
@ -332,6 +332,7 @@ namespace tools
|
|||
std::vector<uint8_t> extra;
|
||||
uint64_t unlock_time;
|
||||
bool use_rct;
|
||||
bool use_bulletproofs;
|
||||
std::vector<cryptonote::tx_destination_entry> dests; // original setup, does not include change
|
||||
uint32_t subaddr_account; // subaddress account of your wallet to be used in this transfer
|
||||
std::set<uint32_t> subaddr_indices; // set of address indices used as inputs in this transfer
|
||||
|
@ -344,6 +345,7 @@ namespace tools
|
|||
FIELD(extra)
|
||||
FIELD(unlock_time)
|
||||
FIELD(use_rct)
|
||||
FIELD(use_bulletproofs)
|
||||
FIELD(dests)
|
||||
FIELD(subaddr_account)
|
||||
FIELD(subaddr_indices)
|
||||
|
@ -1289,7 +1291,7 @@ BOOST_CLASS_VERSION(tools::wallet2::address_book_row, 17)
|
|||
BOOST_CLASS_VERSION(tools::wallet2::reserve_proof_entry, 0)
|
||||
BOOST_CLASS_VERSION(tools::wallet2::unsigned_tx_set, 0)
|
||||
BOOST_CLASS_VERSION(tools::wallet2::signed_tx_set, 0)
|
||||
BOOST_CLASS_VERSION(tools::wallet2::tx_construction_data, 2)
|
||||
BOOST_CLASS_VERSION(tools::wallet2::tx_construction_data, 3)
|
||||
BOOST_CLASS_VERSION(tools::wallet2::pending_tx, 3)
|
||||
BOOST_CLASS_VERSION(tools::wallet2::multisig_sig, 0)
|
||||
|
||||
|
@ -1636,6 +1638,9 @@ namespace boost
|
|||
if (ver < 2)
|
||||
return;
|
||||
a & x.selected_transfers;
|
||||
if (ver < 3)
|
||||
return;
|
||||
a & x.use_bulletproofs;
|
||||
}
|
||||
|
||||
template <class Archive>
|
||||
|
@ -1922,6 +1927,7 @@ namespace tools
|
|||
ptx.construction_data.extra = tx.extra;
|
||||
ptx.construction_data.unlock_time = unlock_time;
|
||||
ptx.construction_data.use_rct = false;
|
||||
ptx.construction_data.use_bulletproofs = false;
|
||||
ptx.construction_data.dests = dsts;
|
||||
// record which subaddress indices are being used as inputs
|
||||
ptx.construction_data.subaddr_account = subaddr_account;
|
||||
|
|
|
@ -158,6 +158,7 @@ namespace
|
|||
}
|
||||
|
||||
virtual bool close() { return true; }
|
||||
virtual bool send_done() { return true; }
|
||||
virtual bool call_run_once_service_io() { return true; }
|
||||
virtual bool request_callback() { return true; }
|
||||
virtual boost::asio::io_service& get_io_service() { return m_io_service; }
|
||||
|
|
|
@ -150,6 +150,7 @@ namespace
|
|||
}
|
||||
|
||||
virtual bool close() { /*std::cout << "test_connection::close()" << std::endl; */return true; }
|
||||
virtual bool send_done() { /*std::cout << "test_connection::send_done()" << std::endl; */return true; }
|
||||
virtual bool call_run_once_service_io() { std::cout << "test_connection::call_run_once_service_io()" << std::endl; return true; }
|
||||
virtual bool request_callback() { std::cout << "test_connection::request_callback()" << std::endl; return true; }
|
||||
virtual boost::asio::io_service& get_io_service() { std::cout << "test_connection::get_io_service()" << std::endl; return m_io_service; }
|
||||
|
|
Loading…
Reference in New Issue