2015-12-31 08:39:56 +02:00
|
|
|
// Copyright (c) 2014-2016, The Monero Project
|
2014-07-23 16:03:52 +03:00
|
|
|
//
|
|
|
|
// All rights reserved.
|
|
|
|
//
|
|
|
|
// Redistribution and use in source and binary forms, with or without modification, are
|
|
|
|
// permitted provided that the following conditions are met:
|
|
|
|
//
|
|
|
|
// 1. Redistributions of source code must retain the above copyright notice, this list of
|
|
|
|
// conditions and the following disclaimer.
|
|
|
|
//
|
|
|
|
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
|
|
|
// of conditions and the following disclaimer in the documentation and/or other
|
|
|
|
// materials provided with the distribution.
|
|
|
|
//
|
|
|
|
// 3. Neither the name of the copyright holder nor the names of its contributors may be
|
|
|
|
// used to endorse or promote products derived from this software without specific
|
|
|
|
// prior written permission.
|
|
|
|
//
|
|
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
|
|
|
|
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
|
|
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
|
|
|
|
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
|
|
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
|
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
|
|
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
|
|
|
|
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
//
|
|
|
|
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
|
2014-03-04 00:07:58 +02:00
|
|
|
|
2014-09-27 15:50:15 +03:00
|
|
|
/*!
|
|
|
|
* \file simplewallet.h
|
|
|
|
*
|
|
|
|
* \brief Header file that declares simple_wallet class.
|
|
|
|
*/
|
2014-03-04 00:07:58 +02:00
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include <memory>
|
|
|
|
|
2016-11-09 05:55:41 +02:00
|
|
|
#include <boost/optional/optional.hpp>
|
2014-03-04 00:07:58 +02:00
|
|
|
#include <boost/program_options/variables_map.hpp>
|
|
|
|
|
2017-01-26 17:07:23 +02:00
|
|
|
#include "cryptonote_basic/account.h"
|
|
|
|
#include "cryptonote_basic/cryptonote_basic_impl.h"
|
2014-03-04 00:07:58 +02:00
|
|
|
#include "wallet/wallet2.h"
|
|
|
|
#include "console_handler.h"
|
2017-02-06 00:48:03 +02:00
|
|
|
#include "common/password.h"
|
2014-06-05 01:59:47 +03:00
|
|
|
#include "crypto/crypto.h" // for definition of crypto::secret_key
|
2014-03-04 00:07:58 +02:00
|
|
|
|
Change logging to easylogging++
This replaces the epee and data_loggers logging systems with
a single one, and also adds filename:line and explicit severity
levels. Categories may be defined, and logging severity set
by category (or set of categories). epee style 0-4 log level
maps to a sensible severity configuration. Log files now also
rotate when reaching 100 MB.
To select which logs to output, use the MONERO_LOGS environment
variable, with a comma separated list of categories (globs are
supported), with their requested severity level after a colon.
If a log matches more than one such setting, the last one in
the configuration string applies. A few examples:
This one is (mostly) silent, only outputting fatal errors:
MONERO_LOGS=*:FATAL
This one is very verbose:
MONERO_LOGS=*:TRACE
This one is totally silent (logwise):
MONERO_LOGS=""
This one outputs all errors and warnings, except for the
"verify" category, which prints just fatal errors (the verify
category is used for logs about incoming transactions and
blocks, and it is expected that some/many will fail to verify,
hence we don't want the spam):
MONERO_LOGS=*:WARNING,verify:FATAL
Log levels are, in decreasing order of priority:
FATAL, ERROR, WARNING, INFO, DEBUG, TRACE
Subcategories may be added using prefixes and globs. This
example will output net.p2p logs at the TRACE level, but all
other net* logs only at INFO:
MONERO_LOGS=*:ERROR,net*:INFO,net.p2p:TRACE
Logs which are intended for the user (which Monero was using
a lot through epee, but really isn't a nice way to go things)
should use the "global" category. There are a few helper macros
for using this category, eg: MGINFO("this shows up by default")
or MGINFO_RED("this is red"), to try to keep a similar look
and feel for now.
Existing epee log macros still exist, and map to the new log
levels, but since they're used as a "user facing" UI element
as much as a logging system, they often don't map well to log
severities (ie, a log level 0 log may be an error, or may be
something we want the user to see, such as an important info).
In those cases, I tried to use the new macros. In other cases,
I left the existing macros in. When modifying logs, it is
probably best to switch to the new macros with explicit levels.
The --log-level options and set_log commands now also accept
category settings, in addition to the epee style log levels.
2017-01-01 18:34:23 +02:00
|
|
|
#undef MONERO_DEFAULT_LOG_CATEGORY
|
|
|
|
#define MONERO_DEFAULT_LOG_CATEGORY "wallet.simplewallet"
|
|
|
|
|
2014-09-27 15:50:15 +03:00
|
|
|
/*!
|
|
|
|
* \namespace cryptonote
|
|
|
|
* \brief Holds cryptonote related classes and helpers.
|
|
|
|
*/
|
2014-03-04 00:07:58 +02:00
|
|
|
namespace cryptonote
|
|
|
|
{
|
2014-09-27 15:50:15 +03:00
|
|
|
/*!
|
|
|
|
* \brief Manages wallet operations. This is the most abstracted wallet class.
|
|
|
|
*/
|
2014-04-02 19:00:17 +03:00
|
|
|
class simple_wallet : public tools::i_wallet2_callback
|
2014-03-04 00:07:58 +02:00
|
|
|
{
|
2015-07-14 22:28:25 +03:00
|
|
|
public:
|
|
|
|
static const char *tr(const char *str) { return i18n_translate(str, "cryptonote::simple_wallet"); }
|
|
|
|
|
2014-03-04 00:07:58 +02:00
|
|
|
public:
|
|
|
|
typedef std::vector<std::string> command_type;
|
|
|
|
|
|
|
|
simple_wallet();
|
|
|
|
bool init(const boost::program_options::variables_map& vm);
|
|
|
|
bool deinit();
|
|
|
|
bool run();
|
2014-03-20 13:46:11 +02:00
|
|
|
void stop();
|
2015-11-29 15:02:01 +02:00
|
|
|
void interrupt();
|
2014-03-04 00:07:58 +02:00
|
|
|
|
|
|
|
//wallet *create_wallet();
|
|
|
|
bool process_command(const std::vector<std::string> &args);
|
|
|
|
std::string get_commands_str();
|
|
|
|
private:
|
2015-11-22 21:03:10 +02:00
|
|
|
bool handle_command_line(const boost::program_options::variables_map& vm);
|
2014-03-04 00:07:58 +02:00
|
|
|
|
|
|
|
bool run_console_handler();
|
|
|
|
|
2016-08-07 15:06:40 +03:00
|
|
|
void wallet_idle_thread();
|
2015-11-28 14:38:58 +02:00
|
|
|
|
2016-12-18 01:07:15 +02:00
|
|
|
//! \return Prompts user for password and verifies against local file. Logs on error and returns `none`
|
|
|
|
boost::optional<tools::password_container> get_and_verify_password() const;
|
|
|
|
|
2016-11-09 05:55:41 +02:00
|
|
|
bool new_wallet(const boost::program_options::variables_map& vm, const crypto::secret_key& recovery_key,
|
|
|
|
bool recover, bool two_random, const std::string &old_language);
|
|
|
|
bool new_wallet(const boost::program_options::variables_map& vm, const cryptonote::account_public_address& address,
|
|
|
|
const boost::optional<crypto::secret_key>& spendkey, const crypto::secret_key& viewkey);
|
|
|
|
bool open_wallet(const boost::program_options::variables_map& vm);
|
2014-03-04 00:07:58 +02:00
|
|
|
bool close_wallet();
|
|
|
|
|
2014-08-05 09:53:30 +03:00
|
|
|
bool viewkey(const std::vector<std::string> &args = std::vector<std::string>());
|
2015-05-20 03:08:37 +03:00
|
|
|
bool spendkey(const std::vector<std::string> &args = std::vector<std::string>());
|
2014-08-01 16:40:18 +03:00
|
|
|
bool seed(const std::vector<std::string> &args = std::vector<std::string>());
|
2014-12-06 16:58:33 +02:00
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief Sets seed language.
|
|
|
|
*
|
|
|
|
* interactive
|
|
|
|
* - prompts for password so wallet can be rewritten
|
|
|
|
* - calls get_mnemonic_language() which prompts for language
|
|
|
|
*
|
|
|
|
* \return success status
|
|
|
|
*/
|
|
|
|
bool seed_set_language(const std::vector<std::string> &args = std::vector<std::string>());
|
2015-07-19 00:03:35 +03:00
|
|
|
bool set_always_confirm_transfers(const std::vector<std::string> &args = std::vector<std::string>());
|
2016-12-23 14:04:54 +02:00
|
|
|
bool set_print_ring_members(const std::vector<std::string> &args = std::vector<std::string>());
|
2015-11-22 14:26:27 +02:00
|
|
|
bool set_store_tx_info(const std::vector<std::string> &args = std::vector<std::string>());
|
2015-10-30 23:16:51 +02:00
|
|
|
bool set_default_mixin(const std::vector<std::string> &args = std::vector<std::string>());
|
2015-11-28 14:38:58 +02:00
|
|
|
bool set_auto_refresh(const std::vector<std::string> &args = std::vector<std::string>());
|
2015-12-05 23:44:25 +02:00
|
|
|
bool set_refresh_type(const std::vector<std::string> &args = std::vector<std::string>());
|
2016-10-01 19:03:53 +03:00
|
|
|
bool set_confirm_missing_payment_id(const std::vector<std::string> &args = std::vector<std::string>());
|
2017-01-27 14:26:52 +02:00
|
|
|
bool set_ask_password(const std::vector<std::string> &args = std::vector<std::string>());
|
2014-03-20 13:46:11 +02:00
|
|
|
bool help(const std::vector<std::string> &args = std::vector<std::string>());
|
2014-03-04 00:07:58 +02:00
|
|
|
bool start_mining(const std::vector<std::string> &args);
|
|
|
|
bool stop_mining(const std::vector<std::string> &args);
|
2014-05-16 01:21:43 +03:00
|
|
|
bool save_bc(const std::vector<std::string>& args);
|
2014-03-04 00:07:58 +02:00
|
|
|
bool refresh(const std::vector<std::string> &args);
|
2016-04-21 02:11:11 +03:00
|
|
|
bool show_balance_unlocked();
|
2014-03-20 13:46:11 +02:00
|
|
|
bool show_balance(const std::vector<std::string> &args = std::vector<std::string>());
|
2014-03-04 00:07:58 +02:00
|
|
|
bool show_incoming_transfers(const std::vector<std::string> &args);
|
2014-05-03 19:19:43 +03:00
|
|
|
bool show_payments(const std::vector<std::string> &args);
|
2014-03-04 00:07:58 +02:00
|
|
|
bool show_blockchain_height(const std::vector<std::string> &args);
|
2016-06-16 01:37:13 +03:00
|
|
|
bool transfer_main(int transfer_type, const std::vector<std::string> &args);
|
2014-03-04 00:07:58 +02:00
|
|
|
bool transfer(const std::vector<std::string> &args);
|
2015-07-20 01:47:13 +03:00
|
|
|
bool transfer_new(const std::vector<std::string> &args);
|
2016-09-28 16:20:37 +03:00
|
|
|
bool locked_transfer(const std::vector<std::string> &args);
|
2016-04-19 23:20:27 +03:00
|
|
|
bool sweep_all(const std::vector<std::string> &args);
|
2016-03-26 23:15:47 +02:00
|
|
|
bool sweep_unmixable(const std::vector<std::string> &args);
|
2016-12-14 13:44:09 +02:00
|
|
|
bool donate(const std::vector<std::string> &args);
|
2016-09-27 01:11:10 +03:00
|
|
|
bool sign_transfer(const std::vector<std::string> &args);
|
|
|
|
bool submit_transfer(const std::vector<std::string> &args);
|
2014-06-16 03:36:44 +03:00
|
|
|
std::vector<std::vector<cryptonote::tx_destination_entry>> split_amounts(
|
|
|
|
std::vector<cryptonote::tx_destination_entry> dsts, size_t num_splits
|
2014-06-16 00:20:16 +03:00
|
|
|
);
|
2014-04-02 19:00:17 +03:00
|
|
|
bool print_address(const std::vector<std::string> &args = std::vector<std::string>());
|
2015-06-11 11:44:13 +03:00
|
|
|
bool print_integrated_address(const std::vector<std::string> &args = std::vector<std::string>());
|
2016-12-21 05:05:29 +02:00
|
|
|
bool address_book(const std::vector<std::string> &args = std::vector<std::string>());
|
2014-03-04 00:07:58 +02:00
|
|
|
bool save(const std::vector<std::string> &args);
|
2015-05-31 17:34:55 +03:00
|
|
|
bool save_watch_only(const std::vector<std::string> &args);
|
2014-12-06 16:58:33 +02:00
|
|
|
bool set_variable(const std::vector<std::string> &args);
|
2015-08-11 17:14:44 +03:00
|
|
|
bool rescan_spent(const std::vector<std::string> &args);
|
2014-03-04 00:07:58 +02:00
|
|
|
bool set_log(const std::vector<std::string> &args);
|
2015-08-19 22:59:44 +03:00
|
|
|
bool get_tx_key(const std::vector<std::string> &args);
|
2015-10-12 02:13:05 +03:00
|
|
|
bool check_tx_key(const std::vector<std::string> &args);
|
2015-11-15 23:59:40 +02:00
|
|
|
bool show_transfers(const std::vector<std::string> &args);
|
2016-12-24 07:31:19 +02:00
|
|
|
bool unspent_outputs(const std::vector<std::string> &args);
|
2015-12-30 14:58:15 +02:00
|
|
|
bool rescan_blockchain(const std::vector<std::string> &args);
|
|
|
|
bool refresh_main(uint64_t start_height, bool reset = false);
|
2016-04-20 20:19:42 +03:00
|
|
|
bool set_tx_note(const std::vector<std::string> &args);
|
|
|
|
bool get_tx_note(const std::vector<std::string> &args);
|
2016-06-20 21:11:10 +03:00
|
|
|
bool status(const std::vector<std::string> &args);
|
2016-09-16 13:50:52 +03:00
|
|
|
bool set_default_priority(const std::vector<std::string> &args);
|
2016-04-23 23:46:48 +03:00
|
|
|
bool sign(const std::vector<std::string> &args);
|
|
|
|
bool verify(const std::vector<std::string> &args);
|
2016-07-15 14:11:55 +03:00
|
|
|
bool export_key_images(const std::vector<std::string> &args);
|
|
|
|
bool import_key_images(const std::vector<std::string> &args);
|
2016-10-30 21:37:09 +02:00
|
|
|
bool export_outputs(const std::vector<std::string> &args);
|
|
|
|
bool import_outputs(const std::vector<std::string> &args);
|
2017-01-08 15:57:24 +02:00
|
|
|
bool show_transfer(const std::vector<std::string> &args);
|
2017-01-27 09:12:18 +02:00
|
|
|
bool change_password(const std::vector<std::string>& args);
|
2014-03-04 00:07:58 +02:00
|
|
|
|
2014-03-20 13:46:11 +02:00
|
|
|
uint64_t get_daemon_blockchain_height(std::string& err);
|
2016-12-23 14:04:54 +02:00
|
|
|
bool try_connect_to_daemon(bool silent = false, uint32_t* version = nullptr);
|
2014-05-03 19:19:43 +03:00
|
|
|
bool ask_wallet_create_if_needed();
|
2016-11-15 23:22:04 +02:00
|
|
|
bool accept_loaded_tx(const std::function<size_t()> get_num_txes, const std::function<const tools::wallet2::tx_construction_data&(size_t)> &get_tx, const std::string &extra_message = std::string());
|
2016-09-27 01:11:10 +03:00
|
|
|
bool accept_loaded_tx(const tools::wallet2::unsigned_tx_set &txs);
|
2016-10-30 12:49:22 +02:00
|
|
|
bool accept_loaded_tx(const tools::wallet2::signed_tx_set &txs);
|
2016-12-23 14:04:54 +02:00
|
|
|
bool print_ring_members(const std::vector<tools::wallet2::pending_tx>& ptx_vector, std::ostream& ostr);
|
2015-11-29 15:02:01 +02:00
|
|
|
|
2014-10-19 12:09:45 +03:00
|
|
|
/*!
|
|
|
|
* \brief Prints the seed with a nice message
|
|
|
|
* \param seed seed to print
|
|
|
|
*/
|
|
|
|
void print_seed(std::string seed);
|
2014-09-27 15:50:15 +03:00
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief Gets the word seed language from the user.
|
|
|
|
*
|
|
|
|
* User is asked to choose from a list of supported languages.
|
|
|
|
*
|
|
|
|
* \return The chosen language.
|
|
|
|
*/
|
2014-09-25 15:34:30 +03:00
|
|
|
std::string get_mnemonic_language();
|
2014-03-04 00:07:58 +02:00
|
|
|
|
2014-04-02 19:00:17 +03:00
|
|
|
//----------------- i_wallet2_callback ---------------------
|
|
|
|
virtual void on_new_block(uint64_t height, const cryptonote::block& block);
|
2016-06-16 01:37:13 +03:00
|
|
|
virtual void on_money_received(uint64_t height, const cryptonote::transaction& tx, uint64_t amount);
|
2017-01-12 19:23:23 +02:00
|
|
|
virtual void on_unconfirmed_money_received(uint64_t height, const cryptonote::transaction& tx, uint64_t amount);
|
2016-06-16 01:37:13 +03:00
|
|
|
virtual void on_money_spent(uint64_t height, const cryptonote::transaction& in_tx, uint64_t amount, const cryptonote::transaction& spend_tx);
|
2014-05-03 19:19:43 +03:00
|
|
|
virtual void on_skip_transaction(uint64_t height, const cryptonote::transaction& tx);
|
2014-04-02 19:00:17 +03:00
|
|
|
//----------------------------------------------------------
|
|
|
|
|
|
|
|
friend class refresh_progress_reporter_t;
|
|
|
|
|
|
|
|
class refresh_progress_reporter_t
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
refresh_progress_reporter_t(cryptonote::simple_wallet& simple_wallet)
|
|
|
|
: m_simple_wallet(simple_wallet)
|
|
|
|
, m_blockchain_height(0)
|
|
|
|
, m_blockchain_height_update_time()
|
|
|
|
, m_print_time()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void update(uint64_t height, bool force = false)
|
|
|
|
{
|
|
|
|
auto current_time = std::chrono::system_clock::now();
|
2016-01-29 17:09:17 +02:00
|
|
|
const auto node_update_threshold = std::chrono::seconds(DIFFICULTY_TARGET_V1 / 2); // use min of V1/V2
|
|
|
|
if (node_update_threshold < current_time - m_blockchain_height_update_time || m_blockchain_height <= height)
|
2014-04-02 19:00:17 +03:00
|
|
|
{
|
|
|
|
update_blockchain_height();
|
|
|
|
m_blockchain_height = (std::max)(m_blockchain_height, height);
|
|
|
|
}
|
|
|
|
|
2015-11-21 13:52:35 +02:00
|
|
|
if (std::chrono::milliseconds(20) < current_time - m_print_time || force)
|
2014-04-02 19:00:17 +03:00
|
|
|
{
|
2015-11-21 13:52:35 +02:00
|
|
|
std::cout << QT_TRANSLATE_NOOP("cryptonote::simple_wallet", "Height ") << height << " / " << m_blockchain_height << '\r' << std::flush;
|
2014-04-02 19:00:17 +03:00
|
|
|
m_print_time = current_time;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
void update_blockchain_height()
|
|
|
|
{
|
|
|
|
std::string err;
|
|
|
|
uint64_t blockchain_height = m_simple_wallet.get_daemon_blockchain_height(err);
|
|
|
|
if (err.empty())
|
|
|
|
{
|
|
|
|
m_blockchain_height = blockchain_height;
|
|
|
|
m_blockchain_height_update_time = std::chrono::system_clock::now();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
LOG_ERROR("Failed to get current blockchain height: " << err);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
cryptonote::simple_wallet& m_simple_wallet;
|
|
|
|
uint64_t m_blockchain_height;
|
|
|
|
std::chrono::system_clock::time_point m_blockchain_height_update_time;
|
|
|
|
std::chrono::system_clock::time_point m_print_time;
|
|
|
|
};
|
|
|
|
|
|
|
|
private:
|
2014-03-04 00:07:58 +02:00
|
|
|
std::string m_wallet_file;
|
|
|
|
std::string m_generate_new;
|
2015-06-20 14:31:53 +03:00
|
|
|
std::string m_generate_from_view_key;
|
2016-02-23 00:10:55 +02:00
|
|
|
std::string m_generate_from_keys;
|
wallet: add a --generate-from-json flag
It takes a filename containing JSON data to generate a wallet.
The following fields are valid:
version: integer, should be 1
filename: string, path/filename for the newly created wallet
scan_from_height: 64 bit unsigned integer, optional
password: string, optional
viewkey: string, hex representation
spendkey: string, hex representation
seed: string, optional, list of words separated by spaces
Either seed or private keys should be given. If using private
keys, the spend key may be omitted (the wallet will not be
able to spend, but will see incoming transactions).
If scan_from_height is given, blocks below this height will not
be checked for transactions as an optimization.
2016-03-25 02:48:11 +02:00
|
|
|
std::string m_generate_from_json;
|
2014-03-04 00:07:58 +02:00
|
|
|
std::string m_import_path;
|
|
|
|
|
2014-06-05 01:59:47 +03:00
|
|
|
std::string m_electrum_seed; // electrum-style seed parameter
|
|
|
|
|
|
|
|
crypto::secret_key m_recovery_key; // recovery key (used as random for wallet gen)
|
2014-06-09 01:59:02 +03:00
|
|
|
bool m_restore_deterministic_wallet; // recover flag
|
2014-06-09 03:04:32 +03:00
|
|
|
bool m_non_deterministic; // old 2-random generation
|
2015-10-11 21:45:59 +03:00
|
|
|
bool m_trusted_daemon;
|
2016-07-10 18:49:40 +03:00
|
|
|
bool m_allow_mismatched_daemon_version;
|
2016-08-10 02:54:20 +03:00
|
|
|
bool m_restoring; // are we restoring, by whatever method?
|
2016-04-15 21:10:20 +03:00
|
|
|
uint64_t m_restore_height; // optional
|
2014-06-05 01:59:47 +03:00
|
|
|
|
2014-03-04 00:07:58 +02:00
|
|
|
epee::console_handlers_binder m_cmd_binder;
|
|
|
|
|
2014-03-20 13:46:11 +02:00
|
|
|
std::unique_ptr<tools::wallet2> m_wallet;
|
2014-05-25 20:06:40 +03:00
|
|
|
epee::net_utils::http::http_simple_client m_http_client;
|
2014-04-02 19:00:17 +03:00
|
|
|
refresh_progress_reporter_t m_refresh_progress_reporter;
|
2015-11-28 14:38:58 +02:00
|
|
|
|
2016-08-07 15:06:40 +03:00
|
|
|
std::atomic<bool> m_idle_run;
|
|
|
|
boost::thread m_idle_thread;
|
|
|
|
boost::mutex m_idle_mutex;
|
|
|
|
boost::condition_variable m_idle_cond;
|
|
|
|
|
|
|
|
std::atomic<bool> m_auto_refresh_enabled;
|
2015-11-28 14:38:58 +02:00
|
|
|
bool m_auto_refresh_refreshing;
|
2015-11-29 15:02:01 +02:00
|
|
|
std::atomic<bool> m_in_manual_refresh;
|
2014-03-04 00:07:58 +02:00
|
|
|
};
|
|
|
|
}
|